Creat UP directly.

3 files changed, 99 insertions, 33 deletions

diff --git a/searchlib/src/tests/grouping/grouping_test.cpp b/searchlib/src/tests/grouping/grouping_test.cpp
index 5e165954eba..10a594696d6 100644
--- a/searchlib/src/tests/grouping/grouping_test.cpp
+++ b/searchlib/src/tests/grouping/grouping_test.cpp
@@ -551,6 +551,22 @@ Test::testAggregationGroupRank()
     EXPECT_TRUE(testAggregation(ctx, request, expect));
 }
 
+template<typename T>
+ExpressionNode::UP
+createAggr(ExpressionNode::UP e) {
+    std::unique_ptr<T> aggr = MU<T>();
+    aggr->setExpression(std::move(e));
+    return aggr;
+}
+
+template<typename T>
+ExpressionNode::UP
+createAggr(SingleResultNode::UP r, ExpressionNode::UP e) {
+    std::unique_ptr<T> aggr = MU<T>(std::move(r));
+    aggr->setExpression(std::move(e));
+    return aggr;
+}
+
 void
 Test::testAggregationGroupCapping()
 {
@@ -596,13 +612,19 @@ Test::testAggregationGroupCapping()
         request.setFirstLevel(0)
                 .setLastLevel(1)
                 .addLevel(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr"))
-                                  .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr")))
+                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<AttributeNode>("attr")))
                                   .addOrderBy(MU<AggregationRefNode>(0), false));
 
         Group expect;
-        expect.addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7)).addResult(SumAggregationResult(Int64ResultNode(7)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(MU<AggregationRefNode>(0), false))
-              .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8)).addResult(SumAggregationResult(Int64ResultNode(8)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(MU<AggregationRefNode>(0), false))
-              .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9)).addResult(SumAggregationResult(Int64ResultNode(9)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(MU<AggregationRefNode>(0), false));
+        expect.addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7))
+                                .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(7), MU<AttributeNode>("attr")))
+                                .addOrderBy(MU<AggregationRefNode>(0), false))
+              .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8))
+                                .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(8), MU<AttributeNode>("attr")))
+                                .addOrderBy(MU<AggregationRefNode>(0), false))
+              .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9))
+                                .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(9), MU<AttributeNode>("attr")))
+                                .addOrderBy(MU<AggregationRefNode>(0), false));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
@@ -613,13 +635,19 @@ Test::testAggregationGroupCapping()
                 .addLevel(GroupingLevel()
                                   .setMaxGroups(3)
                                   .setExpression(MU<AttributeNode>("attr"))
-                                  .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr")))
+                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<AttributeNode>("attr")))
                                   .addOrderBy(MU<AggregationRefNode>(0), true));
 
         Group expect = Group()
-                       .addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(1)).addResult(SumAggregationResult(Int64ResultNode(1)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(MU<AggregationRefNode>(0), true))
-                       .addChild(Group().setId(Int64ResultNode(2)).setRank(RawRank(2)).addResult(SumAggregationResult(Int64ResultNode(2)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(MU<AggregationRefNode>(0), true))
-                       .addChild(Group().setId(Int64ResultNode(3)).setRank(RawRank(3)).addResult(SumAggregationResult(Int64ResultNode(3)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(MU<AggregationRefNode>(0), true));
+                       .addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(1))
+                                         .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(1), MU<AttributeNode>("attr")))
+                                         .addOrderBy(MU<AggregationRefNode>(0), true))
+                       .addChild(Group().setId(Int64ResultNode(2)).setRank(RawRank(2))
+                                         .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(2), MU<AttributeNode>("attr")))
+                                         .addOrderBy(MU<AggregationRefNode>(0), true))
+                       .addChild(Group().setId(Int64ResultNode(3)).setRank(RawRank(3))
+                                         .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(3), MU<AttributeNode>("attr")))
+                                         .addOrderBy(MU<AggregationRefNode>(0), true));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
@@ -632,13 +660,19 @@ Test::testAggregationGroupCapping()
         request.setFirstLevel(0)
                 .setLastLevel(1)
                 .addLevel(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr"))
-                                  .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr")))
+                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<AttributeNode>("attr")))
                                   .addOrderBy(ExpressionNode::UP(add), false));
 
         Group expect;
