From d4b0f5acb05497156736953f693ec2c40eff5b7e Mon Sep 17 00:00:00 2001 From: Alex Zaytsev Date: Fri, 29 Jul 2022 13:04:14 +1200 Subject: [PATCH 01/10] Add test for #3076 --- src/NHibernate.Test/Linq/ByMethod/GroupByTests.cs | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/NHibernate.Test/Linq/ByMethod/GroupByTests.cs b/src/NHibernate.Test/Linq/ByMethod/GroupByTests.cs index 2b5bab7bcab..df96ab07ca0 100644 --- a/src/NHibernate.Test/Linq/ByMethod/GroupByTests.cs +++ b/src/NHibernate.Test/Linq/ByMethod/GroupByTests.cs @@ -840,6 +840,15 @@ public void GroupByComputedValueFromNestedObjectSelect() Assert.AreEqual(2155, orderGroups.Sum(g => g.Count)); } + [Test(Description="GH-3076")] + public void NestedGroupBy() + { + var list = db.OrderLines + .GroupBy(x => new { x.Order.OrderId, x.Product.ProductId }) // this works fine + .GroupBy(x => x.Key.ProductId) // exception: "A recognition error occurred" + .ToList(); + } + private static void CheckGrouping(IEnumerable> groupedItems, Func groupBy) { var used = new HashSet(); From c7726c223142da045b1ed4e3815afb7af72b84a0 Mon Sep 17 00:00:00 2001 From: Alex Zaytsev Date: Fri, 29 Jul 2022 15:17:40 +1200 Subject: [PATCH 02/10] WIP Next step would be to change ProcessNonAggregatingGroupBy to correctly detect source expression for second result operator --- .../GroupBy/NonAggregatingGroupByRewriter.cs | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs index 90bc4c1884c..a80810af95c 100644 --- a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs +++ b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs @@ -1,6 +1,8 @@ using System; +using System.Linq; using System.Linq.Expressions; using NHibernate.Linq.ResultOperators; +using NHibernate.Util; using Remotion.Linq; using Remotion.Linq.Clauses; using Remotion.Linq.Clauses.ExpressionVisitors; @@ -13,13 +15,18 @@ public static class NonAggregatingGroupByRewriter { public static void ReWrite(QueryModel queryModel) { - if (queryModel.ResultOperators.Count == 1 - && queryModel.ResultOperators[0] is GroupResultOperator - && IsNonAggregatingGroupBy(queryModel)) + if (queryModel.ResultOperators.All(r => r is GroupResultOperator) + && IsNonAggregatingGroupBy(queryModel)) { - var resultOperator = (GroupResultOperator)queryModel.ResultOperators[0]; + var resultOperators = queryModel.ResultOperators + .ToArray(r => new NonAggregatingGroupBy((GroupResultOperator) r)); + queryModel.ResultOperators.Clear(); - queryModel.ResultOperators.Add(new NonAggregatingGroupBy(resultOperator)); + foreach (var resultOperator in resultOperators) + { + queryModel.ResultOperators.Add(resultOperator); + } + return; } @@ -103,4 +110,4 @@ public ClientSideSelect2(LambdaExpression selectClause) SelectClause = selectClause; } } -} \ No newline at end of file +} From e084a8a5d41fce0e1ebc82017c6044999b581c72 Mon Sep 17 00:00:00 2001 From: Alex Zaytsev Date: Fri, 29 Jul 2022 16:08:08 +1200 Subject: [PATCH 03/10] Correctly set source for chained group by operators --- .../Linq/ByMethod/GroupByTests.cs | 2 ++ .../GroupBy/NonAggregatingGroupByRewriter.cs | 14 ++++++-------- .../ResultOperators/NonAggregatingGroupBy.cs | 17 ++++++++++++++--- .../ProcessNonAggregatingGroupBy.cs | 2 +- 4 files changed, 23 insertions(+), 12 deletions(-) diff --git a/src/NHibernate.Test/Linq/ByMethod/GroupByTests.cs b/src/NHibernate.Test/Linq/ByMethod/GroupByTests.cs index df96ab07ca0..feab44d0621 100644 --- a/src/NHibernate.Test/Linq/ByMethod/GroupByTests.cs +++ b/src/NHibernate.Test/Linq/ByMethod/GroupByTests.cs @@ -847,6 +847,8 @@ public void NestedGroupBy() .GroupBy(x => new { x.Order.OrderId, x.Product.ProductId }) // this works fine .GroupBy(x => x.Key.ProductId) // exception: "A recognition error occurred" .ToList(); + + Assert.That(list, Has.Count.EqualTo(77)); } private static void CheckGrouping(IEnumerable> groupedItems, Func groupBy) diff --git a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs index a80810af95c..eb811526df1 100644 --- a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs +++ b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs @@ -2,7 +2,6 @@ using System.Linq; using System.Linq.Expressions; using NHibernate.Linq.ResultOperators; -using NHibernate.Util; using Remotion.Linq; using Remotion.Linq.Clauses; using Remotion.Linq.Clauses.ExpressionVisitors; @@ -18,13 +17,12 @@ public static void ReWrite(QueryModel queryModel) if (queryModel.ResultOperators.All(r => r is GroupResultOperator) && IsNonAggregatingGroupBy(queryModel)) { - var resultOperators = queryModel.ResultOperators - .ToArray(r => new NonAggregatingGroupBy((GroupResultOperator) r)); - - queryModel.ResultOperators.Clear(); - foreach (var resultOperator in resultOperators) + var source = queryModel.SelectClause.Selector; + for (var index = 0; index < queryModel.ResultOperators.Count; index++) { - queryModel.ResultOperators.Add(resultOperator); + var r = (GroupResultOperator) queryModel.ResultOperators[index]; + queryModel.ResultOperators[index] = new NonAggregatingGroupBy(r, source); + source = new QuerySourceReferenceExpression(r); } return; @@ -65,7 +63,7 @@ private static void FlattenSubQuery(SubQueryExpression subQueryExpression, Query throw new NotImplementedException(); } - queryModel.ResultOperators.Add(new NonAggregatingGroupBy((GroupResultOperator) subQueryModel.ResultOperators[0])); + queryModel.ResultOperators.Add(new NonAggregatingGroupBy((GroupResultOperator) subQueryModel.ResultOperators[0], queryModel.SelectClause.Selector)); queryModel.ResultOperators.Add(clientSideSelect); } diff --git a/src/NHibernate/Linq/ResultOperators/NonAggregatingGroupBy.cs b/src/NHibernate/Linq/ResultOperators/NonAggregatingGroupBy.cs index 93b86f9f171..fa9ea5034ab 100644 --- a/src/NHibernate/Linq/ResultOperators/NonAggregatingGroupBy.cs +++ b/src/NHibernate/Linq/ResultOperators/NonAggregatingGroupBy.cs @@ -1,14 +1,25 @@ +using System; +using System.Linq.Expressions; using Remotion.Linq.Clauses.ResultOperators; namespace NHibernate.Linq.ResultOperators { public class NonAggregatingGroupBy : ClientSideTransformOperator { - public NonAggregatingGroupBy(GroupResultOperator groupBy) + //Since v5.4 + [Obsolete("Please use another constructor")] + public NonAggregatingGroupBy(GroupResultOperator groupBy) : this(groupBy, null) + { + } + + public NonAggregatingGroupBy(GroupResultOperator groupBy, Expression source) { GroupBy = groupBy; + Source = source; } - public GroupResultOperator GroupBy { get; private set; } + public GroupResultOperator GroupBy { get; } + + public Expression Source { get; } } -} \ No newline at end of file +} diff --git a/src/NHibernate/Linq/Visitors/ResultOperatorProcessors/ProcessNonAggregatingGroupBy.cs b/src/NHibernate/Linq/Visitors/ResultOperatorProcessors/ProcessNonAggregatingGroupBy.cs index 21c82a87eb0..f8c50d8c56d 100644 --- a/src/NHibernate/Linq/Visitors/ResultOperatorProcessors/ProcessNonAggregatingGroupBy.cs +++ b/src/NHibernate/Linq/Visitors/ResultOperatorProcessors/ProcessNonAggregatingGroupBy.cs @@ -11,7 +11,7 @@ public class ProcessNonAggregatingGroupBy : IResultOperatorProcessor Date: Fri, 29 Jul 2022 16:54:30 +1200 Subject: [PATCH 04/10] Fix broken tests --- src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs index eb811526df1..3e33893e43d 100644 --- a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs +++ b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs @@ -14,7 +14,8 @@ public static class NonAggregatingGroupByRewriter { public static void ReWrite(QueryModel queryModel) { - if (queryModel.ResultOperators.All(r => r is GroupResultOperator) + if (queryModel.ResultOperators.Count > 0 + && queryModel.ResultOperators.All(r => r is GroupResultOperator) && IsNonAggregatingGroupBy(queryModel)) { var source = queryModel.SelectClause.Selector; From dc201c1450a49790084be813a3112c328dcec7ad Mon Sep 17 00:00:00 2001 From: "deepsource-autofix[bot]" <62050782+deepsource-autofix[bot]@users.noreply.github.com> Date: Sun, 31 Jul 2022 21:41:26 +0000 Subject: [PATCH 05/10] Autofix issues in 1 file Resolved issues in src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs via DeepSource Autofix --- src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs index 3e33893e43d..4a49a9c2cc1 100644 --- a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs +++ b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs @@ -29,9 +29,7 @@ public static void ReWrite(QueryModel queryModel) return; } - var subQueryExpression = queryModel.MainFromClause.FromExpression as SubQueryExpression; - - if ((subQueryExpression != null) + if ((queryModel.MainFromClause.FromExpression is SubQueryExpression subQueryExpression) && (subQueryExpression.QueryModel.ResultOperators.Count == 1) && (subQueryExpression.QueryModel.ResultOperators[0] is GroupResultOperator) && (IsNonAggregatingGroupBy(queryModel))) From 501ed871f1ec2550ff020d70d55c2ad541b18029 Mon Sep 17 00:00:00 2001 From: Alex Zaytsev Date: Tue, 2 Aug 2022 19:03:40 +1200 Subject: [PATCH 06/10] Refactoring --- .../Linq/GroupBy/NonAggregatingGroupByRewriter.cs | 4 ++-- .../Linq/ResultOperators/NonAggregatingGroupBy.cs | 15 ++++----------- .../ProcessNonAggregatingGroupBy.cs | 3 ++- 3 files changed, 8 insertions(+), 14 deletions(-) diff --git a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs index 4a49a9c2cc1..81eae0f4761 100644 --- a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs +++ b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs @@ -22,7 +22,7 @@ public static void ReWrite(QueryModel queryModel) for (var index = 0; index < queryModel.ResultOperators.Count; index++) { var r = (GroupResultOperator) queryModel.ResultOperators[index]; - queryModel.ResultOperators[index] = new NonAggregatingGroupBy(r, source); + queryModel.ResultOperators[index] = new NonAggregatingGroupBy(r); source = new QuerySourceReferenceExpression(r); } @@ -62,7 +62,7 @@ private static void FlattenSubQuery(SubQueryExpression subQueryExpression, Query throw new NotImplementedException(); } - queryModel.ResultOperators.Add(new NonAggregatingGroupBy((GroupResultOperator) subQueryModel.ResultOperators[0], queryModel.SelectClause.Selector)); + queryModel.ResultOperators.Add(new NonAggregatingGroupBy((GroupResultOperator) subQueryModel.ResultOperators[0])); queryModel.ResultOperators.Add(clientSideSelect); } diff --git a/src/NHibernate/Linq/ResultOperators/NonAggregatingGroupBy.cs b/src/NHibernate/Linq/ResultOperators/NonAggregatingGroupBy.cs index fa9ea5034ab..69fd5a3772d 100644 --- a/src/NHibernate/Linq/ResultOperators/NonAggregatingGroupBy.cs +++ b/src/NHibernate/Linq/ResultOperators/NonAggregatingGroupBy.cs @@ -1,25 +1,18 @@ -using System; -using System.Linq.Expressions; using Remotion.Linq.Clauses.ResultOperators; +using Remotion.Linq.Clauses.StreamedData; namespace NHibernate.Linq.ResultOperators { public class NonAggregatingGroupBy : ClientSideTransformOperator { - //Since v5.4 - [Obsolete("Please use another constructor")] - public NonAggregatingGroupBy(GroupResultOperator groupBy) : this(groupBy, null) - { - } - - public NonAggregatingGroupBy(GroupResultOperator groupBy, Expression source) + public NonAggregatingGroupBy(GroupResultOperator groupBy) { GroupBy = groupBy; - Source = source; } public GroupResultOperator GroupBy { get; } - public Expression Source { get; } + public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo) => + GroupBy.GetOutputDataInfo(inputInfo); } } diff --git a/src/NHibernate/Linq/Visitors/ResultOperatorProcessors/ProcessNonAggregatingGroupBy.cs b/src/NHibernate/Linq/Visitors/ResultOperatorProcessors/ProcessNonAggregatingGroupBy.cs index f8c50d8c56d..133f2f23572 100644 --- a/src/NHibernate/Linq/Visitors/ResultOperatorProcessors/ProcessNonAggregatingGroupBy.cs +++ b/src/NHibernate/Linq/Visitors/ResultOperatorProcessors/ProcessNonAggregatingGroupBy.cs @@ -4,6 +4,7 @@ using NHibernate.Linq.ResultOperators; using NHibernate.Util; using Remotion.Linq.Clauses.ExpressionVisitors; +using Remotion.Linq.Clauses.StreamedData; namespace NHibernate.Linq.Visitors.ResultOperatorProcessors { @@ -11,7 +12,7 @@ public class ProcessNonAggregatingGroupBy : IResultOperatorProcessor Date: Tue, 2 Aug 2022 20:05:12 +1200 Subject: [PATCH 07/10] Add support for select after nested group by --- .../Linq/ByMethod/GroupByTests.cs | 14 +++++++++++- .../GroupBy/NonAggregatingGroupByRewriter.cs | 22 ++++++++++--------- 2 files changed, 25 insertions(+), 11 deletions(-) diff --git a/src/NHibernate.Test/Linq/ByMethod/GroupByTests.cs b/src/NHibernate.Test/Linq/ByMethod/GroupByTests.cs index feab44d0621..92f8457c0c5 100644 --- a/src/NHibernate.Test/Linq/ByMethod/GroupByTests.cs +++ b/src/NHibernate.Test/Linq/ByMethod/GroupByTests.cs @@ -841,7 +841,7 @@ public void GroupByComputedValueFromNestedObjectSelect() } [Test(Description="GH-3076")] - public void NestedGroupBy() + public void NestedNonAggregateGroupBy() { var list = db.OrderLines .GroupBy(x => new { x.Order.OrderId, x.Product.ProductId }) // this works fine @@ -851,6 +851,18 @@ public void NestedGroupBy() Assert.That(list, Has.Count.EqualTo(77)); } + [Test(Description="GH-3076")] + public void NestedNonAggregateGroupBySelect() + { + var list = db.OrderLines + .GroupBy(x => new { x.Order.OrderId, x.Product.ProductId }) // this works fine + .GroupBy(x => x.Key.ProductId) // exception: "A recognition error occurred" + .Select(x => new { ProductId = x }) + .ToList(); + + Assert.That(list, Has.Count.EqualTo(77)); + } + private static void CheckGrouping(IEnumerable> groupedItems, Func groupBy) { var used = new HashSet(); diff --git a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs index 81eae0f4761..1ab8b0e7fb8 100644 --- a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs +++ b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs @@ -18,21 +18,19 @@ public static void ReWrite(QueryModel queryModel) && queryModel.ResultOperators.All(r => r is GroupResultOperator) && IsNonAggregatingGroupBy(queryModel)) { - var source = queryModel.SelectClause.Selector; - for (var index = 0; index < queryModel.ResultOperators.Count; index++) + for (var i = 0; i < queryModel.ResultOperators.Count; i++) { - var r = (GroupResultOperator) queryModel.ResultOperators[index]; - queryModel.ResultOperators[index] = new NonAggregatingGroupBy(r); - source = new QuerySourceReferenceExpression(r); + var r = (GroupResultOperator) queryModel.ResultOperators[i]; + queryModel.ResultOperators[i] = new NonAggregatingGroupBy(r); } return; } - if ((queryModel.MainFromClause.FromExpression is SubQueryExpression subQueryExpression) - && (subQueryExpression.QueryModel.ResultOperators.Count == 1) - && (subQueryExpression.QueryModel.ResultOperators[0] is GroupResultOperator) - && (IsNonAggregatingGroupBy(queryModel))) + if (queryModel.MainFromClause.FromExpression is SubQueryExpression subQueryExpression + && subQueryExpression.QueryModel.ResultOperators.Count > 0 + && subQueryExpression.QueryModel.ResultOperators.All(r => r is GroupResultOperator) + && IsNonAggregatingGroupBy(queryModel)) { FlattenSubQuery(subQueryExpression, queryModel); } @@ -62,7 +60,11 @@ private static void FlattenSubQuery(SubQueryExpression subQueryExpression, Query throw new NotImplementedException(); } - queryModel.ResultOperators.Add(new NonAggregatingGroupBy((GroupResultOperator) subQueryModel.ResultOperators[0])); + for (var i = 0; i < subQueryModel.ResultOperators.Count; i++) + { + queryModel.ResultOperators.Add(new NonAggregatingGroupBy((GroupResultOperator) subQueryModel.ResultOperators[i])); + } + queryModel.ResultOperators.Add(clientSideSelect); } From 7b600de27a3e5de911fed7319ddc62c275e3fd4b Mon Sep 17 00:00:00 2001 From: Alex Zaytsev Date: Tue, 2 Aug 2022 20:07:57 +1200 Subject: [PATCH 08/10] Minor code cleanup --- .../Linq/GroupBy/NonAggregatingGroupByRewriter.cs | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs index 1ab8b0e7fb8..f33f2261708 100644 --- a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs +++ b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs @@ -15,13 +15,13 @@ public static class NonAggregatingGroupByRewriter public static void ReWrite(QueryModel queryModel) { if (queryModel.ResultOperators.Count > 0 - && queryModel.ResultOperators.All(r => r is GroupResultOperator) - && IsNonAggregatingGroupBy(queryModel)) + && queryModel.ResultOperators.All(r => r is GroupResultOperator) + && IsNonAggregatingGroupBy(queryModel)) { for (var i = 0; i < queryModel.ResultOperators.Count; i++) { - var r = (GroupResultOperator) queryModel.ResultOperators[i]; - queryModel.ResultOperators[i] = new NonAggregatingGroupBy(r); + var resultOperator = (GroupResultOperator) queryModel.ResultOperators[i]; + queryModel.ResultOperators[i] = new NonAggregatingGroupBy(resultOperator ); } return; @@ -62,7 +62,8 @@ private static void FlattenSubQuery(SubQueryExpression subQueryExpression, Query for (var i = 0; i < subQueryModel.ResultOperators.Count; i++) { - queryModel.ResultOperators.Add(new NonAggregatingGroupBy((GroupResultOperator) subQueryModel.ResultOperators[i])); + var resultOperator = new NonAggregatingGroupBy((GroupResultOperator) subQueryModel.ResultOperators[i]); + queryModel.ResultOperators.Add(resultOperator); } queryModel.ResultOperators.Add(clientSideSelect); From 1c54c9d1346834c1ada6e23a5a922bcaff0b9740 Mon Sep 17 00:00:00 2001 From: Alex Zaytsev Date: Tue, 2 Aug 2022 20:15:30 +1200 Subject: [PATCH 09/10] Regenerate async tests --- .../Async/Linq/ByMethod/GroupByTests.cs | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/src/NHibernate.Test/Async/Linq/ByMethod/GroupByTests.cs b/src/NHibernate.Test/Async/Linq/ByMethod/GroupByTests.cs index f23b8f2d14d..e2c553cfbcc 100644 --- a/src/NHibernate.Test/Async/Linq/ByMethod/GroupByTests.cs +++ b/src/NHibernate.Test/Async/Linq/ByMethod/GroupByTests.cs @@ -851,6 +851,29 @@ public async Task GroupByComputedValueFromNestedObjectSelectAsync() Assert.AreEqual(2155, orderGroups.Sum(g => g.Count)); } + [Test(Description="GH-3076")] + public async Task NestedNonAggregateGroupByAsync() + { + var list = await (db.OrderLines + .GroupBy(x => new { x.Order.OrderId, x.Product.ProductId }) // this works fine + .GroupBy(x => x.Key.ProductId) // exception: "A recognition error occurred" + .ToListAsync()); + + Assert.That(list, Has.Count.EqualTo(77)); + } + + [Test(Description="GH-3076")] + public async Task NestedNonAggregateGroupBySelectAsync() + { + var list = await (db.OrderLines + .GroupBy(x => new { x.Order.OrderId, x.Product.ProductId }) // this works fine + .GroupBy(x => x.Key.ProductId) // exception: "A recognition error occurred" + .Select(x => new { ProductId = x }) + .ToListAsync()); + + Assert.That(list, Has.Count.EqualTo(77)); + } + private static void CheckGrouping(IEnumerable> groupedItems, Func groupBy) { var used = new HashSet(); From cbbc747aabd319b6ffa93a91d5671af40808cd42 Mon Sep 17 00:00:00 2001 From: Alex Zaytsev Date: Sun, 7 Aug 2022 22:06:41 +0000 Subject: [PATCH 10/10] Fix formatting MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Frédéric Delaporte <12201973+fredericDelaporte@users.noreply.github.com> --- src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs index f33f2261708..7231d3c0414 100644 --- a/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs +++ b/src/NHibernate/Linq/GroupBy/NonAggregatingGroupByRewriter.cs @@ -21,7 +21,7 @@ public static void ReWrite(QueryModel queryModel) for (var i = 0; i < queryModel.ResultOperators.Count; i++) { var resultOperator = (GroupResultOperator) queryModel.ResultOperators[i]; - queryModel.ResultOperators[i] = new NonAggregatingGroupBy(resultOperator ); + queryModel.ResultOperators[i] = new NonAggregatingGroupBy(resultOperator); } return;