Support Aggregate subqueries with paging on MS SQL Server

src/NHibernate.Test/Async/Linq/WhereSubqueryTests.cs

@@ -466,6 +466,50 @@ where subquery.Any(x => x.OrderId == order.OrderId)
 			Assert.That(query.Count, Is.EqualTo(61));
 		}
 
+		[Test]
+		public async Task OrdersWithSubquery9CountAsync()
+		{
+			if (Dialect is MySQLDialect)
+				Assert.Ignore("MySQL does not support LIMIT in subqueries.");
+
+			if (!Dialect.SupportsScalarSubSelects)
+				Assert.Ignore(Dialect.GetType().Name + " does not support scalar sub-queries");
+
+			var ordersQuery = db.Orders
+								.Where(x => x.Employee.EmployeeId > 5)
+								.OrderByDescending(x => x.OrderId)
+								.Take(2);
+
+			var orderLines = await (db.OrderLines
+									.Where(x => ordersQuery.Count(o => o == x.Order) > 0)
+									.OrderBy(x => x.Id)
+									.ToListAsync());
+
+			Assert.That(orderLines.Count, Is.EqualTo(4), nameof(orderLines));
+		}
+
+		[Test]
+		public async Task OrdersWithSubquery9SumAsync()
+		{
+			if (Dialect is MySQLDialect)
+				Assert.Ignore("MySQL does not support LIMIT in subqueries.");
+
+			if (!Dialect.SupportsScalarSubSelects)
+				Assert.Ignore(Dialect.GetType().Name + " does not support scalar sub-queries");
+
+			var ordersQuery = db.Orders
+								.Where(x => x.Employee.EmployeeId > 5)
+								.OrderByDescending(x => x.OrderId)
+								.Take(2);
+
+			var orderLines = await (db.OrderLines
+								.Where(x => ordersQuery.Where(o => o == x.Order).Sum(o => o.Freight.Value) > 0)
+								.OrderBy(x => x.Id)
+								.ToListAsync());
+
+			Assert.That(orderLines.Count, Is.EqualTo(4), nameof(orderLines));
+		}
+
 		[Test(Description = "GH2479")]
 		public async Task OrdersWithSubquery11Async()
 		{

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

@@ -32,6 +32,25 @@ public void DistinctOnAnonymousTypeProjection()
 			Assert.That(result.Length, Is.EqualTo(388));
 		}
 
+		[Test]
+		public void DistinctAndOrderByOnAnonymousTypeProjection()
+		{
+			var result = db.Orders
+							.Where(x => x.ShippingDate != null)
+							.Select(x => new { x.ShippingDate })
+							.OrderByDescending(x => x.ShippingDate)
+							.Distinct()
+							.ToArray();
+
+			var expectedResults = result
+								.OrderByDescending(x => x.ShippingDate)
+								.Distinct()
+								.ToArray();
+
+			Assert.That(result.Length, Is.EqualTo(387));
+			CollectionAssert.AreEqual(expectedResults, result);
+		}
+
 		[Test]
 		public void DistinctOnComplexAnonymousTypeProjection()
 		{

src/NHibernate.Test/Linq/WhereSubqueryTests.cs

@@ -553,6 +553,50 @@ public void OrdersWithSubquery9A()
 			Assert.That(orderLines.Count, Is.EqualTo(711), nameof(orderLines));
 		}
 