-        expect.addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7)).addResult(SumAggregationResult(Int64ResultNode(7)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(10)), false))
-              .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8)).addResult(SumAggregationResult(Int64ResultNode(8)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(11)), false))
-              .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9)).addResult(SumAggregationResult(Int64ResultNode(9)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(12)), false));
+        expect.addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7))
+                                .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(7), MU<AttributeNode>("attr")))
+                                .addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(10)), false))
+              .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8))
+                                .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(8), MU<AttributeNode>("attr")))
+                                .addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(11)), false))
+              .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9))
+                                .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(9), MU<AttributeNode>("attr")))
+                                .addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(12)), false));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
@@ -1560,12 +1594,8 @@ Test::testTopN()
     ctx.result().add(0).add(1).add(2);
     ctx.add(IntAttrBuilder("foo").add(3).add(7).add(15).sp());
 
-    Grouping request = Grouping()
-                       .setRoot(Group()
-                                .addResult(CountAggregationResult()
-                                        .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0)))
-                                           )
-                                );
+    Grouping request;
+    request.setRoot(Group().addResult(CountAggregationResult().setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0)))));
     {
         Group expect;
         expect.addResult(CountAggregationResult().setCount(3).setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
@@ -1573,14 +1603,16 @@ Test::testTopN()
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
     {
-        Group expect = Group().addResult(CountAggregationResult().setCount(1).setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
+        Group expect = Group().addResult(CountAggregationResult()
+                                                 .setCount(1)
+                                                 .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
         EXPECT_TRUE(testAggregation(ctx, request.setTopN(1), expect));
     }
     {
         Grouping request2 = Grouping()
                             .addLevel(GroupingLevel()
-                                      .addResult(MU<SumAggregationResult>())
+                                      .addAggregationResult(MU<SumAggregationResult>())
                                       .addOrderBy(MU<AggregationRefNode>(0), false));
         EXPECT_TRUE(request2.needResort());
         request2.setTopN(0);
diff --git a/searchlib/src/tests/groupingengine/groupingengine_test.cpp b/searchlib/src/tests/groupingengine/groupingengine_test.cpp
index 8a53460d323..9d66dc8b07e 100644
--- a/searchlib/src/tests/groupingengine/groupingengine_test.cpp
+++ b/searchlib/src/tests/groupingengine/groupingengine_test.cpp
@@ -573,6 +573,22 @@ Test::testAggregationGroupRank()
     EXPECT_TRUE(testAggregation(ctx, request, expect));
 }
 
+template<typename T>
+ExpressionNode::UP
+createAggr(ExpressionNode::UP e) {
+    std::unique_ptr<T> aggr = MU<T>();
+    aggr->setExpression(std::move(e));
+    return aggr;
+}
+
+template<typename T>
+ExpressionNode::UP
+createAggr(SingleResultNode::UP r, ExpressionNode::UP e) {
+    std::unique_ptr<T> aggr = MU<T>(std::move(r));
+    aggr->setExpression(std::move(e));
+    return aggr;
+}
+
 void
 Test::testAggregationGroupCapping()
 {
@@ -622,14 +638,20 @@ Test::testAggregationGroupCapping()
                 .setFirstLevel(0)
                 .setLastLevel(1)
                 .addLevel(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr"))
-                                  .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr")))
+                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<AttributeNode>("attr")))
                                   .addOrderBy(MU<AggregationRefNode>(0), false));
 
         Group expect;
         expect.setId(NullResultNode())
-                .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7)).addResult(SumAggregationResult(Int64ResultNode(7)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(MU<AggregationRefNode>(0), false))
-                .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8)).addResult(SumAggregationResult(Int64ResultNode(8)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(MU<AggregationRefNode>(0), false))
-                .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9)).addResult(SumAggregationResult(Int64ResultNode(9)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(MU<AggregationRefNode>(0), false));
+                .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7))
+                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(7), MU<AttributeNode>("attr")))
+                                  .addOrderBy(MU<AggregationRefNode>(0), false))
+                .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8))
+                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(8), MU<AttributeNode>("attr")))
+                                  .addOrderBy(MU<AggregationRefNode>(0), false))
+                .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9))
+                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(9), MU<AttributeNode>("attr")))
+                                  .addOrderBy(MU<AggregationRefNode>(0), false));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
@@ -641,14 +663,20 @@ Test::testAggregationGroupCapping()
                 .addLevel(GroupingLevel()
                                   .setMaxGroups(3)
                                   .setExpression(MU<AttributeNode>("attr"))
-                                  .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr")))
+                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<AttributeNode>("attr")))
                                   .addOrderBy(MU<AggregationRefNode>(0), true));
 
         Group expect;
         expect.setId(NullResultNode())
