Move the GroupingLevel

3 files changed, 138 insertions, 179 deletions

diff --git a/searchlib/src/tests/grouping/grouping_test.cpp b/searchlib/src/tests/grouping/grouping_test.cpp
index 10a594696d6..a8c879550dd 100644
--- a/searchlib/src/tests/grouping/grouping_test.cpp
+++ b/searchlib/src/tests/grouping/grouping_test.cpp
@@ -325,6 +325,37 @@ void Test::testAggregationSimpleSum(AggregationContext & ctx, const AggregationR
     EXPECT_TRUE(testAggregation(ctx, request, expect));
 }
 
+GroupingLevel
+createGL(ExpressionNode::UP expr, ExpressionNode::UP resultExpr) {
+    GroupingLevel l;
+    l.setExpression(std::move(expr));
+    l.addResult(SumAggregationResult().setExpression(std::move(resultExpr)));
+    return l;
+}
+
+GroupingLevel
+createGL(ExpressionNode::UP expr) {
+    GroupingLevel l;
+    l.setExpression(std::move(expr));
+    return l;
+}
+
+GroupingLevel
+createGL(size_t maxGroups, ExpressionNode::UP expr) {
+    GroupingLevel l;
+    l.setMaxGroups(maxGroups);
+    l.setExpression(std::move(expr));
+    return l;
+}
+
+GroupingLevel
+createGL(size_t maxGroups, ExpressionNode::UP expr, ExpressionNode::UP result) {
+    GroupingLevel l;
+    l.setMaxGroups(maxGroups);
+    l.setExpression(std::move(expr));
+    l.addResult(SumAggregationResult().setExpression(std::move(result)));
+    return l;
+}
 /**
  * Verify that the backend aggregation will classify and collect on
  * the appropriate levels, as indicated by the firstLevel and
@@ -343,12 +374,9 @@ Test::testAggregationLevels()
     Grouping baseRequest;
     baseRequest
             .setRoot(Group().addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr0"))))
-            .addLevel(GroupingLevel().setExpression(MU<AttributeNode>("attr1"))
-                                     .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr2"))))
-            .addLevel(GroupingLevel().setExpression(MU<AttributeNode>("attr2"))
-                                     .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr3"))))
-            .addLevel(GroupingLevel().setExpression(MU<AttributeNode>("attr3"))
-                                     .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr1"))));
+            .addLevel(createGL(MU<AttributeNode>("attr1"), MU<AttributeNode>("attr2")))
+            .addLevel(createGL(MU<AttributeNode>("attr2"), MU<AttributeNode>("attr3")))
+            .addLevel(createGL(MU<AttributeNode>("attr3"), MU<AttributeNode>("attr1")));
 
     Group notDone;
     notDone.addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr0")));
@@ -458,9 +486,7 @@ Test::testAggregationMaxGroups()
     ctx.add(IntAttrBuilder("attr").add(5).add(10).add(15).sp());
     ctx.result().add(0).add(1).add(2);
 
-    Grouping baseRequest = Grouping()
-                           .addLevel(GroupingLevel()
-                                     .setExpression(MU<AttributeNode>("attr")));
+    Grouping baseRequest = Grouping().addLevel(createGL(MU<AttributeNode>("attr")));
 
     Group empty = Group();
     Group grp1 = empty.unchain().addChild(Group().setId(Int64ResultNode(5)));
@@ -510,7 +536,7 @@ Test::testAggregationGroupOrder()
     ctx.result().add(0).add(1).add(2).add(3).add(4).add(5).add(6);
 
     Grouping request;
-    request.addLevel(GroupingLevel().setExpression(MU<AttributeNode>("attr")));
+    request.addLevel(createGL(MU<AttributeNode>("attr")));
 
     Group expect;
     expect.addChild(Group().setId(Int64ResultNode(5)))
@@ -540,8 +566,7 @@ Test::testAggregationGroupRank()
         .add(3, 10).add(4, 15).add(5, 5)
         .add(6, 15).add(7, 5).add(8, 10);
 
-    Grouping request = Grouping().addLevel(
-                           GroupingLevel().setExpression(MU<AttributeNode>("attr")));
+    Grouping request = Grouping().addLevel(createGL(MU<AttributeNode>("attr")));
 
     Group expect = Group()
                    .addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(15)))
@@ -581,7 +606,7 @@ Test::testAggregationGroupCapping()
         .add(6, 7).add(7, 8).add(8, 9);
 
     {
-        Grouping request = Grouping().addLevel(GroupingLevel().setExpression(MU<AttributeNode>("attr")));
+        Grouping request = Grouping().addLevel(createGL(MU<AttributeNode>("attr")));
 
         Group expect;
         expect.addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(1)))
@@ -598,7 +623,7 @@ Test::testAggregationGroupCapping()
     }
     {
         Grouping request;
-        request.addLevel(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr")));
+        request.addLevel(createGL(3, MU<AttributeNode>("attr")));
 
         Group expect;
         expect.addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7)))
@@ -611,9 +636,9 @@ Test::testAggregationGroupCapping()
         Grouping request;
         request.setFirstLevel(0)
                 .setLastLevel(1)
-                .addLevel(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr"))
+                .addLevel(std::move(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr"))
                                   .addAggregationResult(createAggr<SumAggregationResult>(MU<AttributeNode>("attr")))
-                                  .addOrderBy(MU<AggregationRefNode>(0), false));
+                                  .addOrderBy(MU<AggregationRefNode>(0), false)));
 
         Group expect;
         expect.addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7))
@@ -632,11 +657,9 @@ Test::testAggregationGroupCapping()
         Grouping request;
         request.setFirstLevel(0)
                 .setLastLevel(1)
-                .addLevel(GroupingLevel()
-                                  .setMaxGroups(3)
-                                  .setExpression(MU<AttributeNode>("attr"))
+                .addLevel(std::move(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr"))
                                   .addAggregationResult(createAggr<SumAggregationResult>(MU<AttributeNode>("attr")))
-                                  .addOrderBy(MU<AggregationRefNode>(0), true));
+                                  .addOrderBy(MU<AggregationRefNode>(0), true)));
 
         Group expect = Group()
                        .addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(1))
@@ -659,9 +682,9 @@ Test::testAggregationGroupCapping()
         Grouping request;
         request.setFirstLevel(0)
                 .setLastLevel(1)
-                .addLevel(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr"))
+                .addLevel(std::move(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr"))
                                   .addAggregationResult(createAggr<SumAggregationResult>(MU<AttributeNode>("attr")))
-                                  .addOrderBy(ExpressionNode::UP(add), false));
+                                  .addOrderBy(ExpressionNode::UP(add), false)));
 
         Group expect;
         expect.addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7))
@@ -718,19 +741,10 @@ Test::testMergeSimpleSum()
 void
 Test::testMergeLevels()
 {
-    Grouping request = Grouping()
-                       .addLevel(GroupingLevel()
-                                 .setExpression(MU<AttributeNode>("c1"))
-                                 .addResult(SumAggregationResult()
-                                         .setExpression(MU<AttributeNode>("s1"))))
-                       .addLevel(GroupingLevel()
-                                 .setExpression(MU<AttributeNode>("c2"))
-                                 .addResult(SumAggregationResult()
-                                         .setExpression(MU<AttributeNode>("s2"))))
-                       .addLevel(GroupingLevel()
-                                 .setExpression(MU<AttributeNode>("c3"))
-                                 .addResult(SumAggregationResult()
-                                         .setExpression(MU<AttributeNode>("s3"))));
+    Grouping request;
+    request.addLevel(createGL(MU<AttributeNode>("c1"), MU<AttributeNode>("s1")))
+           .addLevel(createGL(MU<AttributeNode>("c2"), MU<AttributeNode>("s2")))
+           .addLevel(createGL(MU<AttributeNode>("c3"), MU<AttributeNode>("s3")));
 
     Group a = Group()
               .setId(NullResultNode())
@@ -907,9 +921,8 @@ Test::testMergeLevels()
 void
 Test::testMergeGroups()
 {
-    Grouping request = Grouping()
-                       .addLevel(GroupingLevel()
-                                 .setExpression(MU<AttributeNode>("attr")));
+    Grouping request;
+    request.addLevel(createGL(MU<AttributeNode>("attr")));
 
     Group a = Group()
               .setId(NullResultNode())
@@ -970,22 +983,10 @@ Test::testMergeGroups()
 void
 Test::testMergeTrees()
 {
-    Grouping request = Grouping()
-                       .addLevel(GroupingLevel()
-                                 .setMaxGroups(3)
-                                 .setExpression(MU<AttributeNode>("c1"))
-                                 .addResult(SumAggregationResult()
-                                         .setExpression(MU<AttributeNode>("s1"))))
-                       .addLevel(GroupingLevel()
-                                 .setMaxGroups(2)
-                                 .setExpression(MU<AttributeNode>("c2"))
-                                 .addResult(SumAggregationResult()
-                                         .setExpression(MU<AttributeNode>("s2"))))
-                       .addLevel(GroupingLevel()
-                                 .setMaxGroups(1)
-                                 .setExpression(MU<AttributeNode>("c3"))
-                                 .addResult(SumAggregationResult()
-                                         .setExpression(MU<AttributeNode>("s3"))));
+    Grouping request;
+    request.addLevel(createGL(3, MU<AttributeNode>("c1"), MU<AttributeNode>("s1")))
+           .addLevel(createGL(2, MU<AttributeNode>("c2"), MU<AttributeNode>("s2")))
+           .addLevel(createGL(1, MU<AttributeNode>("c3"), MU<AttributeNode>("s3")));
 
     Group a = Group()
               .setId(NullResultNode())
@@ -1387,19 +1388,10 @@ Test::testPruneComplex()
 void
 Test::testPartialMerging()
 {
-    Grouping baseRequest = Grouping()
-                           .addLevel(GroupingLevel()
-                                     .setExpression(MU<AttributeNode>("c1"))
-                                     .addResult(SumAggregationResult()
-                                                .setExpression(MU<AttributeNode>("s1"))))
-                           .addLevel(GroupingLevel()
-                                     .setExpression(MU<AttributeNode>("c2"))
-                                     .addResult(SumAggregationResult()
-                                                .setExpression(MU<AttributeNode>("s2"))))
-                           .addLevel(GroupingLevel()
-                                     .setExpression(MU<AttributeNode>("c3"))
-                                     .addResult(SumAggregationResult()
-                                                .setExpression(MU<AttributeNode>("s3"))));
+    Grouping baseRequest;
+    baseRequest.addLevel(createGL(MU<AttributeNode>("c1"), MU<AttributeNode>("s1")))
+               .addLevel(createGL(MU<AttributeNode>("c2"), MU<AttributeNode>("s2")))
+               .addLevel(createGL(MU<AttributeNode>("c3"), MU<AttributeNode>("s3")));
 
     // Cached result
     Group cached = Group()
@@ -1562,22 +1554,17 @@ void
 Test::testPruneSimple()
 {
     {
-        Grouping request = Grouping()
-                           .addLevel(GroupingLevel()
-                                     .setExpression(MU<AttributeNode>("attr")))
-                           .setFirstLevel(1)
-                           .setLastLevel(1);
+        Grouping request;
+        request.addLevel(createGL(MU<AttributeNode>("attr"))).setFirstLevel(1).setLastLevel(1);
 
         Group a = Group()
                   .addChild(Group().setId(StringResultNode("foo")))
                   .addChild(Group().setId(StringResultNode("bar")))
                   .addChild(Group().setId(StringResultNode("baz")));
 
-        Group b = Group()
-                  .addChild(Group().setId(StringResultNode("foo")));
+        Group b = Group().addChild(Group().setId(StringResultNode("foo")));
 
-        Group expect = Group()
-                  .addChild(Group().setId(StringResultNode("foo")));
+        Group expect = Group().addChild(Group().setId(StringResultNode("foo")));
 
         EXPECT_TRUE(testPrune(request.unchain().setFirstLevel(0).setRoot(a), request.unchain().setRoot(b), expect));
     }
@@ -1610,10 +1597,10 @@ Test::testTopN()
         EXPECT_TRUE(testAggregation(ctx, request.setTopN(1), expect));
     }
     {
-        Grouping request2 = Grouping()
-                            .addLevel(GroupingLevel()
-                                      .addAggregationResult(MU<SumAggregationResult>())
-                                      .addOrderBy(MU<AggregationRefNode>(0), false));
+        Grouping request2;
+        request2.addLevel(std::move(GroupingLevel()
+                                  .addAggregationResult(MU<SumAggregationResult>())
+                                  .addOrderBy(MU<AggregationRefNode>(0), false)));
         EXPECT_TRUE(request2.needResort());
         request2.setTopN(0);
         EXPECT_TRUE(request2.needResort());
@@ -1785,9 +1772,7 @@ Test::checkBucket(const NumericResultNode &width, const NumericResultNode &value
     }
     std::unique_ptr<FixedWidthBucketFunctionNode> fixed = MU<FixedWidthBucketFunctionNode>(MU<AttributeNode>("attr"));
     fixed->setWidth(width);
-    Grouping request = Grouping()
-                       .addLevel(GroupingLevel()
-                                 .setExpression(std::move(fixed)));
+    Grouping request = Grouping().addLevel(createGL(std::move(fixed)));
     Group expect = Group().addChild(Group().setId(bucket));
     return testAggregation(ctx, request, expect);
 }
diff --git a/searchlib/src/tests/groupingengine/groupingengine_benchmark.cpp b/searchlib/src/tests/groupingengine/groupingengine_benchmark.cpp
index 3fcec02fb34..3917f85d99b 100644
--- a/searchlib/src/tests/groupingengine/groupingengine_benchmark.cpp
+++ b/searchlib/src/tests/groupingengine/groupingengine_benchmark.cpp
@@ -204,7 +204,7 @@ Test::benchmarkIntegerSum(bool useEngine, size_t numDocs, size_t numQueries, int
     baseRequest.setFirstLevel(0)
                .setLastLevel(1)
                .setRoot(Group().addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr0"))))
-               .addLevel(level);
+               .addLevel(std::move(level));
 
     for (size_t i(0); i < numQueries; i++) {
         testAggregation(ctx, baseRequest, useEngine);
@@ -233,7 +233,7 @@ Test::benchmarkIntegerCount(bool useEngine, size_t numDocs, size_t numQueries, i
     baseRequest.setFirstLevel(0)
                .setLastLevel(1)
                .setRoot(Group().addResult(CountAggregationResult().setExpression(MU<AttributeNode>("attr0"))))
-               .addLevel(level);
+               .addLevel(std::move(level));
 
     for (size_t i(0); i < numQueries; i++) {
         testAggregation(ctx, baseRequest, useEngine);
diff --git a/searchlib/src/tests/groupingengine/groupingengine_test.cpp b/searchlib/src/tests/groupingengine/groupingengine_test.cpp
index 9d66dc8b07e..d3f1df8c501 100644
--- a/searchlib/src/tests/groupingengine/groupingengine_test.cpp
+++ b/searchlib/src/tests/groupingengine/groupingengine_test.cpp
@@ -334,6 +334,37 @@ void Test::testAggregationSimpleSum(AggregationContext & ctx, const AggregationR
     EXPECT_TRUE(testAggregation(ctx, request, expect));
 }
 
+GroupingLevel
+createGL(ExpressionNode::UP expr, ExpressionNode::UP result) {
+    GroupingLevel l;
+    l.setExpression(std::move(expr));
+    l.addResult(SumAggregationResult().setExpression(std::move(result)));
+    return l;
+}
+
+GroupingLevel
+createGL(ExpressionNode::UP expr) {
+    GroupingLevel l;
+    l.setExpression(std::move(expr));
+    return l;
+}
+
+GroupingLevel
+createGL(size_t maxGroups, ExpressionNode::UP expr) {
+    GroupingLevel l;
+    l.setMaxGroups(maxGroups);
+    l.setExpression(std::move(expr));
+    return l;
+}
+
+GroupingLevel
+createGL(size_t maxGroups, ExpressionNode::UP expr, ExpressionNode::UP result) {
+    GroupingLevel l;
+    l.setMaxGroups(maxGroups);
+    l.setExpression(std::move(expr));
+    l.addResult(SumAggregationResult().setExpression(std::move(result)));
+    return l;
+}
 /**
  * Verify that the backend aggregation will classify and collect on
  * the appropriate levels, as indicated by the firstLevel and
@@ -352,15 +383,9 @@ Test::testAggregationLevels()
     Grouping baseRequest;
     baseRequest.setRoot(Group().setId(NullResultNode())
                                .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr0"))))
-               .addLevel(GroupingLevel()
-                                 .setExpression(MU<AttributeNode>("attr1"))
-                                 .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr2"))))
-               .addLevel(GroupingLevel()
-                                 .setExpression(MU<AttributeNode>("attr2"))
-                                 .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr3"))))
-               .addLevel(GroupingLevel()
-                                 .setExpression(MU<AttributeNode>("attr3"))
-                                 .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr1"))));
+               .addLevel(createGL(MU<AttributeNode>("attr1"), MU<AttributeNode>("attr2")))
+               .addLevel(createGL(MU<AttributeNode>("attr2"), MU<AttributeNode>("attr3")))
+               .addLevel(createGL(MU<AttributeNode>("attr3"), MU<AttributeNode>("attr1")));
 
     Group notDone;
     notDone.addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr0")));
@@ -476,8 +501,7 @@ Test::testAggregationMaxGroups()
 
     Grouping baseRequest = Grouping()
                            .setRoot(Group().setId(NullResultNode()))
-                           .addLevel(GroupingLevel()
-                                     .setExpression(MU<AttributeNode>("attr")));
+                           .addLevel(createGL(MU<AttributeNode>("attr")));
 
     Group empty = Group().setId(NullResultNode());
     Group grp1 = empty.unchain().addChild(Group().setId(Int64ResultNode(5)));
@@ -528,8 +552,7 @@ Test::testAggregationGroupOrder()
 
     Grouping request = Grouping()
                        .setRoot(Group().setId(NullResultNode()))
-                       .addLevel(GroupingLevel()
-                                 .setExpression(MU<AttributeNode>("attr")));
+                       .addLevel(createGL(MU<AttributeNode>("attr")));
 
     Group expect;
     expect.setId(NullResultNode())
@@ -562,7 +585,7 @@ Test::testAggregationGroupRank()
 
     Grouping request = Grouping()
                            .setRoot(Group().setId(NullResultNode()))
-                           .addLevel(GroupingLevel().setExpression(MU<AttributeNode>("attr")));
+                           .addLevel(createGL(MU<AttributeNode>("attr")));
 
     Group expect = Group()
                    .setId(NullResultNode())
@@ -603,8 +626,8 @@ Test::testAggregationGroupCapping()
         .add(6, 7).add(7, 8).add(8, 9);
 
     {
-        Grouping request = Grouping().setRoot(Group().setId(NullResultNode())).addLevel(
-                               GroupingLevel().setExpression(MU<AttributeNode>("attr")));
+        Grouping request;
+        request.setRoot(Group().setId(NullResultNode())).addLevel(createGL(MU<AttributeNode>("attr")));
 
         Group expect = Group().setId(NullResultNode())
                        .addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(1)))
@@ -622,7 +645,7 @@ Test::testAggregationGroupCapping()
     {
         Grouping request;
         request.setRoot(Group().setId(NullResultNode())).addLevel(
-                               GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr")));
+                               createGL(3, MU<AttributeNode>("attr")));
 
         Group expect;
         expect.setId(NullResultNode())
@@ -637,9 +660,9 @@ Test::testAggregationGroupCapping()
         request.setRoot(Group().setId(NullResultNode()))
                 .setFirstLevel(0)
                 .setLastLevel(1)
-                .addLevel(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr"))
+                .addLevel(std::move(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr"))
                                   .addAggregationResult(createAggr<SumAggregationResult>(MU<AttributeNode>("attr")))
-                                  .addOrderBy(MU<AggregationRefNode>(0), false));
+                                  .addOrderBy(MU<AggregationRefNode>(0), false)));
 
         Group expect;
         expect.setId(NullResultNode())
@@ -660,11 +683,9 @@ Test::testAggregationGroupCapping()
         request.setRoot(Group().setId(NullResultNode()))
                .setFirstLevel(0)
                 .setLastLevel(1)
-                .addLevel(GroupingLevel()
-                                  .setMaxGroups(3)
-                                  .setExpression(MU<AttributeNode>("attr"))
+                .addLevel(std::move(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr"))
                                   .addAggregationResult(createAggr<SumAggregationResult>(MU<AttributeNode>("attr")))
-                                  .addOrderBy(MU<AggregationRefNode>(0), true));
+                                  .addOrderBy(MU<AggregationRefNode>(0), true)));
 
         Group expect;
         expect.setId(NullResultNode())
@@ -688,9 +709,9 @@ Test::testAggregationGroupCapping()
         Grouping request;
         request.setFirstLevel(0)
                 .setLastLevel(1)
-                .addLevel(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr")).
+                .addLevel(std::move(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr")).
                         addResult(createAggr<SumAggregationResult>(MU<AttributeNode>("attr"))).
-                        addOrderBy(std::move(i1), false));
+                        addOrderBy(std::move(i1), false)));
 
         Group expect = Group()
                        .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7))
@@ -748,18 +769,9 @@ void
 Test::testMergeLevels()
 {
     Grouping request = Grouping()
-                       .addLevel(GroupingLevel()
-                                 .setExpression(MU<AttributeNode>("c1"))
-                                 .addResult(SumAggregationResult()
-                                         .setExpression(MU<AttributeNode>("s1"))))
-                       .addLevel(GroupingLevel()
-                                 .setExpression(MU<AttributeNode>("c2"))
-                                 .addResult(SumAggregationResult()
-                                         .setExpression(MU<AttributeNode>("s2"))))
-                       .addLevel(GroupingLevel()
-                                 .setExpression(MU<AttributeNode>("c3"))
-                                 .addResult(SumAggregationResult()
-                                         .setExpression(MU<AttributeNode>("s3"))));
+                       .addLevel(createGL(MU<AttributeNode>("c1"), MU<AttributeNode>("s1")))
+                       .addLevel(createGL(MU<AttributeNode>("c2"), MU<AttributeNode>("s2")))
+                       .addLevel(createGL(MU<AttributeNode>("c3"), MU<AttributeNode>("s3")));
 
     Group a = Group()
               .setId(NullResultNode())
@@ -936,9 +948,7 @@ Test::testMergeLevels()
 void
 Test::testMergeGroups()
 {
-    Grouping request = Grouping()
-                       .addLevel(GroupingLevel()
-                                 .setExpression(MU<AttributeNode>("attr")));
+    Grouping request = Grouping().addLevel(createGL(MU<AttributeNode>("attr")));
 
     Group a = Group()
               .setId(NullResultNode())
@@ -999,22 +1009,10 @@ Test::testMergeGroups()
 void
 Test::testMergeTrees()
 {
-    Grouping request = Grouping()
-                       .addLevel(GroupingLevel()
-                                 .setMaxGroups(3)
-                                 .setExpression(MU<AttributeNode>("c1"))
-                                 .addResult(SumAggregationResult()
-                                         .setExpression(MU<AttributeNode>("s1"))))
-                       .addLevel(GroupingLevel()
-                                 .setMaxGroups(2)
-                                 .setExpression(MU<AttributeNode>("c2"))
-                                 .addResult(SumAggregationResult()
-                                         .setExpression(MU<AttributeNode>("s2"))))
-                       .addLevel(GroupingLevel()
-                                 .setMaxGroups(1)
-                                 .setExpression(MU<AttributeNode>("c3"))
-                                 .addResult(SumAggregationResult()
-                                         .setExpression(MU<AttributeNode>("s3"))));
+    Grouping request;
+    request.addLevel(createGL(3, MU<AttributeNode>("c1"), MU<AttributeNode>("s1")))
+           .addLevel(createGL(2, MU<AttributeNode>("c2"), MU<AttributeNode>("s2")))
+           .addLevel(createGL(1, MU<AttributeNode>("c3"), MU<AttributeNode>("s3")));
 
     Group a = Group()
               .setId(NullResultNode())
@@ -1416,19 +1414,10 @@ Test::testPruneComplex()
 void
 Test::testPartialMerging()
 {
-    Grouping baseRequest = Grouping()
-                           .addLevel(GroupingLevel()
-                                     .setExpression(MU<AttributeNode>("c1"))
-                                     .addResult(SumAggregationResult()
-                                                .setExpression(MU<AttributeNode>("s1"))))
-                           .addLevel(GroupingLevel()
-                                     .setExpression(MU<AttributeNode>("c2"))
-                                     .addResult(SumAggregationResult()
-                                                .setExpression(MU<AttributeNode>("s2"))))
-                           .addLevel(GroupingLevel()
-                                     .setExpression(MU<AttributeNode>("c3"))
-                                     .addResult(SumAggregationResult()
-                                                .setExpression(MU<AttributeNode>("s3"))));
+    Grouping baseRequest;
+    baseRequest.addLevel(createGL(MU<AttributeNode>("c1"), MU<AttributeNode>("s1")))
+               .addLevel(createGL(MU<AttributeNode>("c2"), MU<AttributeNode>("s2")))
+               .addLevel(createGL(MU<AttributeNode>("c3"), MU<AttributeNode>("s3")));
 
     // Cached result
     Group cached = Group()
@@ -1591,11 +1580,8 @@ void
 Test::testPruneSimple()
 {
     {
-        Grouping request = Grouping()
-                           .addLevel(GroupingLevel()
-                                     .setExpression(MU<AttributeNode>("attr")))
-                           .setFirstLevel(1)
-                           .setLastLevel(1);
+        Grouping request;
+        request.addLevel(createGL(MU<AttributeNode>("attr"))).setFirstLevel(1).setLastLevel(1);
 
         Group a = Group()
                   .addChild(Group().setId(StringResultNode("foo")))
@@ -1640,9 +1626,9 @@ Test::testTopN()
     {
         Grouping request2 = Grouping()
                             .setRoot(Group().setId(NullResultNode()))
-                            .addLevel(GroupingLevel()
+                            .addLevel(std::move(GroupingLevel()
                                       .addAggregationResult(MU<SumAggregationResult>())
-                                      .addOrderBy(MU<AggregationRefNode>(0), false));
+                                      .addOrderBy(MU<AggregationRefNode>(0), false)));
         EXPECT_TRUE(request2.needResort());
         request2.setTopN(0);
         EXPECT_TRUE(request2.needResort());
@@ -1818,8 +1804,7 @@ Test::checkBucket(const NumericResultNode &width, const NumericResultNode &value
     std::unique_ptr<FixedWidthBucketFunctionNode> fixed = MU<FixedWidthBucketFunctionNode>(MU<AttributeNode>("attr"));
     fixed->setWidth(width);
     Grouping request = Grouping().setRoot(Group().setId(NullResultNode()))
-                       .addLevel(GroupingLevel()
-                                 .setExpression(std::move(fixed)));
+                       .addLevel(createGL(std::move(fixed)));
     Group expect = Group().setId(NullResultNode()).addChild(Group().setId(bucket));
     return testAggregation(ctx, request, expect);
 }
@@ -1936,22 +1921,11 @@ Test::testGroupingEngineFromRequest()
     ctx.add(IntAttrBuilder("attr2").add(12).add(12).sp());
     ctx.add(IntAttrBuilder("attr3").add(13).add(13).sp());
     ctx.result().add(0).add(1);
-    Grouping baseRequest = Grouping()
-                           .setRoot(Group()
-                                    .addResult(SumAggregationResult()
-                                            .setExpression(MU<AttributeNode>("attr0"))))
-                           .addLevel(GroupingLevel()
-                                     .setExpression(MU<AttributeNode>("attr1"))
-                                     .addResult(SumAggregationResult()
-                                             .setExpression(MU<AttributeNode>("attr2"))))
-                           .addLevel(GroupingLevel()
-                                     .setExpression(MU<AttributeNode>("attr2"))
-                                     .addResult(SumAggregationResult()
-                                             .setExpression(MU<AttributeNode>("attr3"))))
-                           .addLevel(GroupingLevel()
-                                     .setExpression(MU<AttributeNode>("attr3"))
-                                     .addResult(SumAggregationResult()
-                                             .setExpression(MU<AttributeNode>("attr1"))));
+    Grouping baseRequest;
+    baseRequest.setRoot(Group().addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr0"))))
+            .addLevel(createGL(MU<AttributeNode>("attr1"), MU<AttributeNode>("attr2")))
+            .addLevel(createGL(MU<AttributeNode>("attr2"), MU<AttributeNode>("attr3")))
+            .addLevel(createGL(MU<AttributeNode>("attr3"), MU<AttributeNode>("attr1")));
     ctx.setup(baseRequest);
     GroupingEngine engine(baseRequest.setFirstLevel(0).setLastLevel(2));
     EXPECT_EQUAL(4u, engine.getEngines().size());