+		[Test]
+		public void OrdersWithSubquery9Count()
+		{
+			if (Dialect is MySQLDialect)
+				Assert.Ignore("MySQL does not support LIMIT in subqueries.");
+
+			if (!Dialect.SupportsScalarSubSelects)
+				Assert.Ignore(Dialect.GetType().Name + " does not support scalar sub-queries");
+
+			var ordersQuery = db.Orders
+								.Where(x => x.Employee.EmployeeId > 5)
+								.OrderByDescending(x => x.OrderId)
+								.Take(2);
+
+			var orderLines = db.OrderLines
+									.Where(x => ordersQuery.Count(o => o == x.Order) > 0)
+									.OrderBy(x => x.Id)
+									.ToList();
+
+			Assert.That(orderLines.Count, Is.EqualTo(4), nameof(orderLines));
+		}
+
+		[Test]
+		public void OrdersWithSubquery9Sum()
+		{
+			if (Dialect is MySQLDialect)
+				Assert.Ignore("MySQL does not support LIMIT in subqueries.");
+
+			if (!Dialect.SupportsScalarSubSelects)
+				Assert.Ignore(Dialect.GetType().Name + " does not support scalar sub-queries");
+
+			var ordersQuery = db.Orders
+								.Where(x => x.Employee.EmployeeId > 5)
+								.OrderByDescending(x => x.OrderId)
+								.Take(2);
+
+			var orderLines = db.OrderLines
+								.Where(x => ordersQuery.Where(o => o == x.Order).Sum(o => o.Freight.Value) > 0)
+								.OrderBy(x => x.Id)
+								.ToList();
+
+			Assert.That(orderLines.Count, Is.EqualTo(4), nameof(orderLines));
+		}
+
 		[Test(Description = "GH2479")]
 		public void OrdersWithSubquery10()
 		{

src/NHibernate/Linq/GroupBy/PagingRewriter.cs

@@ -1,4 +1,5 @@
 using System.Linq;
+using NHibernate.Linq.ReWriters;
 using NHibernate.Linq.Visitors;
 using Remotion.Linq;
 using Remotion.Linq.Clauses;
@@ -53,7 +54,7 @@ private static void FlattenSubQuery(SubQueryExpression subQueryExpression, Query
 				var where = new WhereClause(new SubQueryExpression(newSubQueryModel));
 				queryModel.BodyClauses.Add(where);
 
-				if (!queryModel.BodyClauses.OfType<OrderByClause>().Any())
+				if (RemoveUnnecessaryBodyOperators.IsOrderByNeeded(queryModel) && !queryModel.BodyClauses.OfType<OrderByClause>().Any())
 				{
 					var orderByClauses = subQueryModel.BodyClauses.OfType<OrderByClause>();
 					foreach (var orderByClause in orderByClauses)

src/NHibernate/Linq/ReWriters/RemoveUnnecessaryBodyOperators.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using NHibernate.Linq.Expressions;
 using NHibernate.Linq.Visitors;
 using Remotion.Linq;
 using Remotion.Linq.Clauses;
@@ -21,20 +22,33 @@ public static void ReWrite(QueryModel queryModel)
 
 		internal static void RemoveUnnecessaryOrderByClauses(QueryModel queryModel)
 		{
-			if (queryModel.ResultOperators.Count == 1 &&
-			    queryModel.ResultOperators.All(
-				    r => r is ContainsResultOperator || r is AnyResultOperator || r is AllResultOperator))
+			if (IsOrderByNeeded(queryModel))
+				return;
+
+			// For these operators, we can remove any order-by clause
+			var bodyClauses = queryModel.BodyClauses;
+			for (int i = bodyClauses.Count - 1; i >= 0; i--)
 			{
-				// For these operators, we can remove any order-by clause
-				var bodyClauses = queryModel.BodyClauses;
-				for (int i = bodyClauses.Count - 1; i >= 0; i--)
-				{
-					if (bodyClauses[i] is OrderByClause)
-						bodyClauses.RemoveAt(i);
-				}
+				if (bodyClauses[i] is OrderByClause)
+					bodyClauses.RemoveAt(i);
 			}
 		}
 
+		internal static bool IsOrderByNeeded(QueryModel queryModel)
+		{
+			switch (queryModel.ResultOperators.Count)
+			{
+				case 1:
+					var r = queryModel.ResultOperators[0];
+					return !(r is AnyResultOperator || r is AllResultOperator || r is ContainsResultOperator);
+				case 0:
+					var s = queryModel.SelectClause.Selector;
+					return !(s is NhAggregatedExpression) || s is NhDistinctExpression;
+			}
+
+			return true;
+		}
+
 		public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
 		{
 			if (resultOperator is CountResultOperator || resultOperator is LongCountResultOperator)