-                .addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(1)).addResult(SumAggregationResult(Int64ResultNode(1)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(MU<AggregationRefNode>(0), true))
-                .addChild(Group().setId(Int64ResultNode(2)).setRank(RawRank(2)).addResult(SumAggregationResult(Int64ResultNode(2)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(MU<AggregationRefNode>(0), true))
-                .addChild(Group().setId(Int64ResultNode(3)).setRank(RawRank(3)).addResult(SumAggregationResult(Int64ResultNode(3)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(MU<AggregationRefNode>(0), true));
+                .addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(1))
+                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(1), MU<AttributeNode>("attr")))
+                                  .addOrderBy(MU<AggregationRefNode>(0), true))
+                .addChild(Group().setId(Int64ResultNode(2)).setRank(RawRank(2))
+                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(2), MU<AttributeNode>("attr")))
+                                  .addOrderBy(MU<AggregationRefNode>(0), true))
+                .addChild(Group().setId(Int64ResultNode(3)).setRank(RawRank(3))
+                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(3), MU<AttributeNode>("attr")))
+                                  .addOrderBy(MU<AggregationRefNode>(0), true));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
@@ -661,13 +689,19 @@ Test::testAggregationGroupCapping()
         request.setFirstLevel(0)
                 .setLastLevel(1)
                 .addLevel(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr")).
-                        addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr"))).
+                        addResult(createAggr<SumAggregationResult>(MU<AttributeNode>("attr"))).
                         addOrderBy(std::move(i1), false));
 
         Group expect = Group()
-                       .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7)).addResult(SumAggregationResult(Int64ResultNode(7)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(10)), false))
-                       .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8)).addResult(SumAggregationResult(Int64ResultNode(8)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(11)), false))
-                       .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9)).addResult(SumAggregationResult(Int64ResultNode(9)).setExpression(MU<AttributeNode>("attr"))).addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(12)), false));
+                       .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7))
+                                         .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(7), MU<AttributeNode>("attr")))
+                                         .addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(10)), false))
+                       .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8))
+                                         .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(8), MU<AttributeNode>("attr")))
+                                         .addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(11)), false))
+                       .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9))
+                                         .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(9), MU<AttributeNode>("attr")))
+                                         .addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(12)), false));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
diff --git a/searchlib/src/vespa/searchlib/aggregation/sumaggregationresult.h b/searchlib/src/vespa/searchlib/aggregation/sumaggregationresult.h
index a976cc1e355..0916dc75ff9 100644
--- a/searchlib/src/vespa/searchlib/aggregation/sumaggregationresult.h
+++ b/searchlib/src/vespa/searchlib/aggregation/sumaggregationresult.h
@@ -14,7 +14,7 @@ public:
     using SingleResultNode = expression::SingleResultNode;
     DECLARE_AGGREGATIONRESULT(SumAggregationResult);
     SumAggregationResult() : AggregationResult(), _sum() { }
-    SumAggregationResult(const SingleResultNode & sum) : AggregationResult(), _sum(sum) { }
+    SumAggregationResult(SingleResultNode::UP sum) : AggregationResult(), _sum(sum.release()) { }
     virtual void visitMembers(vespalib::ObjectVisitor &visitor) const;
     const SingleResultNode & getSum() const { return *_sum; }
 private: