Remove ExpressionNode::CP from interfaces.

6 files changed, 1015 insertions, 1250 deletions

diff --git a/searchlib/src/tests/aggregator/attr_test.cpp b/searchlib/src/tests/aggregator/attr_test.cpp
index 49ec52274f9..874e79495c8 100644
--- a/searchlib/src/tests/aggregator/attr_test.cpp
+++ b/searchlib/src/tests/aggregator/attr_test.cpp
@@ -114,13 +114,11 @@ struct StringAttrFixture {
     }
 };
 
+#define MU std::make_unique
 
 TEST_F("testArrayAt", AttributeFixture()) {
     for (int i = 0; i < 11; i++) {
-        ExpressionNode::CP cn(new ConstantNode(new Int64ResultNode(i)));
-        ExpressionNode::CP ln(new ArrayAtLookup(*f1.guard, cn));
-
-        ExpressionTree et(ln);
+        ExpressionTree et(MU<ArrayAtLookup>(*f1.guard, MU<ConstantNode>(MU<Int64ResultNode>(i))));
         ExpressionTree::Configure treeConf;
         et.select(treeConf, treeConf);
         EXPECT_TRUE(et.getResult().getClass().inherits(FloatResultNode::classId));
@@ -134,15 +132,11 @@ TEST_F("testArrayAt", AttributeFixture()) {
 
 TEST_F("testArrayAtInt", IntAttrFixture()) {
     for (int i = 0; i < 3; i++) {
-        ExpressionNode::CP othercn(new ConstantNode(new Int64ResultNode(4567)));
-        ArrayAtLookup *x = new ArrayAtLookup(*f1.guard, othercn);
-        ExpressionNode::CP cn(new ConstantNode(new Int64ResultNode(i)));
-        ArrayAtLookup *y = new ArrayAtLookup(*f1.guard, cn);
+        auto x = MU<ArrayAtLookup>(*f1.guard, MU<ConstantNode>(MU<Int64ResultNode>(4567)));
+        auto y = MU<ArrayAtLookup>(*f1.guard, MU<ConstantNode>(MU<Int64ResultNode>(i)));
         *x = *y;
-        delete y;
-        ExpressionNode::CP ln(x);
 
-        ExpressionTree et(ln);
+        ExpressionTree et(std::move(x));
         ExpressionTree::Configure treeConf;
         et.select(treeConf, treeConf);
         EXPECT_TRUE(et.getResult().getClass().inherits(IntegerResultNode::classId));
@@ -156,10 +150,7 @@ TEST_F("testArrayAtInt", IntAttrFixture()) {
 
 
 TEST_F("testArrayAtString", StringAttrFixture()) {
-    ExpressionNode::CP cn(new ConstantNode(new Int64ResultNode(1)));
-    ExpressionNode::CP ln(new ArrayAtLookup(*f1.guard, cn));
-
-    ExpressionTree et(ln);
+    ExpressionTree et(MU<ArrayAtLookup>(*f1.guard, MU<ConstantNode>(MU<Int64ResultNode>(1))));
     ExpressionTree::Configure treeConf;
     et.select(treeConf, treeConf);
     EXPECT_TRUE(et.getResult().getClass().inherits(StringResultNode::classId));
@@ -177,15 +168,11 @@ TEST_F("testArrayAtString", StringAttrFixture()) {
 struct ArrayAtExpressionFixture :
     public AttributeFixture
 {
-    ExpressionNode::CP cn;
-    ExpressionNode::CP ln;
     ExpressionTree et;
 
     ArrayAtExpressionFixture(int i) :
         AttributeFixture(),
-        cn(new ConstantNode(new Int64ResultNode(i))),
-        ln(new ArrayAtLookup(*guard, cn)),
-        et(ln)
+        et(MU<ArrayAtLookup>(*guard, MU<ConstantNode>(MU<Int64ResultNode>(i))))
     {
         ExpressionTree::Configure treeConf;
         et.select(treeConf, treeConf);
@@ -212,11 +199,7 @@ TEST_F("testArrayAtAboveRange", ArrayAtExpressionFixture(17)) {
 }
 
 TEST_F("testInterpolatedLookup", AttributeFixture()) {
-
-    ExpressionNode::CP c1(new ConstantNode(new FloatResultNode(f1.doc0attr[2])));
-    ExpressionNode::CP l1(new InterpolatedLookup(*f1.guard, c1));
-
-    ExpressionTree et(l1);
+    ExpressionTree et(MU<InterpolatedLookup>(*f1.guard, MU<ConstantNode>(MU<FloatResultNode>(f1.doc0attr[2]))));
     ExpressionTree::Configure treeConf;
     et.select(treeConf, treeConf);
 
@@ -230,11 +213,7 @@ TEST_F("testInterpolatedLookup", AttributeFixture()) {
 }
 
 TEST_F("testWithRelevance", AttributeFixture()) {
-
-    ExpressionNode::CP r1(new RelevanceNode());
-    ExpressionNode::CP l1(new InterpolatedLookup(*f1.guard, r1));
-
-    ExpressionTree et(l1);
+    ExpressionTree et(MU<InterpolatedLookup>(*f1.guard, MU<RelevanceNode>()));
     ExpressionTree::Configure treeConf;
     et.select(treeConf, treeConf);
 
diff --git a/searchlib/src/tests/aggregator/perdocexpr.cpp b/searchlib/src/tests/aggregator/perdocexpr.cpp
index c4c08e4de8f..81fbc964d9e 100644
--- a/searchlib/src/tests/aggregator/perdocexpr.cpp
+++ b/searchlib/src/tests/aggregator/perdocexpr.cpp
@@ -14,6 +14,8 @@
 #include <cmath>
 #include <iostream>
 
+#define MU std::make_unique
+
 using namespace search;
 using namespace search::expression;
 using namespace search::aggregation;
@@ -34,13 +36,13 @@ void testCmp(const T & small, const T & medium, const T & large);
 void testMin(const ResultNode & a, const ResultNode & b) {
     ASSERT_TRUE(a.cmp(b) < 0);
     MinFunctionNode func;
-    func.appendArg(ConstantNode(a)).appendArg(ConstantNode(b)).prepare(false)
-        .execute();
+    func.appendArg(MU<ConstantNode>(ResultNode::UP(a.clone())))
+        .appendArg(MU<ConstantNode>(ResultNode::UP(b.clone()))).prepare(false).execute();
     ASSERT_TRUE(func.getResult().cmp(a) == 0);
 
     MinFunctionNode funcR;
-    funcR.appendArg(ConstantNode(b)).appendArg(ConstantNode(a)).prepare(false)
-        .execute();
+    funcR.appendArg(MU<ConstantNode>(ResultNode::UP(b.clone())))
+         .appendArg(MU<ConstantNode>(ResultNode::UP(a.clone()))).prepare(false).execute();
     ASSERT_TRUE(funcR.getResult().cmp(a) == 0);
 }
 
@@ -55,13 +57,15 @@ TEST("testMin") {
 void testMax(const ResultNode & a, const ResultNode & b) {
     ASSERT_TRUE(a.cmp(b) < 0);
     MaxFunctionNode func;
-    func.appendArg(ConstantNode(a)).appendArg(ConstantNode(b)).prepare(false)
+    func.appendArg(MU<ConstantNode>(ResultNode::UP(a.clone())))
+        .appendArg(MU<ConstantNode>(ResultNode::UP(b.clone()))).prepare(false)
         .execute();
     ASSERT_TRUE(func.getResult().cmp(b) == 0);
 
     MaxFunctionNode funcR;
-    funcR.appendArg(ConstantNode(b)).appendArg(ConstantNode(a)).prepare(false)
-        .execute();
+    funcR.appendArg(MU<ConstantNode>(ResultNode::UP(a.clone())))
+         .appendArg(MU<ConstantNode>(ResultNode::UP(b.clone()))).prepare(false)
+         .execute();
     ASSERT_TRUE(funcR.getResult().cmp(b) == 0);
 }
 
@@ -91,16 +95,14 @@ ExpressionCountAggregationResult getExpressionCountWithNormalSketch() {
 }
 
 void testExpressionCount(const ResultNode &a, uint32_t bucket, uint8_t val) {
-    ExpressionCountAggregationResult func =
-        getExpressionCountWithNormalSketch();
-    func.setExpression(ConstantNode(a));
+    ExpressionCountAggregationResult func = getExpressionCountWithNormalSketch();
+    func.setExpression(MU<ConstantNode>(ResultNode::UP(a.clone())));
     func.aggregate(DocId(42), HitRank(21));
 
     const auto &sketch = func.getSketch();
     auto normal = dynamic_cast<const NormalSketch<>&>(sketch);
     for (uint32_t i = 0; i < sketch.BUCKET_COUNT; ++i) {
-        TEST_STATE(make_string("Bucket %u. Expected bucket %u=%u",
-                               i, bucket, val).c_str());
+        TEST_STATE(make_string("Bucket %u. Expected bucket %u=%u", i, bucket, val).c_str());
         EXPECT_EQUAL(i == bucket? val : 0, (int) normal.bucket[i]);
     }
 }
@@ -114,14 +116,10 @@ TEST("require that expression count can operate on different results") {
 }
 
 TEST("require that expression counts can be merged") {
-    ExpressionCountAggregationResult func1 =
-        getExpressionCountWithNormalSketch();
-    func1.setExpression(ConstantNode(Int64ResultNode(67)))
-        .aggregate(DocId(42), HitRank(21));
-    ExpressionCountAggregationResult func2 =
-        getExpressionCountWithNormalSketch();
-    func2.setExpression(ConstantNode(FloatResultNode(67)))
-        .aggregate(DocId(42), HitRank(21));
+    ExpressionCountAggregationResult func1 = getExpressionCountWithNormalSketch();
+    func1.setExpression(MU<ConstantNode>(MU<Int64ResultNode>(67))).aggregate(DocId(42), HitRank(21));
+    ExpressionCountAggregationResult func2 = getExpressionCountWithNormalSketch();
+    func2.setExpression(MU<ConstantNode>(MU<FloatResultNode>(67))).aggregate(DocId(42), HitRank(21));
 
     EXPECT_EQUAL(2, func1.getRank().getInteger());
     func1.merge(func2);
@@ -134,10 +132,8 @@ TEST("require that expression counts can be merged") {
 
 TEST("require that expression counts can be serialized") {
     ExpressionCountAggregationResult func;
-    func.setExpression(ConstantNode(Int64ResultNode(67)))
-        .aggregate(DocId(42), HitRank(21));
-    func.setExpression(ConstantNode(Int64ResultNode(68)))
-        .aggregate(DocId(42), HitRank(21));
+    func.setExpression(MU<ConstantNode>(MU<Int64ResultNode>(67))).aggregate(DocId(42), HitRank(21));
+    func.setExpression(MU<ConstantNode>(MU<Int64ResultNode>(68))).aggregate(DocId(42), HitRank(21));
 
     nbostream os;
     NBOSerializer nos(os);
@@ -149,24 +145,20 @@ TEST("require that expression counts can be serialized") {
 }
 
 TEST("require that expression count estimates rank") {
-    ExpressionCountAggregationResult func =
-        getExpressionCountWithNormalSketch();
+    ExpressionCountAggregationResult func = getExpressionCountWithNormalSketch();
     EXPECT_EQUAL(0, func.getRank().getInteger());
-    func.setExpression(ConstantNode(Int64ResultNode(67)))
-        .aggregate(DocId(42), HitRank(21));
+    func.setExpression(MU<ConstantNode>(MU<Int64ResultNode>(67))).aggregate(DocId(42), HitRank(21));
     EXPECT_EQUAL(2, func.getRank().getInteger());
-    func.setExpression(ConstantNode(FloatResultNode(67)))
-        .aggregate(DocId(42), HitRank(21));
+    func.setExpression(MU<ConstantNode>(MU<FloatResultNode>(67))).aggregate(DocId(42), HitRank(21));
     EXPECT_EQUAL(3, func.getRank().getInteger());
-    func.setExpression(ConstantNode(FloatResultNode(67)))
-        .aggregate(DocId(42), HitRank(21));
+    func.setExpression(MU<ConstantNode>(MU<FloatResultNode>(67))).aggregate(DocId(42), HitRank(21));
     EXPECT_EQUAL(3, func.getRank().getInteger());
 }
 
 void testAdd(const ResultNode &a, const ResultNode &b, const ResultNode &c) {
     AddFunctionNode func;
-    func.appendArg(ConstantNode(a)).appendArg(ConstantNode(b)).prepare(false)
-        .execute();
+    func.appendArg(MU<ConstantNode>(ResultNode::UP(a.clone())))
+        .appendArg(MU<ConstantNode>(ResultNode::UP(b.clone()))).prepare(false).execute();
     EXPECT_EQUAL(func.getResult().asString(), c.asString());
     EXPECT_EQUAL(func.getResult().cmp(c), 0);
     EXPECT_EQUAL(c.cmp(func.getResult()), 0);
@@ -175,17 +167,14 @@ void testAdd(const ResultNode &a, const ResultNode &b, const ResultNode &c) {
 TEST("testAdd") {
     testAdd(Int64ResultNode(67), Int64ResultNode(68), Int64ResultNode(67+68));
     testAdd(FloatResultNode(67), FloatResultNode(68), FloatResultNode(67+68));
-    testAdd(StringResultNode("67"), StringResultNode("68"),
-            StringResultNode("lo"));
-    testAdd(RawResultNode("67", 2), RawResultNode("68", 2),
-            RawResultNode("lo", 2));
+    testAdd(StringResultNode("67"), StringResultNode("68"), StringResultNode("lo"));
+    testAdd(RawResultNode("67", 2), RawResultNode("68", 2), RawResultNode("lo", 2));
 }
 
-void testDivide(const ResultNode &a, const ResultNode &b,
-                const ResultNode &c) {
+void testDivide(const ResultNode &a, const ResultNode &b, const ResultNode &c) {
     DivideFunctionNode func;
-    func.appendArg(ConstantNode(a)).appendArg(ConstantNode(b)).prepare(false)
-        .execute();
+    func.appendArg(MU<ConstantNode>(ResultNode::UP(a.clone())))
+        .appendArg(MU<ConstantNode>(ResultNode::UP(b.clone()))).prepare(false).execute();
     EXPECT_EQUAL(func.getResult().asString(), c.asString());
     EXPECT_EQUAL(func.getResult().getFloat(), c.getFloat());
     EXPECT_EQUAL(func.getResult().cmp(c), 0);
@@ -193,17 +182,15 @@ void testDivide(const ResultNode &a, const ResultNode &b,
 }
 
 TEST("testDivide") {
-    testDivide(Int64ResultNode(6), FloatResultNode(12.0),
-               FloatResultNode(0.5));
+    testDivide(Int64ResultNode(6), FloatResultNode(12.0), FloatResultNode(0.5));
     testDivide(Int64ResultNode(6), Int64ResultNode(1), Int64ResultNode(6));
     testDivide(Int64ResultNode(6), Int64ResultNode(0), Int64ResultNode(0));
 }
 
-void testModulo(const ResultNode &a, const ResultNode &b,
-                const ResultNode &c) {
+void testModulo(const ResultNode &a, const ResultNode &b, const ResultNode &c) {
     ModuloFunctionNode func;
-    func.appendArg(ConstantNode(a)).appendArg(ConstantNode(b)).prepare(false)
-        .execute();
+    func.appendArg(MU<ConstantNode>(ResultNode::UP(a.clone())))
+        .appendArg(MU<ConstantNode>(ResultNode::UP(b.clone()))).prepare(false).execute();
     EXPECT_EQUAL(func.getResult().asString(), c.asString());
     EXPECT_EQUAL(func.getResult().getFloat(), c.getFloat());
     EXPECT_EQUAL(func.getResult().cmp(c), 0);
@@ -228,7 +215,7 @@ TEST("testModulo") {
 
 void testNegate(const ResultNode & a, const ResultNode & b) {
     NegateFunctionNode func;
-    func.appendArg(ConstantNode(a)).prepare(false).execute();
+    func.appendArg(MU<ConstantNode>(ResultNode::UP(a.clone()))).prepare(false).execute();
     EXPECT_EQUAL(func.getResult().asString(), b.asString());
     EXPECT_EQUAL(func.getResult().cmp(b), 0);
     EXPECT_EQUAL(b.cmp(func.getResult()), 0);
@@ -491,10 +478,7 @@ TEST("testTimeStamp") {
 namespace {
 
 std::string
-getVespaChecksumV2(
-        const std::string& ymumid,
-        int fid,
-        const std::string& flags_str)
+getVespaChecksumV2(const std::string& ymumid, int fid, const std::string& flags_str)
 {
     if (fid == 6 || fid == 0 || fid == 5) {
         return 0;
@@ -537,10 +521,8 @@ TEST("testMailChecksumExpression") {
     std::string flags = "RWA";
     std::string ymumid = "barmuda";
 
-    document::Document::UP doc =
-        testDocMan.createDocument("foo", "userdoc:footype:1234:" + ymumid);
-    document::WeightedSetFieldValue
-        ws(doc->getField("byteweightedset").getDataType());
+    document::Document::UP doc = testDocMan.createDocument("foo", "userdoc:footype:1234:" + ymumid);
+    document::WeightedSetFieldValue ws(doc->getField("byteweightedset").getDataType());
 
     for (uint32_t i = 0; i < flags.size(); i++) {
         ws.add(document::ByteFieldValue(flags[i]));
@@ -548,42 +530,33 @@ TEST("testMailChecksumExpression") {
     doc->setValue("headerval", document::IntFieldValue(folder));
     doc->setValue("byteweightedset", ws);
 
-    CatFunctionNode e;
+    std::unique_ptr<CatFunctionNode> e = MU<CatFunctionNode>();
 
     // YMUMID
-    GetDocIdNamespaceSpecificFunctionNode* ns =
-        new GetDocIdNamespaceSpecificFunctionNode(
-                ResultNode::UP(new StringResultNode));
-    e.appendArg(ExpressionNode::CP(ns));
+    e->appendArg(MU<GetDocIdNamespaceSpecificFunctionNode>(MU<StringResultNode>()));
 
     // Folder
-    e.appendArg(DocumentFieldNode("headerval"));
+    e->appendArg(MU<DocumentFieldNode>("headerval"));
 
     // Flags
-    e.appendArg(SortFunctionNode(DocumentFieldNode("byteweightedset")));
+    e->appendArg(MU<SortFunctionNode>(MU<DocumentFieldNode>("byteweightedset")));
 
-    MD5BitFunctionNode node(e, 32);
+    MD5BitFunctionNode node(std::move(e), 32);
 
-    CatFunctionNode &cfn =
-        static_cast<CatFunctionNode&>(*node.expressionNodeVector()[0]);
-    MultiArgFunctionNode::ExpressionNodeVector &xe =
-        cfn.expressionNodeVector();
+    CatFunctionNode &cfn = static_cast<CatFunctionNode&>(*node.expressionNodeVector()[0]);
+    MultiArgFunctionNode::ExpressionNodeVector &xe = cfn.expressionNodeVector();
 
     for (uint32_t i = 0; i < xe.size(); i++) {
-        DocumentAccessorNode* rf =
-            dynamic_cast<DocumentAccessorNode *>(xe[i].get());
+        DocumentAccessorNode* rf = dynamic_cast<DocumentAccessorNode *>(xe[i].get());
         if (rf) {
             rf->setDocType(doc->getType());
             rf->prepare(true);
             rf->setDoc(*doc);
         } else {
-            MultiArgFunctionNode * mf =
-                dynamic_cast<MultiArgFunctionNode *>(xe[i].get());
-            MultiArgFunctionNode::ExpressionNodeVector& se =
-                mf->expressionNodeVector();
+            MultiArgFunctionNode * mf = dynamic_cast<MultiArgFunctionNode *>(xe[i].get());
+            MultiArgFunctionNode::ExpressionNodeVector& se = mf->expressionNodeVector();
             for (uint32_t j = 0; j < se.size(); j++) {
-                DocumentAccessorNode* tf =
-                    dynamic_cast<DocumentAccessorNode *>(se[j].get());
+                DocumentAccessorNode* tf = dynamic_cast<DocumentAccessorNode *>(se[j].get());
                 tf->setDocType(doc->getType());
                 tf->prepare(true);
                 tf->setDoc(*doc);
@@ -595,8 +568,7 @@ TEST("testMailChecksumExpression") {
     cfn.prepare(false);
 
     cfn.execute();
-    ConstBufferRef ref =
-        static_cast<const RawResultNode &>(cfn.getResult()).get();
+    ConstBufferRef ref = static_cast<const RawResultNode &>(cfn.getResult()).get();
 
     std::string cmp = getVespaChecksumV2(ymumid, folder, flags);
 
@@ -623,152 +595,129 @@ TEST("testMailChecksumExpression") {
 
 TEST("testDebugFunction") {
     {
-        AddFunctionNode add;
-        add.appendArg(ConstantNode(Int64ResultNode(3)));
-        add.appendArg(ConstantNode(Int64ResultNode(4)));
-        DebugWaitFunctionNode n(add, 1.3, false);
+        std::unique_ptr<AddFunctionNode> add = MU<AddFunctionNode>();
+        add->appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3)));
+        add->appendArg(MU<ConstantNode>(MU<Int64ResultNode>(4)));
+        DebugWaitFunctionNode n(std::move(add), 1.3, false);
         n.prepare(false);
 
         FastOS_Time time;
         time.SetNow();
         n.execute();
         EXPECT_TRUE(time.MilliSecsToNow() > 1000.0);
-        EXPECT_EQUAL(static_cast<const Int64ResultNode &>(n.getResult()).get(),
-                     7);
+        EXPECT_EQUAL(static_cast<const Int64ResultNode &>(n.getResult()).get(), 7);
     }
     {
-        AddFunctionNode add;
-        add.appendArg(ConstantNode(Int64ResultNode(3)));
-        add.appendArg(ConstantNode(Int64ResultNode(4)));
-        DebugWaitFunctionNode n(add, 1.3, true);
+        std::unique_ptr<AddFunctionNode> add = MU<AddFunctionNode>();
+        add->appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3)));
+        add->appendArg(MU<ConstantNode>(MU<Int64ResultNode>(4)));
+        DebugWaitFunctionNode n(std::move(add), 1.3, true);
         n.prepare(false);
 
         FastOS_Time time;
         time.SetNow();
         n.execute();
         EXPECT_TRUE(time.MilliSecsToNow() > 1000.0);
-        EXPECT_EQUAL(static_cast<const Int64ResultNode &>(n.getResult()).get(),
-                     7);
+        EXPECT_EQUAL(static_cast<const Int64ResultNode &>(n.getResult()).get(), 7);
     }
 }
 
+template<typename V>
+ResultNode::UP
+createIntRV(std::vector<int64_t> values) {
+    using T = typename V::BaseType;
+    std::unique_ptr<V> r = MU<V>();
+    for (int64_t v : values) {
+        r->push_back(T(v));
+    }
+    return r;
+}
+
 TEST("testDivExpressions") {
     {
-        StrLenFunctionNode e(ConstantNode(Int64ResultNode(238686)));
+        StrLenFunctionNode e(MU<ConstantNode>(MU<Int64ResultNode>(238686)));
         e.prepare(false);
         e.execute();
-        EXPECT_EQUAL(static_cast<const Int64ResultNode &>(e.getResult()).get(),
-                     6);
+        EXPECT_EQUAL(static_cast<const Int64ResultNode &>(e.getResult()).get(), 6);
     }
     {
-        NormalizeSubjectFunctionNode
-            e(ConstantNode(StringResultNode("Re: Your mail")));
+        NormalizeSubjectFunctionNode e(MU<ConstantNode>(MU<StringResultNode>("Re: Your mail")));
         e.prepare(false);
         e.execute();
-        EXPECT_EQUAL(
-                static_cast<const StringResultNode &>(e.getResult()).get(),
-                "Your mail");
+        EXPECT_EQUAL(static_cast<const StringResultNode &>(e.getResult()).get(), "Your mail");
     }
     {
-        NormalizeSubjectFunctionNode
-            e(ConstantNode(StringResultNode("Your mail")));
+        NormalizeSubjectFunctionNode e(MU<ConstantNode>(MU<StringResultNode>("Your mail")));
         e.prepare(false);
         e.execute();
-        EXPECT_EQUAL(
-                static_cast<const StringResultNode &>(e.getResult()).get(),
-                "Your mail");
+        EXPECT_EQUAL(static_cast<const StringResultNode &>(e.getResult()).get(), "Your mail");
     }
     {
-        StrCatFunctionNode e(ConstantNode(Int64ResultNode(238686)));
-        e.appendArg(ConstantNode(StringResultNode("ARG 2")));
+        StrCatFunctionNode e(MU<ConstantNode>(MU<Int64ResultNode>(238686)));
+        e.appendArg(MU<ConstantNode>(MU<StringResultNode>("ARG 2")));
         e.prepare(false);
         e.execute();
-        EXPECT_EQUAL(
-                static_cast<const StringResultNode &>(e.getResult()).get(),
-                "238686ARG 2");
+        EXPECT_EQUAL(static_cast<const StringResultNode &>(e.getResult()).get(), "238686ARG 2");
     }
 
     {
-        ToStringFunctionNode e(ConstantNode(Int64ResultNode(238686)));
+        ToStringFunctionNode e(MU<ConstantNode>(MU<Int64ResultNode>(238686)));
         e.prepare(false);
         e.execute();
-        EXPECT_EQUAL(strcmp(static_cast<const StringResultNode &>(
-                                e.getResult()).get().c_str(), "238686"), 0);
+        EXPECT_EQUAL(strcmp(static_cast<const StringResultNode &>(e.getResult()).get().c_str(), "238686"), 0);
     }
 
     {
-        ToRawFunctionNode e(ConstantNode(Int64ResultNode(238686)));
+        ToRawFunctionNode e(MU<ConstantNode>(MU<Int64ResultNode>(238686)));
         e.prepare(false);
         e.execute();
-        EXPECT_EQUAL(strcmp(static_cast<const RawResultNode &>(
-                                e.getResult()).get().c_str(), "238686"), 0);
+        EXPECT_EQUAL(strcmp(static_cast<const RawResultNode &>(e.getResult()).get().c_str(), "238686"), 0);
     }
 
     {
-        CatFunctionNode e(ConstantNode(Int64ResultNode(238686)));
+        CatFunctionNode e(MU<ConstantNode>(MU<Int64ResultNode>(238686)));
         e.prepare(false);
         e.execute();
-        EXPECT_EQUAL(
-                static_cast<const RawResultNode &>(e.getResult()).get().size(),
-                8u);
+        EXPECT_EQUAL(static_cast<const RawResultNode &>(e.getResult()).get().size(), 8u);
     }
     {
-        CatFunctionNode e(ConstantNode(Int32ResultNode(23886)));
+        CatFunctionNode e(MU<ConstantNode>(MU<Int32ResultNode>(23886)));
         e.prepare(false);
         e.execute();
-        EXPECT_EQUAL(
-                static_cast<const RawResultNode &>(e.getResult()).get().size(),
-                4u);
+        EXPECT_EQUAL(static_cast<const RawResultNode &>(e.getResult()).get().size(), 4u);
     }
     {
         const uint8_t buf[4] = { 0, 0, 0, 7 };
-        MD5BitFunctionNode
-            e(ConstantNode(RawResultNode(buf, sizeof(buf))), 16*8);
+        MD5BitFunctionNode e(MU<ConstantNode>(MU<RawResultNode>(buf, sizeof(buf))), 16*8);
         e.prepare(false);
         e.execute();
         ASSERT_TRUE(e.getResult().getClass().inherits(RawResultNode::classId));
-        const RawResultNode &
-            r(static_cast<const RawResultNode &>(e.getResult()));
+        const RawResultNode &r(static_cast<const RawResultNode &>(e.getResult()));
         EXPECT_EQUAL(r.get().size(), 16u);
     }
     {
         const uint8_t buf[4] = { 0, 0, 0, 7 };
-        MD5BitFunctionNode
-            e(ConstantNode(RawResultNode(buf, sizeof(buf))), 2*8);
+        MD5BitFunctionNode e(MU<ConstantNode>(MU<RawResultNode>(buf, sizeof(buf))), 2*8);
         e.prepare(false);
         e.execute();
-        EXPECT_EQUAL(
-                static_cast<const RawResultNode &>(e.getResult()).get().size(),
-                2u);
+        EXPECT_EQUAL(static_cast<const RawResultNode &>(e.getResult()).get().size(), 2u);
     }
     {
         const uint8_t buf[4] = { 0, 0, 0, 7 };
-        XorBitFunctionNode
-            e(ConstantNode(RawResultNode(buf, sizeof(buf))), 1*8);
+        XorBitFunctionNode e(MU<ConstantNode>(MU<RawResultNode>(buf, sizeof(buf))), 1*8);
         e.prepare(false);
         e.execute();
-        EXPECT_EQUAL(
-                static_cast<const RawResultNode &>(e.getResult()).get().size(),
-                1u);
-        EXPECT_EQUAL(static_cast<const RawResultNode &>(
-                        e.getResult()).get().c_str()[0],
-                     0x7);
+        EXPECT_EQUAL(static_cast<const RawResultNode &>(e.getResult()).get().size(), 1u);
+        EXPECT_EQUAL(static_cast<const RawResultNode &>(e.getResult()).get().c_str()[0], 0x7);
     }
     {
         const uint8_t buf[4] = { 6, 0, 7, 7 };
-        XorBitFunctionNode
-            e(ConstantNode(RawResultNode(buf, sizeof(buf))), 2*8);
+        XorBitFunctionNode e(MU<ConstantNode>(MU<RawResultNode>(buf, sizeof(buf))), 2*8);
         e.prepare(false);
         e.execute();
-        EXPECT_EQUAL(
-                static_cast<const RawResultNode &>(e.getResult()).get().size(),
-                2u);
-        EXPECT_EQUAL((int)static_cast<const RawResultNode &>(
-                        e.getResult()).get().c_str()[0],
-                     0x1);
-        EXPECT_EQUAL((int)static_cast<const RawResultNode &>(
-                        e.getResult()).get().c_str()[1],
-                     0x7);
+        EXPECT_EQUAL(static_cast<const RawResultNode &>(e.getResult()).get().size(), 2u);
+        EXPECT_EQUAL((int)static_cast<const RawResultNode &>(e.getResult()).get().c_str()[0], 0x1);
+        EXPECT_EQUAL((int)static_cast<const RawResultNode &>(e.getResult()).get().c_str()[1], 0x7);
     }
     {
         const uint8_t wantedBuf[14]  =
@@ -783,13 +732,11 @@ TEST("testDivExpressions") {
             { 0, 0, 0, 22, 0, 0, 0, 7, 98, 97, 114, 109, 117, 100, 97, 0,
               0, 0, 32, 0 , 0, 0, 3, 65, 82, 87 };
 
-        MD5BitFunctionNode
-            e(ConstantNode(RawResultNode(wantedBuf, sizeof(wantedBuf))), 16*8);
+        MD5BitFunctionNode e(MU<ConstantNode>(MU<RawResultNode>(wantedBuf, sizeof(wantedBuf))), 16*8);
         e.prepare(false);
         e.execute();
         ASSERT_TRUE(e.getResult().getClass().inherits(RawResultNode::classId));
-        const RawResultNode &
-            r(static_cast<const RawResultNode &>(e.getResult()));
+        const RawResultNode &r(static_cast<const RawResultNode &>(e.getResult()));
         EXPECT_EQUAL(r.get().size(), 16u);
         uint8_t md5[16];
         fastc_md5sum(currentBuf, sizeof(currentBuf), md5);
@@ -799,87 +746,62 @@ TEST("testDivExpressions") {
         fastc_md5sum(thomasBuf, sizeof(thomasBuf), md5);
         EXPECT_TRUE(memcmp(r.get().data(), md5, sizeof(md5)) != 0);
 
-        MD5BitFunctionNode
-            finalCheck(
-                    CatFunctionNode(ConstantNode(StringResultNode("barmuda")))
-                    .appendArg(ConstantNode(Int32ResultNode(32)))
-                    .appendArg(SortFunctionNode(
-                                    ConstantNode(Int8ResultNodeVector()
-                                            .push_back(Int8ResultNode(87))
-                                            .push_back(Int8ResultNode(65))
-                                            .push_back(Int8ResultNode(82))
-                                                 )
-                                                )
-                               ), 32);
+        std::unique_ptr<CatFunctionNode> cat = MU<CatFunctionNode>(MU<ConstantNode>(MU<StringResultNode>("barmuda")));
+        cat->appendArg(MU<ConstantNode>(MU<Int32ResultNode>(32)));
+        cat->appendArg(MU<SortFunctionNode>(MU<ConstantNode>(createIntRV<Int8ResultNodeVector>({87, 65, 82}))));
+
+        MD5BitFunctionNode finalCheck(std::move(cat), 32);
         finalCheck.prepare(false);
         finalCheck.execute();
-        const RawResultNode &
-            rr(static_cast<const RawResultNode &>(finalCheck.getResult()));
+        const RawResultNode &rr(static_cast<const RawResultNode &>(finalCheck.getResult()));
         EXPECT_EQUAL(rr.get().size(), 4u);
         fastc_md5sum(wantedBuf, sizeof(wantedBuf), md5);
         EXPECT_TRUE(memcmp(md5facit, md5, sizeof(md5)) == 0);
         EXPECT_TRUE(memcmp(rr.get().data(), md5, rr.get().size()) == 0);
     }
     {
-        CatFunctionNode e(ConstantNode(Int16ResultNode(23886)));
+        CatFunctionNode e(MU<ConstantNode>(MU<Int16ResultNode>(23886)));
         e.prepare(false);
         e.execute();
-        EXPECT_EQUAL(
-                static_cast<const RawResultNode &>(e.getResult()).get().size(),
-                2u);
+        EXPECT_EQUAL(static_cast<const RawResultNode &>(e.getResult()).get().size(), 2u);
     }
     {
-        CatFunctionNode
-            e(ConstantNode(Int8ResultNodeVector().push_back(Int8ResultNode(86))
-                           .push_back(Int8ResultNode(14))));
+        CatFunctionNode e(MU<ConstantNode>(createIntRV<Int8ResultNodeVector>({86, 14})));
         e.prepare(false);
         e.execute();
-        EXPECT_EQUAL(
-                static_cast<const RawResultNode &>(e.getResult()).get().size(),
-                1*2u);
+        EXPECT_EQUAL(static_cast<const RawResultNode &>(e.getResult()).get().size(), 1*2u);
     }
     {
-        CatFunctionNode
-            e(ConstantNode(Int32ResultNodeVector()
-                           .push_back(Int32ResultNode(238686))
-                           .push_back(Int32ResultNode(2133214))));
+        CatFunctionNode e(MU<ConstantNode>(createIntRV<Int32ResultNodeVector>({238686,2133214})));
         e.prepare(false);
         e.execute();
-        EXPECT_EQUAL(
-                static_cast<const RawResultNode &>(e.getResult()).get().size(),
-                4*2u);
+        EXPECT_EQUAL(static_cast<const RawResultNode &>(e.getResult()).get().size(), 4*2u);
     }
     {
-        NumElemFunctionNode e(ConstantNode(Int64ResultNode(238686)));
+        NumElemFunctionNode e(MU<ConstantNode>(MU<Int64ResultNode>(238686)));
         e.prepare(false);
         e.execute();
         EXPECT_EQUAL(e.getResult().getInteger(), 1);
     }
     {
-        NumElemFunctionNode
-            e(ConstantNode(Int32ResultNodeVector()
-                           .push_back(Int32ResultNode(238686))
-                           .push_back(Int32ResultNode(2133214))));
+        NumElemFunctionNode e(MU<ConstantNode>(createIntRV<Int32ResultNodeVector>({238686,2133214})));
         e.prepare(false);
         e.execute();
         EXPECT_EQUAL(e.getResult().getInteger(), 2);
     }
     {
-        NumElemFunctionNode
-            e(ConstantNode(Int32ResultNodeVector()
-                           .push_back(Int32ResultNode(238686))
-                           .push_back(Int32ResultNode(2133214))));
+        NumElemFunctionNode e(MU<ConstantNode>(createIntRV<Int32ResultNodeVector>({238686,2133214})));
         e.prepare(false);
         e.execute();
         EXPECT_EQUAL(e.getResult().getInteger(), 2);
     }
 }
 
-bool test1MultivalueExpression(const MultiArgFunctionNode &exprConst,
-                               const ExpressionNode::CP &mv,
-                               const ResultNode & expected) {
+bool test1MultivalueExpression(const MultiArgFunctionNode &exprConst, ExpressionNode::UP mv,
+                               const ResultNode & expected)
+{
    MultiArgFunctionNode & expr(const_cast<MultiArgFunctionNode &>(exprConst));
-   expr.appendArg(mv);
+   expr.appendArg(std::move(mv));
    expr.prepare(false);
    bool ok = EXPECT_TRUE(expr.execute()) &&
              EXPECT_EQUAL(0, expr.getResult().cmp(expected));
@@ -891,40 +813,43 @@ bool test1MultivalueExpression(const MultiArgFunctionNode &exprConst,
 }
 
 bool test1MultivalueExpressionException(const MultiArgFunctionNode & exprConst,
-                                        const ExpressionNode::CP & mv,
+                                        ExpressionNode::UP mv,
                                         const char * expected) {
    try {
-       test1MultivalueExpression(exprConst, mv, NullResultNode());
+       test1MultivalueExpression(exprConst, std::move(mv), NullResultNode());
        return EXPECT_TRUE(false);
    } catch (std::runtime_error & e) {
-       return EXPECT_TRUE(std::string(e.what()).find(expected)
-                          != std::string::npos);
+       return EXPECT_TRUE(std::string(e.what()).find(expected) != std::string::npos);
    }
 }
 
 TEST("testMultivalueExpression") {
-   IntegerResultNodeVector iv;
-   iv.push_back(Int64ResultNode(7))
-       .push_back(Int64ResultNode(17)).push_back(Int64ResultNode(117));
-   ExpressionNode::CP mv(new ConstantNode(iv));
+    std::vector<int64_t> IV = {7, 17, 117};
 
-   EXPECT_TRUE(test1MultivalueExpression(AddFunctionNode(), mv,
+   EXPECT_TRUE(test1MultivalueExpression(AddFunctionNode(),
+                                         MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV)),
                                          Int64ResultNode(7 + 17 + 117)));
-   EXPECT_TRUE(test1MultivalueExpression(MultiplyFunctionNode(), mv,
+   EXPECT_TRUE(test1MultivalueExpression(MultiplyFunctionNode(),
+                                         MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV)),
                                          Int64ResultNode(7 * 17 * 117)));
-   EXPECT_TRUE(test1MultivalueExpressionException(DivideFunctionNode(), mv,
+   EXPECT_TRUE(test1MultivalueExpressionException(DivideFunctionNode(),
+                                                  MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV)),
                                                   "DivideFunctionNode"));
-   EXPECT_TRUE(test1MultivalueExpressionException(ModuloFunctionNode(), mv,
+   EXPECT_TRUE(test1MultivalueExpressionException(ModuloFunctionNode(),
+                                                  MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV)),
                                                   "ModuloFunctionNode"));
-   EXPECT_TRUE(test1MultivalueExpression(MinFunctionNode(), mv,
+   EXPECT_TRUE(test1MultivalueExpression(MinFunctionNode(),
+                                         MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV)),
                                          Int64ResultNode(7)));
-   EXPECT_TRUE(test1MultivalueExpression(MaxFunctionNode(), mv,
+   EXPECT_TRUE(test1MultivalueExpression(MaxFunctionNode(),
+                                         MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV)),
                                          Int64ResultNode(117)));
 
    EXPECT_TRUE(
            test1MultivalueExpression(
                    FixedWidthBucketFunctionNode()
-                   .setWidth(Int64ResultNode(1)), mv,
+                   .setWidth(Int64ResultNode(1)),
+                   MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV)),
                    IntegerBucketResultNodeVector()
                    .push_back(IntegerBucketResultNode(7,8))
                    .push_back(IntegerBucketResultNode(17,18))
@@ -938,7 +863,7 @@ TEST("testMultivalueExpression") {
                            .push_back(IntegerBucketResultNode(0,10))
                            .push_back(IntegerBucketResultNode(20,30))
                            .push_back(IntegerBucketResultNode(100,120))),
-                   mv,
+                   MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV)),
                    IntegerBucketResultNodeVector()
                    .push_back(IntegerBucketResultNode(0,10))
                    .push_back(IntegerBucketResultNode(0,0))
@@ -947,114 +872,105 @@ TEST("testMultivalueExpression") {
    EXPECT_TRUE(
            test1MultivalueExpression(
                    TimeStampFunctionNode()
-                   .setTimePart(TimeStampFunctionNode::Second), mv,
+                   .setTimePart(TimeStampFunctionNode::Second),
+                   MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV)),
                    IntegerResultNodeVector()
                    .push_back(Int64ResultNode(7))
                    .push_back(Int64ResultNode(17))
                    .push_back(Int64ResultNode(117%60))));
 
    EXPECT_TRUE(
-           test1MultivalueExpression(NegateFunctionNode(), mv,
+           test1MultivalueExpression(NegateFunctionNode(),
+                                     MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV)),
                                      IntegerResultNodeVector()
                                      .push_back(Int64ResultNode(-7))
                                      .push_back(Int64ResultNode(-17))
                                      .push_back(Int64ResultNode(-117))));
-   EXPECT_TRUE(test1MultivalueExpression(SortFunctionNode(), mv,
+   EXPECT_TRUE(test1MultivalueExpression(SortFunctionNode(),
+                                         MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV)),
                                          IntegerResultNodeVector()
                                          .push_back(Int64ResultNode(7))
                                          .push_back(Int64ResultNode(17))
                                          .push_back(Int64ResultNode(117))));
-   EXPECT_TRUE(test1MultivalueExpression(ReverseFunctionNode(), mv,
+   EXPECT_TRUE(test1MultivalueExpression(ReverseFunctionNode(),
+                                         MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV)),
                                          IntegerResultNodeVector()
                                          .push_back(Int64ResultNode(117))
                                          .push_back(Int64ResultNode(17))
                                          .push_back(Int64ResultNode(7))));
    EXPECT_TRUE(test1MultivalueExpression(SortFunctionNode(),
-                                         ReverseFunctionNode(mv),
+                                         MU<ReverseFunctionNode>(MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV))),
                                          IntegerResultNodeVector()
                                          .push_back(Int64ResultNode(7))
                                          .push_back(Int64ResultNode(17))
                                          .push_back(Int64ResultNode(117))));
-   EXPECT_TRUE(test1MultivalueExpression(AndFunctionNode(), mv,
+   EXPECT_TRUE(test1MultivalueExpression(AndFunctionNode(),
+                                         MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV)),
                                          Int64ResultNode(7 & 17 & 117)));
-   EXPECT_TRUE(test1MultivalueExpression(OrFunctionNode(), mv,
+   EXPECT_TRUE(test1MultivalueExpression(OrFunctionNode(),
+                                         MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV)),
                                          Int64ResultNode(7 | 17 | 117)));
-   EXPECT_TRUE(test1MultivalueExpression(XorFunctionNode(), mv,
+   EXPECT_TRUE(test1MultivalueExpression(XorFunctionNode(),
+                                         MU<ConstantNode>(createIntRV<Int64ResultNodeVector>(IV)),
                                          Int64ResultNode(7 ^ 17 ^ 117)));
 }
 
+ExpressionNode::UP createScalarInt(int64_t v) { return MU<ConstantNode>(MU<Int64ResultNode>(v)); }
+ExpressionNode::UP createScalarFloat(double v) { return MU<ConstantNode>(MU<FloatResultNode>(v)); }
+ExpressionNode::UP createScalarString(const char * v) { return MU<ConstantNode>(MU<StringResultNode>(v)); }
+ExpressionNode::UP createScalarRaw(const char * v) { return MU<ConstantNode>(MU<RawResultNode>(v, strlen(v))); }
+
 TEST("testArithmeticNodes") {
     AttributeGuard attr1 = createInt64Attribute();
-    ExpressionNode::CP i1(new ConstantNode(new Int64ResultNode(1)));
-    ExpressionNode::CP i2(new ConstantNode(new Int64ResultNode(2)));
-    ExpressionNode::CP f1(new ConstantNode(new FloatResultNode(1.1)));
-    ExpressionNode::CP f2(new ConstantNode(new FloatResultNode(9.9)));
-    ExpressionNode::CP s1(new ConstantNode(new StringResultNode("1")));
-    ExpressionNode::CP s2(new ConstantNode(new StringResultNode("2")));
-    ExpressionNode::CP r1(new ConstantNode(new RawResultNode("1", 1)));
-    ExpressionNode::CP r2(new ConstantNode(new RawResultNode("2", 1)));
-    ExpressionNode::CP a1(new AttributeNode(*attr1));
-    ExpressionNode::CP a2(new AttributeNode(*attr1));
+    constexpr int64_t I1 = 1, I2 = 2;
+    constexpr double F1 = 1.1, F2 = 9.9;
+    constexpr const char * S2 = "2";
+
     AddFunctionNode add1;
-    add1.appendArg(i1);
-    add1.appendArg(i2);
+    add1.appendArg(createScalarInt(I1));
+    add1.appendArg(createScalarInt(I2));
     ExpressionTree et(add1);
 
     ExpressionTree::Configure treeConf;
     et.select(treeConf, treeConf);
 
-    EXPECT_TRUE(
-            et.getResult().getClass().inherits(IntegerResultNode::classId));
+    EXPECT_TRUE(et.getResult().getClass().inherits(IntegerResultNode::classId));
     EXPECT_TRUE(et.ExpressionNode::execute());
     EXPECT_EQUAL(et.getResult().getInteger(), 3);
     EXPECT_TRUE(et.ExpressionNode::execute());
     EXPECT_EQUAL(et.getResult().getInteger(), 3);
     AddFunctionNode add2;
-    add2.appendArg(i1);
-    add2.appendArg(f2);
+    add2.appendArg(createScalarInt(I1));
+    add2.appendArg(createScalarFloat(F2));
     add2.prepare(false);
-    EXPECT_TRUE(
-            add2.getResult().getClass().inherits(FloatResultNode::classId));
+    EXPECT_TRUE(add2.getResult().getClass().inherits(FloatResultNode::classId));
     AddFunctionNode add3;
-    add3.appendArg(i1);
-    add3.appendArg(s2);
+    add3.appendArg(createScalarInt(I1));
+    add3.appendArg(createScalarString(S2));
     add3.prepare(false);
-    EXPECT_TRUE(
-            add3.getResult().getClass().inherits(IntegerResultNode::classId));
+    EXPECT_TRUE(add3.getResult().getClass().inherits(IntegerResultNode::classId));
     AddFunctionNode add4;
-    add4.appendArg(i1);
-    add4.appendArg(r2);
+    add4.appendArg(createScalarInt(I1));
+    add4.appendArg(createScalarRaw(S2));
     add4.prepare(false);
-    EXPECT_TRUE(
-            add4.getResult().getClass().inherits(IntegerResultNode::classId));
+    EXPECT_TRUE(add4.getResult().getClass().inherits(IntegerResultNode::classId));
     AddFunctionNode add5;
-    add5.appendArg(i1);
-    add5.appendArg(a1);
+    add5.appendArg(createScalarInt(I1));
+    add5.appendArg(MU<AttributeNode>(*attr1));
     add5.prepare(false);
-    EXPECT_TRUE(
-            add5.getResult().getClass().inherits(IntegerResultNode::classId));
+    EXPECT_TRUE(add5.getResult().getClass().inherits(IntegerResultNode::classId));
     AddFunctionNode add6;
-    add6.appendArg(f1);
-    add6.appendArg(a1);
+    add6.appendArg(createScalarFloat(F1));
+    add6.appendArg(MU<AttributeNode>(*attr1));
     add6.prepare(false);
-    EXPECT_TRUE(
-            add6.getResult().getClass().inherits(FloatResultNode::classId));
-}
-
-void testArith(MultiArgFunctionNode &op, const ExpressionNode::CP &arg1,
-                     const ExpressionNode::CP & arg2, int64_t intResult,
-                     double floatResult) {
-    op.appendArg(arg1);
-    op.appendArg(arg2);
-    op.prepare(false);
-    op.execute();
-    EXPECT_EQUAL(intResult, op.getResult().getInteger());
-    ASSERT_TRUE(intResult == op.getResult().getInteger());
-    EXPECT_EQUAL(floatResult, op.getResult().getFloat());
+    EXPECT_TRUE(add6.getResult().getClass().inherits(FloatResultNode::classId));
 }
 
-void testArith2(MultiArgFunctionNode &op, int64_t intResult,
-                double floatResult) {
+void testArith(MultiArgFunctionNode &op, ExpressionNode::UP arg1, ExpressionNode::UP arg2,
+               int64_t intResult, double floatResult)
+{
+    op.appendArg(std::move(arg1));
+    op.appendArg(std::move(arg2));
     op.prepare(false);
     op.execute();
     EXPECT_EQUAL(intResult, op.getResult().getInteger());
@@ -1062,64 +978,57 @@ void testArith2(MultiArgFunctionNode &op, int64_t intResult,
     EXPECT_EQUAL(floatResult, op.getResult().getFloat());
 }
 
-void testAdd(const ExpressionNode::CP &arg1,
-             const ExpressionNode::CP &arg2,
-             int64_t intResult, double floatResult){
+void testAdd(ExpressionNode::UP arg1, ExpressionNode::UP arg2,
+             int64_t intResult, double floatResult)
+{
     AddFunctionNode add;
-    testArith(add, arg1, arg2, intResult, floatResult);
+    testArith(add, std::move(arg1), std::move(arg2), intResult, floatResult);
 }
 
-void testMultiply(const ExpressionNode::CP & arg1,
-                  const ExpressionNode::CP & arg2,
-                  int64_t intResult, double floatResult) {
+void testMultiply(ExpressionNode::UP arg1, ExpressionNode::UP arg2,
+                  int64_t intResult, double floatResult)
+{
     MultiplyFunctionNode add;
-    testArith(add, arg1, arg2, intResult, floatResult);
+    testArith(add, std::move(arg1), std::move(arg2), intResult, floatResult);
 }
 
-void testDivide(const ExpressionNode::CP & arg1,
-                const ExpressionNode::CP & arg2,
-                int64_t intResult, double floatResult) {
+void testDivide(ExpressionNode::UP arg1, ExpressionNode::UP arg2,
+                int64_t intResult, double floatResult)
+{
     DivideFunctionNode add;
-    testArith(add, arg1, arg2, intResult, floatResult);
+    testArith(add, std::move(arg1), std::move(arg2), intResult, floatResult);
 }
 
-void testModulo(const ExpressionNode::CP & arg1,
-                const ExpressionNode::CP & arg2,
-                int64_t intResult, double floatResult) {
+void testModulo(ExpressionNode::UP arg1, ExpressionNode::UP arg2,
+                int64_t intResult, double floatResult)
+{
     ModuloFunctionNode add;
-    testArith(add, arg1, arg2, intResult, floatResult);
+    testArith(add, std::move(arg1), std::move(arg2), intResult, floatResult);
 }
 
-void testArithmeticArguments(NumericFunctionNode &function,
-                             std::vector<double> & arg1,
-                             std::vector<double> & arg2,
-                             const std::vector<double> & result,
-                             double flattenResult) {
-    ExpressionNode::CP scalarInt1(new ConstantNode(new Int64ResultNode(
-                            static_cast<int64_t>(arg1[0]))));
-    ExpressionNode::CP scalarInt2(new ConstantNode(new Int64ResultNode(
-                            static_cast<int64_t>(arg2[0]))));
-    ExpressionNode::CP scalarFloat1(new ConstantNode(new FloatResultNode(
-                            arg1[0])));
-    ExpressionNode::CP scalarFloat2(new ConstantNode(new FloatResultNode(
-                            arg2[0])));
-
-    IntegerResultNodeVector iv1;
-    for (size_t i(0), m(arg1.size()); i<m; i++) {
-        iv1.push_back(Int64ResultNode(static_cast<int64_t>(arg1[i])));
+ExpressionNode::UP
+createVectorInt(const std::vector<double> & v) {
+    std::unique_ptr<IntegerResultNodeVector> r = MU<IntegerResultNodeVector>();
+    for (double d : v) {
+        r->push_back(Int64ResultNode(static_cast<int64_t>(d)));
     }
-    IntegerResultNodeVector iv2;
-    for (size_t i(0), m(arg2.size()); i<m; i++) {
-        iv2.push_back(Int64ResultNode(static_cast<int64_t>(arg2[i])));
-    }
-    FloatResultNodeVector fv1;
-    for (size_t i(0), m(arg1.size()); i<m; i++) {
-        fv1.push_back(FloatResultNode(arg1[i]));
-    }
-    FloatResultNodeVector fv2;
-    for (size_t i(0), m(arg2.size()); i<m; i++) {
-        fv2.push_back(FloatResultNode(arg2[i]));
+    return MU<ConstantNode>(std::move(r));
+}
+ExpressionNode::UP
+createVectorFloat(const std::vector<double> & v) {
+    std::unique_ptr<FloatResultNodeVector> r = MU<FloatResultNodeVector>();
+    for (double d : v) {
+        r->push_back(FloatResultNode(d));
     }
+    return MU<ConstantNode>(std::move(r));
+}
+
+void testArithmeticArguments(NumericFunctionNode &function,
+                             const std::vector<double> & arg1,
+                             const std::vector<double> & arg2,
+                             const std::vector<double> & result,
+                             double flattenResult)
+{
     IntegerResultNodeVector ir;
     for (size_t i(0), m(result.size()); i<m; i++) {
         ir.push_back(Int64ResultNode((int64_t)result[i]));
@@ -1128,128 +1037,105 @@ void testArithmeticArguments(NumericFunctionNode &function,
     for (size_t i(0), m(result.size()); i<m; i++) {
         fr.push_back(FloatResultNode(result[i]));
     }
-    ExpressionNode::CP vectorInt1(new ConstantNode(iv1));
-    ExpressionNode::CP vectorInt2(new ConstantNode(iv2));
-    ExpressionNode::CP vectorFloat1(new ConstantNode(fv1));
-    ExpressionNode::CP vectorFloat2(new ConstantNode(fv2));
-    function.appendArg(scalarInt1).appendArg(scalarInt2);
+    function.appendArg(createScalarInt(arg1[0])).appendArg(createScalarInt(arg2[0]));
     function.prepare(false);
-    EXPECT_TRUE(
-            function.getResult().getClass().equal(Int64ResultNode::classId));
+    EXPECT_TRUE(function.getResult().getClass().equal(Int64ResultNode::classId));
     EXPECT_TRUE(function.execute());
-    EXPECT_EQUAL(function.getResult().getInteger(),
-                 static_cast<int64_t>(result[0]));
+    EXPECT_EQUAL(function.getResult().getInteger(), static_cast<int64_t>(result[0]));
 
     function.reset();
 
-    function.appendArg(scalarInt1).appendArg(scalarFloat2);
+    function.appendArg(createScalarInt(arg1[0])).appendArg(createScalarFloat(arg2[0]));
     function.prepare(false);
-    EXPECT_TRUE(
-            function.getResult().getClass().equal(FloatResultNode::classId));
+    EXPECT_TRUE(function.getResult().getClass().equal(FloatResultNode::classId));
     EXPECT_TRUE(function.execute());
     EXPECT_EQUAL(function.getResult().getFloat(), result[0]);
 
     function.reset();
 
-    function.appendArg(scalarFloat1).appendArg(scalarInt2);
+    function.appendArg(createScalarFloat(arg1[0])).appendArg(createScalarInt(arg2[0]));
     function.prepare(false);
-    EXPECT_TRUE(
-            function.getResult().getClass().equal(FloatResultNode::classId));
+    EXPECT_TRUE(function.getResult().getClass().equal(FloatResultNode::classId));
     EXPECT_TRUE(function.execute());
     EXPECT_EQUAL(function.getResult().getFloat(), result[0]);
 
     function.reset();
 
-    function.appendArg(scalarFloat1).appendArg(scalarFloat2);
+    function.appendArg(createScalarFloat(arg1[0])).appendArg(createScalarFloat(arg2[0]));
     function.prepare(false);
-    EXPECT_TRUE(
-            function.getResult().getClass().equal(FloatResultNode::classId));
+    EXPECT_TRUE(function.getResult().getClass().equal(FloatResultNode::classId));
     EXPECT_TRUE(function.execute());
     EXPECT_EQUAL(function.getResult().getFloat(), result[0]);
 
     function.reset();
 
-    function.appendArg(vectorInt1);
+    function.appendArg(createVectorInt(arg1));
     function.prepare(false);
-    EXPECT_TRUE(
-            function.getResult().getClass().equal(Int64ResultNode::classId));
+    EXPECT_TRUE(function.getResult().getClass().equal(Int64ResultNode::classId));
     EXPECT_TRUE(function.execute());
-    EXPECT_EQUAL(function.getResult().getInteger(),
-                 static_cast<int64_t>(flattenResult));
+    EXPECT_EQUAL(function.getResult().getInteger(), static_cast<int64_t>(flattenResult));
 
     function.reset();
 
-    function.appendArg(vectorFloat1);
+    function.appendArg(createVectorFloat(arg1));
     function.prepare(false);
-    EXPECT_TRUE(
-            function.getResult().getClass().equal(FloatResultNode::classId));
+    EXPECT_TRUE(function.getResult().getClass().equal(FloatResultNode::classId));
     EXPECT_TRUE(function.execute());
     EXPECT_EQUAL(function.getResult().getFloat(), flattenResult);
 
     function.reset();
 
-    function.appendArg(vectorInt1).appendArg(vectorInt2);
+    function.appendArg(createVectorInt(arg1)).appendArg(createVectorInt(arg2));
     function.prepare(false);
-    EXPECT_TRUE(function.getResult().getClass()
-                .equal(IntegerResultNodeVector::classId));
+    EXPECT_TRUE(function.getResult().getClass().equal(IntegerResultNodeVector::classId));
     EXPECT_TRUE(function.execute());
-    EXPECT_TRUE(function.getResult().getClass()
-                .equal(IntegerResultNodeVector::classId));
-    EXPECT_EQUAL(static_cast<const IntegerResultNodeVector &>(
-                    function.getResult()).size(), 7u);
+    EXPECT_TRUE(function.getResult().getClass().equal(IntegerResultNodeVector::classId));
+    EXPECT_EQUAL(static_cast<const IntegerResultNodeVector &>(function.getResult()).size(), 7u);
     EXPECT_EQUAL(0, function.getResult().cmp(ir));
 
     function.reset();
 
-    function.appendArg(vectorFloat1).appendArg(vectorFloat2);
+    function.appendArg(createVectorFloat(arg1)).appendArg(createVectorFloat(arg2));
     function.prepare(false);
-    EXPECT_TRUE(function.getResult().getClass()
-                .equal(FloatResultNodeVector::classId));
+    EXPECT_TRUE(function.getResult().getClass().equal(FloatResultNodeVector::classId));
     EXPECT_TRUE(function.execute());
-    EXPECT_TRUE(function.getResult().getClass()
-                .equal(FloatResultNodeVector::classId));
-    EXPECT_EQUAL(static_cast<const FloatResultNodeVector &>(
-                    function.getResult()).size(), 7u);
+    EXPECT_TRUE(function.getResult().getClass().equal(FloatResultNodeVector::classId));
+    EXPECT_EQUAL(static_cast<const FloatResultNodeVector &>(function.getResult()).size(), 7u);
     EXPECT_EQUAL(0, function.getResult().cmp(fr));
 
     function.reset();
 
-    function.appendArg(vectorInt1).appendArg(vectorFloat2);
+    function.appendArg(createVectorInt(arg1)).appendArg(createVectorFloat(arg2));
     function.prepare(false);
-    EXPECT_TRUE(function.getResult().getClass()
-                .equal(FloatResultNodeVector::classId));
+    EXPECT_TRUE(function.getResult().getClass().equal(FloatResultNodeVector::classId));
     EXPECT_TRUE(function.execute());
-    EXPECT_TRUE(function.getResult().getClass()
-                .equal(FloatResultNodeVector::classId));
-    EXPECT_EQUAL(static_cast<const FloatResultNodeVector &>(
-                    function.getResult()).size(), 7u);
+    EXPECT_TRUE(function.getResult().getClass().equal(FloatResultNodeVector::classId));
+    EXPECT_EQUAL(static_cast<const FloatResultNodeVector &>(function.getResult()).size(), 7u);
     EXPECT_EQUAL(0, function.getResult().cmp(fr));
 
     function.reset();
 
-    function.appendArg(vectorFloat1).appendArg(vectorInt2);
+    function.appendArg(createVectorFloat(arg1)).appendArg(createVectorInt(arg2));
     function.prepare(false);
-    EXPECT_TRUE(function.getResult().getClass()
-                .equal(FloatResultNodeVector::classId));
+    EXPECT_TRUE(function.getResult().getClass().equal(FloatResultNodeVector::classId));
     EXPECT_TRUE(function.execute());
-    EXPECT_TRUE(function.getResult().getClass()
-                .equal(FloatResultNodeVector::classId));
-    EXPECT_EQUAL(static_cast<const FloatResultNodeVector &>(
-                    function.getResult()).size(), 7u);
+    EXPECT_TRUE(function.getResult().getClass().equal(FloatResultNodeVector::classId));
+    EXPECT_EQUAL(static_cast<const FloatResultNodeVector &>(function.getResult()).size(), 7u);
     EXPECT_EQUAL(0, function.getResult().cmp(fr));
 }
 
 TEST("testArithmeticOperations") {
-    ExpressionNode::CP i1(new ConstantNode(new Int64ResultNode(1793253241)));
-    ExpressionNode::CP i2(new ConstantNode(new Int64ResultNode(1676521321)));
-    ExpressionNode::CP f1(new ConstantNode(new FloatResultNode(1.1109876)));
-    ExpressionNode::CP f2(new ConstantNode(new FloatResultNode(9.767681239)));
-    testAdd(i1, i2, 3469774562ull, 3469774562ull);
-    testAdd(i1, f2, 1793253251ull, 1793253250.767681239);
-    testAdd(f1, f2, 11, 10.878668839 );
-    testMultiply(i1, i2, 3006427292488851361ull, 3006427292488851361ull);
-    testMultiply(i1, f2, 17515926039ull, 1793253241.0*9.767681239);
-    testMultiply(f1, f2, 11, 10.8517727372816364 );
+    constexpr int64_t I1 = 1793253241;
+    constexpr int64_t I2 = 1676521321;
+    constexpr double F1 = 1.1109876;
+    constexpr double F2 = 9.767681239;
+
+    testAdd(createScalarInt(I1), createScalarInt(I2), 3469774562ull, 3469774562ull);
+    testAdd(createScalarInt(I1), createScalarFloat(F2), 1793253251ull, 1793253250.767681239);
+    testAdd(createScalarFloat(F1), createScalarFloat(F2), 11, 10.878668839 );
+    testMultiply(createScalarInt(I1), createScalarInt(I2), 3006427292488851361ull, 3006427292488851361ull);
+    testMultiply(createScalarInt(I1), createScalarFloat(F2), 17515926039ull, 1793253241.0*9.767681239);
+    testMultiply(createScalarFloat(F1), createScalarFloat(F2), 11, 10.8517727372816364 );
 
     std::vector<double> a(5), b(7);
     a[0] = b[0] = 1;
@@ -1284,57 +1170,52 @@ TEST("testArithmeticOperations") {
     }
 }
 
-TEST("testAggregatorsInExpressions") {
-    CountAggregationResult *c = new CountAggregationResult();
-    c->setCount(3);
-    SumAggregationResult *s = new SumAggregationResult();
-    ResultNode::CP r1(new Int64ResultNode(7)),
-                   r2(new Int64ResultNode(22));
-    ExpressionNode::CP i1(new ConstantNode(new Int64ResultNode(7))),
-                       i2(c),
-                       i3(s),
-                       i4(new ConstantNode(new Int64ResultNode(22)));
+ExpressionNode::UP createCountAggr(int64_t initial) { return MU<CountAggregationResult>(initial); }
+ExpressionNode::UP createMinAggr(const ResultNode & initial) { return MU<MinAggregationResult>(initial); }
+
+constexpr int64_t I1 = 7, I2 = 3, I4 = 22;
+
+ExpressionNode::UP createSumAggr() {
+    std::unique_ptr<SumAggregationResult> s = MU<SumAggregationResult>();
     AggregationResult::Configure conf;
-    s->setExpression(i4).select(conf, conf);
+    s->setExpression(createScalarInt(I4)).select(conf, conf);
     s->aggregate(0, 0);
+    return s;
+}
+
+TEST("testAggregatorsInExpressions") {
+    Int64ResultNode r1(I1);
+    Int64ResultNode r2(I4);
 
-    testAdd(i1, i2, 10, 10);
-    testMultiply(i1, i2, 21, 21);
-    testMultiply(i2, i3, 66, 66);
-    testDivide(i3, i2, 7, 7);
-    testDivide(i3, i1, 3, 3);
-    testModulo(i3, i2, 1, 1);
-    testModulo(i3, i1, 1, 1);
 
-    MinAggregationResult *min = new MinAggregationResult();
-    min->setResult(r2);
-    ExpressionNode::CP imin(min);
-    testAdd(imin, i1, 29, 29);
+    testAdd(createScalarInt(I1), createCountAggr(I2), 10, 10);
+    testMultiply(createScalarInt(I1), createCountAggr(I2), 21, 21);
+    testMultiply(createCountAggr(I2), createSumAggr(), 66, 66);
+    testDivide(createSumAggr(), createCountAggr(I2), 7, 7);
+    testDivide(createSumAggr(), createScalarInt(I1), 3, 3);
+    testModulo(createSumAggr(), createCountAggr(I2), 1, 1);
+    testModulo(createSumAggr(), createScalarInt(I1), 1, 1);
 
-    MaxAggregationResult *max = new MaxAggregationResult();
-    max->setResult(r1);
-    ExpressionNode::CP imax(max);
-    testAdd(imin, imax, 29, 29);
+    testAdd(MU<MinAggregationResult>(r2), createScalarInt(I1), 29, 29);
+    testAdd(MU<MinAggregationResult>(r2), MU<MaxAggregationResult>(r1), 29, 29);
 
+    AggregationResult::Configure conf;
     XorAggregationResult *x = new XorAggregationResult();
-    x->setExpression(i4).select(conf, conf);
+    x->setExpression(createScalarInt(I4)).select(conf, conf);
     x->aggregate(0, 0);
-    ExpressionNode::CP ix(x);
-    testAdd(ix, i1, 29, 29);
+    testAdd(ExpressionNode::UP(x), createScalarInt(I1), 29, 29);
 
     AverageAggregationResult *avg = new AverageAggregationResult();
-    avg->setExpression(i4).select(conf, conf);
+    avg->setExpression(createScalarInt(I4)).select(conf, conf);
     avg->aggregate(0, 0);
-    ExpressionNode::CP iavg(avg);
-    testAdd(iavg, i1, 29, 29);
+    testAdd(ExpressionNode::UP(avg), createScalarInt(I1), 29, 29);
 }
 
 void testAggregationResult(AggregationResult & aggr, const AggrGetter & g,
                            const ResultNode & v, const ResultNode & i,
                            const ResultNode & m, const ResultNode & s) {
-    ExpressionNode::CP scalarInt1(new ConstantNode(v));
     AggregationResult::Configure conf;
-    aggr.setExpression(scalarInt1).select(conf, conf);
+    aggr.setExpression(MU<ConstantNode>(ResultNode::UP(v.clone()))).select(conf, conf);
     EXPECT_TRUE(g(aggr).getClass().equal(i.getClass().id()));
     EXPECT_EQUAL(0, i.cmp(g(aggr)));
     aggr.aggregate(0,0);
@@ -1368,135 +1249,100 @@ TEST("testAggregationResults") {
 
 TEST("testGrouping") {
     AttributeGuard attr1 = createInt64Attribute();
-    ExpressionNode::CP select1(new AttributeNode(*attr1));
-    ExpressionNode::CP result1(new CountAggregationResult());
-    (static_cast<AggregationResult &>(*result1)).setExpression(select1);
-    ExpressionNode::CP result2( new SumAggregationResult());
-    (static_cast<AggregationResult &>(*result2)).setExpression(select1);
-
-    Grouping grouping = Grouping()
-                        .setFirstLevel(0)
-                        .setLastLevel(1)
-                        .addLevel(GroupingLevel()
-                                  .setExpression(select1)
-                                  .addResult(result1)
-                                  .addResult(result2));
+    ExpressionNode::UP result1(new CountAggregationResult());
+    (static_cast<AggregationResult &>(*result1)).setExpression(MU<AttributeNode>(*attr1));
+    ExpressionNode::UP result2( new SumAggregationResult());
+    (static_cast<AggregationResult &>(*result2)).setExpression(MU<AttributeNode>(*attr1));
+
+    Grouping grouping;
+    grouping.setFirstLevel(0)
+            .setLastLevel(1)
+            .addLevel(std::move(GroupingLevel()
+                                        .setExpression(MU<AttributeNode>(*attr1))
+                                        .addResult(std::move(result1))
+                                        .addResult(std::move(result2))));
 
     grouping.configureStaticStuff(ConfigureStaticParams(0, 0));
     grouping.aggregate(0u, 10u);
     const Group::GroupList &groups = grouping.getRoot().groups();
     EXPECT_EQUAL(grouping.getRoot().getChildrenSize(), 9u);
-    ASSERT_TRUE(groups[0]->getAggregationResult(0).getClass().id() ==
-                CountAggregationResult::classId);
-    ASSERT_TRUE(groups[0]->getAggregationResult(1).getClass().id() ==
-                SumAggregationResult::classId);
+    ASSERT_TRUE(groups[0]->getAggregationResult(0).getClass().id() == CountAggregationResult::classId);
+    ASSERT_TRUE(groups[0]->getAggregationResult(1).getClass().id() == SumAggregationResult::classId);
     EXPECT_EQUAL(groups[0]->getId().getInteger(), 6u);
-    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(
-                    groups[0]->getAggregationResult(0)).getCount(), 1u);
-    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(
-                    groups[0]->getAggregationResult(1)).getSum().getInteger(),
-                 6);
+    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(groups[0]->getAggregationResult(0)).getCount(), 1u);
+    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(groups[0]->getAggregationResult(1)).getSum().getInteger(), 6);
     EXPECT_EQUAL(groups[1]->getId().getInteger(), 7u);
-    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(
-                    groups[1]->getAggregationResult(0)).getCount(), 1u);
-    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(
-                    groups[1]->getAggregationResult(1)).getSum().getInteger(),
-                 7);
+    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(groups[1]->getAggregationResult(0)).getCount(), 1u);
+    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(groups[1]->getAggregationResult(1)).getSum().getInteger(), 7);
     EXPECT_EQUAL(groups[2]->getId().getInteger(), 11u);
-    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(
-                    groups[2]->getAggregationResult(0)).getCount(), 1u);
-    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(
-                    groups[2]->getAggregationResult(1)).getSum().getInteger(),
-                 11);
+    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(groups[2]->getAggregationResult(0)).getCount(), 1u);
+    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(groups[2]->getAggregationResult(1)).getSum().getInteger(), 11);
     EXPECT_EQUAL(groups[3]->getId().getInteger(), 13u);
-    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(
-                    groups[3]->getAggregationResult(0)).getCount(), 2u);
-    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(
-                    groups[3]->getAggregationResult(1)).getSum().getInteger(),
-                 26);
+    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(groups[3]->getAggregationResult(0)).getCount(), 2u);
+    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(groups[3]->getAggregationResult(1)).getSum().getInteger(), 26);
     EXPECT_EQUAL(groups[4]->getId().getInteger(), 17u);
-    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(
-                    groups[4]->getAggregationResult(0)).getCount(), 1u);
-    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(
-                    groups[4]->getAggregationResult(1)).getSum().getInteger(),
-                 17);
+    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(groups[4]->getAggregationResult(0)).getCount(), 1u);
+    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(groups[4]->getAggregationResult(1)).getSum().getInteger(), 17);
     EXPECT_EQUAL(groups[5]->getId().getInteger(), 27u);
-    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(
-                    groups[5]->getAggregationResult(0)).getCount(), 1u);
-    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(
-                    groups[5]->getAggregationResult(1)).getSum().getInteger(),
-                 27);
+    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(groups[5]->getAggregationResult(0)).getCount(), 1u);
+    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(groups[5]->getAggregationResult(1)).getSum().getInteger(), 27);
     EXPECT_EQUAL(groups[6]->getId().getInteger(), 34u);
-    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(
-                    groups[6]->getAggregationResult(0)).getCount(), 1u);
-    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(
-                    groups[6]->getAggregationResult(1)).getSum().getInteger(),
-                 34);
+    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(groups[6]->getAggregationResult(0)).getCount(), 1u);
+    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(groups[6]->getAggregationResult(1)).getSum().getInteger(), 34);
     EXPECT_EQUAL(groups[7]->getId().getInteger(), 67891u);
-    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(
-                    groups[7]->getAggregationResult(0)).getCount(), 1u);
-    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(
-                    groups[7]->getAggregationResult(1)).getSum().getInteger(),
-                 67891);
+    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(groups[7]->getAggregationResult(0)).getCount(), 1u);
+    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(groups[7]->getAggregationResult(1)).getSum().getInteger(), 67891);
     EXPECT_EQUAL(groups[8]->getId().getInteger(), 67892u);
-    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(
-                    groups[8]->getAggregationResult(0)).getCount(), 1u);
-    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(
-                    groups[8]->getAggregationResult(1)).getSum().getInteger(),
-                 67892);
+    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(groups[8]->getAggregationResult(0)).getCount(), 1u);
+    EXPECT_EQUAL(static_cast<const SumAggregationResult &>(groups[8]->getAggregationResult(1)).getSum().getInteger(), 67892);
     testStreaming(grouping);
 }
 
-TEST("testGrouping2") {
-    AttributeGuard attr1 = createInt64Attribute();
 
-    RangeBucketPreDefFunctionNode *predef(
-            new RangeBucketPreDefFunctionNode(AttributeNode(*attr1)));
+ExpressionNode::UP
+createPredefRangeBucket(const AttributeGuard & guard) {
+    RangeBucketPreDefFunctionNode *predef(new RangeBucketPreDefFunctionNode(MU<AttributeNode>(*guard)));
     IntegerBucketResultNodeVector prevec;
     prevec.getVector().push_back(IntegerBucketResultNode(6,7));
     prevec.getVector().push_back(IntegerBucketResultNode(7,14));
     prevec.getVector().push_back(IntegerBucketResultNode(18,50)); //30
-    prevec.getVector()
-        .push_back(IntegerBucketResultNode(80,50000000000ull)); //30
+    prevec.getVector().push_back(IntegerBucketResultNode(80,50000000000ull)); //30
     predef->setBucketList(prevec);
-    ExpressionNode::CP select1(predef);
-    ExpressionNode::CP result1( new CountAggregationResult());
-    (static_cast<AggregationResult &>(*result1)).setExpression(select1);
+    return ExpressionNode::UP(predef);
+}
+
+TEST("testGrouping2") {
+    AttributeGuard attr1 = createInt64Attribute();
+    ExpressionNode::UP result1( new CountAggregationResult());
+    (static_cast<AggregationResult &>(*result1)).setExpression(createPredefRangeBucket(attr1));
 
-    Grouping grouping = Grouping()
-                        .setFirstLevel(0)
-                        .setLastLevel(1)
-                        .addLevel(GroupingLevel()
-                                  .setExpression(select1)
-                                  .addResult(result1));
+    Grouping grouping;
+    grouping.setFirstLevel(0)
+            .setLastLevel(1)
+            .addLevel(std::move(GroupingLevel()
+                              .setExpression(createPredefRangeBucket(attr1))
+                              .addResult(std::move(result1))));
 
     grouping.configureStaticStuff(ConfigureStaticParams(0, 0));
     grouping.aggregate(0u, 10u);
     const Group::GroupList &groups = grouping.getRoot().groups();
     EXPECT_EQUAL(grouping.getRoot().getChildrenSize(), 5u);
-    ASSERT_TRUE(groups[0]->getAggregationResult(0).getClass().id()
-                == CountAggregationResult::classId);
+    ASSERT_TRUE(groups[0]->getAggregationResult(0).getClass().id() == CountAggregationResult::classId);
     EXPECT_EQUAL(groups[0]->getId().getInteger(), 0u);
-    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(
-                    groups[0]->getAggregationResult(0)).getCount(), 1u);
+    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(groups[0]->getAggregationResult(0)).getCount(), 1u);
     EXPECT_EQUAL(groups[1]->getId().getInteger(), 0u);
-    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(
-                    groups[1]->getAggregationResult(0)).getCount(), 1u);
+    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(groups[1]->getAggregationResult(0)).getCount(), 1u);
     EXPECT_EQUAL(groups[2]->getId().getInteger(), 0u);
-    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(
-                    groups[2]->getAggregationResult(0)).getCount(), 4u);
+    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(groups[2]->getAggregationResult(0)).getCount(), 4u);
     EXPECT_EQUAL(groups[3]->getId().getInteger(), 0u);
-    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(
-                    groups[3]->getAggregationResult(0)).getCount(), 2u);
+    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(groups[3]->getAggregationResult(0)).getCount(), 2u);
     EXPECT_EQUAL(groups[4]->getId().getInteger(), 0u);
-    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(
-                    groups[4]->getAggregationResult(0)).getCount(), 2u);
+    EXPECT_EQUAL(static_cast<const CountAggregationResult &>(groups[4]->getAggregationResult(0)).getCount(), 2u);
     testStreaming(grouping);
 }
 
 AttributeGuard createInt64Attribute() {
-    SingleInt64ExtAttribute *selectAttr1(
-            new SingleInt64ExtAttribute("selectAttr1"));
+    SingleInt64ExtAttribute *selectAttr1(new SingleInt64ExtAttribute("selectAttr1"));
     DocId docId(0);
     selectAttr1->addDoc(docId);
     selectAttr1->add(7);
@@ -1525,8 +1371,7 @@ AttributeGuard createInt64Attribute() {
 }
 
 AttributeGuard createInt32Attribute() {
-    SingleInt32ExtAttribute *selectAttr1(
-            new SingleInt32ExtAttribute("selectAttr1"));
+    SingleInt32ExtAttribute *selectAttr1(new SingleInt32ExtAttribute("selectAttr1"));
     DocId docId(0);
     selectAttr1->addDoc(docId);
     selectAttr1->add(7);
@@ -1555,8 +1400,7 @@ AttributeGuard createInt32Attribute() {
 }
 
 AttributeGuard createInt16Attribute() {
-    SingleInt16ExtAttribute *selectAttr1(
-            new SingleInt16ExtAttribute("selectAttr1"));
+    SingleInt16ExtAttribute *selectAttr1(new SingleInt16ExtAttribute("selectAttr1"));
     DocId docId(0);
     selectAttr1->addDoc(docId);
     selectAttr1->add(7);
@@ -1585,8 +1429,7 @@ AttributeGuard createInt16Attribute() {
 }
 
 AttributeGuard createInt8Attribute() {
-    SingleInt8ExtAttribute *selectAttr1(
-            new SingleInt8ExtAttribute("selectAttr1"));
+    SingleInt8ExtAttribute *selectAttr1(new SingleInt8ExtAttribute("selectAttr1"));
     DocId docId(0);
     selectAttr1->addDoc(docId);
     selectAttr1->add(7);
@@ -1640,38 +1483,28 @@ TEST("testIntegerTypes") {
                  .prepare(true).getResult().getClass().id(),
                  uint32_t(Int64ResultNode::classId));
 
-    EXPECT_EQUAL(
-            AttributeNode(*AttributeGuard(AttributeVector::SP(
-                                    new MultiInt8ExtAttribute("test"))))
+    EXPECT_EQUAL(AttributeNode(*AttributeGuard(AttributeVector::SP(new MultiInt8ExtAttribute("test"))))
             .prepare(false).getResult().getClass().id(),
             uint32_t(Int64ResultNodeVector::classId));
-    EXPECT_EQUAL(
-            AttributeNode(*AttributeGuard(AttributeVector::SP(
-                                    new MultiInt8ExtAttribute("test"))))
+    EXPECT_EQUAL(AttributeNode(*AttributeGuard(AttributeVector::SP(new MultiInt8ExtAttribute("test"))))
             .prepare(true).getResult().getClass().id(),
             uint32_t(Int8ResultNodeVector::classId));
-    EXPECT_EQUAL(AttributeNode(*AttributeGuard(AttributeVector::SP(
-                                    new MultiInt16ExtAttribute("test"))))
+    EXPECT_EQUAL(AttributeNode(*AttributeGuard(AttributeVector::SP(new MultiInt16ExtAttribute("test"))))
                  .prepare(false).getResult().getClass().id(),
                  uint32_t(Int64ResultNodeVector::classId));
-    EXPECT_EQUAL(AttributeNode(*AttributeGuard(AttributeVector::SP(
-                                    new MultiInt16ExtAttribute("test"))))
+    EXPECT_EQUAL(AttributeNode(*AttributeGuard(AttributeVector::SP(new MultiInt16ExtAttribute("test"))))
                  .prepare(true).getResult().getClass().id(),
                  uint32_t(Int16ResultNodeVector::classId));
-    EXPECT_EQUAL(AttributeNode(*AttributeGuard(AttributeVector::SP(
-                                    new MultiInt32ExtAttribute("test"))))
+    EXPECT_EQUAL(AttributeNode(*AttributeGuard(AttributeVector::SP(new MultiInt32ExtAttribute("test"))))
                  .prepare(false).getResult().getClass().id(),
                  uint32_t(Int64ResultNodeVector::classId));
-    EXPECT_EQUAL(AttributeNode(*AttributeGuard(AttributeVector::SP(
-                                    new MultiInt32ExtAttribute("test"))))
+    EXPECT_EQUAL(AttributeNode(*AttributeGuard(AttributeVector::SP(new MultiInt32ExtAttribute("test"))))
                  .prepare(true).getResult().getClass().id(),
                  uint32_t(Int32ResultNodeVector::classId));
-    EXPECT_EQUAL(AttributeNode(*AttributeGuard(AttributeVector::SP(
-                                    new MultiInt64ExtAttribute("test"))))
+    EXPECT_EQUAL(AttributeNode(*AttributeGuard(AttributeVector::SP(new MultiInt64ExtAttribute("test"))))
                  .prepare(false).getResult().getClass().id(),
                  uint32_t(Int64ResultNodeVector::classId));
-    EXPECT_EQUAL(AttributeNode(*AttributeGuard(AttributeVector::SP(
-                                    new MultiInt64ExtAttribute("test"))))
+    EXPECT_EQUAL(AttributeNode(*AttributeGuard(AttributeVector::SP(new MultiInt64ExtAttribute("test"))))
                  .prepare(true).getResult().getClass().id(),
                  uint32_t(Int64ResultNodeVector::classId));
 }
diff --git a/searchlib/src/tests/grouping/grouping_serialization_test.cpp b/searchlib/src/tests/grouping/grouping_serialization_test.cpp
index a7a197d44d5..0586594ec5c 100644
--- a/searchlib/src/tests/grouping/grouping_serialization_test.cpp
+++ b/searchlib/src/tests/grouping/grouping_serialization_test.cpp
@@ -27,6 +27,8 @@ document::GlobalId getGlobalId(uint32_t docId) {
         .getGlobalId();
 }
 
+#define MU std::make_unique
+
 struct Fixture {
     // Set WRITE_FILES to true to generate new expected serialization files.
     const bool WRITE_FILES = false;
@@ -69,28 +71,27 @@ struct Fixture {
         Identifiable::UP newObj = Identifiable::create(stream);
 
         if (!EXPECT_TRUE(newObj.get() != 0)) {
-            LOG(error, "object of class '%s' resulted in empty echo",
-                obj.getClass().name());
+            LOG(error, "object of class '%s' resulted in empty echo", obj.getClass().name());
             return;
         }
         if (EXPECT_EQUAL(obj.asString(), newObj->asString())
             && EXPECT_TRUE(newObj->cmp(obj) == 0)
             && EXPECT_TRUE(obj.cmp(*newObj) == 0))
         {
-            LOG(info, "object of class '%s' passed echo test : %s",
-                obj.getClass().name(), newObj->asString().c_str());
+            LOG(info, "object of class '%s' passed echo test : %s", obj.getClass().name(), newObj->asString().c_str());
         } else {
-            LOG(error, "object of class '%s' FAILED echo test",
-                obj.getClass().name());
+            LOG(error, "object of class '%s' FAILED echo test", obj.getClass().name());
         }
     }
 };
 
 //-----------------------------------------------------------------------------
 
-ExpressionNode::CP createDummyExpression() {
-    return AddFunctionNode().addArg(ConstantNode(Int64ResultNode(2)))
-        .addArg(ConstantNode(Int64ResultNode(2)));
+ExpressionNode::UP
+createDummyExpression() {
+    std::unique_ptr<AddFunctionNode> f = MU<AddFunctionNode>();
+    f->addArg(MU<ConstantNode>(MU<Int64ResultNode>(2))).addArg(MU<ConstantNode>(MU<Int64ResultNode>(2)));
+    return f;
 }
 
 //-----------------------------------------------------------------------------
@@ -150,83 +151,82 @@ TEST_F("testSpecialNodes", Fixture("testSpecialNodes")) {
 
 TEST_F("testFunctionNodes", Fixture("testFunctionNodes")) {
     f.checkObject(AddFunctionNode()
-                .addArg(ConstantNode(Int64ResultNode(7)))
-                .addArg(ConstantNode(Int64ResultNode(8)))
-                .addArg(ConstantNode(Int64ResultNode(9))));
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(7)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(8)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(9))));
     f.checkObject(XorFunctionNode()
-                .addArg(ConstantNode(Int64ResultNode(7)))
-                .addArg(ConstantNode(Int64ResultNode(8)))
-                .addArg(ConstantNode(Int64ResultNode(9))));
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(7)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(8)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(9))));
     f.checkObject(MultiplyFunctionNode()
-                .addArg(ConstantNode(Int64ResultNode(7)))
-                .addArg(ConstantNode(Int64ResultNode(8)))
-                .addArg(ConstantNode(Int64ResultNode(9))));
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(7)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(8)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(9))));
     f.checkObject(DivideFunctionNode()
-                .addArg(ConstantNode(Int64ResultNode(7)))
-                .addArg(ConstantNode(Int64ResultNode(8)))
-                .addArg(ConstantNode(Int64ResultNode(9))));
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(7)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(8)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(9))));
     f.checkObject(ModuloFunctionNode()
-                .addArg(ConstantNode(Int64ResultNode(7)))
-                .addArg(ConstantNode(Int64ResultNode(8)))
-                .addArg(ConstantNode(Int64ResultNode(9))));
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(7)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(8)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(9))));
     f.checkObject(MinFunctionNode()
-                .addArg(ConstantNode(Int64ResultNode(7)))
-                .addArg(ConstantNode(Int64ResultNode(8)))
-                .addArg(ConstantNode(Int64ResultNode(9))));
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(7)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(8)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(9))));
     f.checkObject(MaxFunctionNode()
-                .addArg(ConstantNode(Int64ResultNode(7)))
-                .addArg(ConstantNode(Int64ResultNode(8)))
-                .addArg(ConstantNode(Int64ResultNode(9))));
-    f.checkObject(TimeStampFunctionNode(ConstantNode(Int64ResultNode(7)),
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(7)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(8)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(9))));
+    f.checkObject(TimeStampFunctionNode(MU<ConstantNode>(MU<Int64ResultNode>(7)),
                                       TimeStampFunctionNode::Hour, true));
-    f.checkObject(ZCurveFunctionNode(ConstantNode(Int64ResultNode(7)),
+    f.checkObject(ZCurveFunctionNode(MU<ConstantNode>(MU<Int64ResultNode>(7)),
                                    ZCurveFunctionNode::X));
-    f.checkObject(ZCurveFunctionNode(ConstantNode(Int64ResultNode(7)),
+    f.checkObject(ZCurveFunctionNode(MU<ConstantNode>(MU<Int64ResultNode>(7)),
                                    ZCurveFunctionNode::Y));
-    f.checkObject(NegateFunctionNode(ConstantNode(Int64ResultNode(7))));
-    f.checkObject(SortFunctionNode(ConstantNode(Int64ResultNode(7))));
-    f.checkObject(NormalizeSubjectFunctionNode(ConstantNode(
-                            StringResultNode("foo"))));
-    f.checkObject(ReverseFunctionNode(ConstantNode(Int64ResultNode(7))));
-    f.checkObject(MD5BitFunctionNode(ConstantNode(Int64ResultNode(7)), 64));
-    f.checkObject(XorBitFunctionNode(ConstantNode(Int64ResultNode(7)), 64));
+    f.checkObject(NegateFunctionNode(MU<ConstantNode>(MU<Int64ResultNode>(7))));
+    f.checkObject(SortFunctionNode(MU<ConstantNode>(MU<Int64ResultNode>(7))));
+    f.checkObject(NormalizeSubjectFunctionNode(MU<ConstantNode>(MU<StringResultNode>("foo"))));
+    f.checkObject(ReverseFunctionNode(MU<ConstantNode>(MU<Int64ResultNode>(7))));
+    f.checkObject(MD5BitFunctionNode(MU<ConstantNode>(MU<Int64ResultNode>(7)), 64));
+    f.checkObject(XorBitFunctionNode(MU<ConstantNode>(MU<Int64ResultNode>(7)), 64));
     f.checkObject(CatFunctionNode()
-                .addArg(ConstantNode(Int64ResultNode(7)))
-                .addArg(ConstantNode(Int64ResultNode(8)))
-                .addArg(ConstantNode(Int64ResultNode(9))));
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(7)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(8)))
+                .addArg(MU<ConstantNode>(MU<Int64ResultNode>(9))));
     f.checkObject(FixedWidthBucketFunctionNode());
-    f.checkObject(FixedWidthBucketFunctionNode(AttributeNode("foo")));
-    f.checkObject(FixedWidthBucketFunctionNode(AttributeNode("foo"))
+    f.checkObject(FixedWidthBucketFunctionNode(MU<AttributeNode>("foo")));
+    f.checkObject(FixedWidthBucketFunctionNode(MU<AttributeNode>("foo"))
                 .setWidth(Int64ResultNode(10)));
-    f.checkObject(FixedWidthBucketFunctionNode(AttributeNode("foo"))
+    f.checkObject(FixedWidthBucketFunctionNode(MU<AttributeNode>("foo"))
                 .setWidth(FloatResultNode(10.0)));
     f.checkObject(RangeBucketPreDefFunctionNode());
-    f.checkObject(RangeBucketPreDefFunctionNode(AttributeNode("foo")));
-    f.checkObject(DebugWaitFunctionNode(ConstantNode(Int64ResultNode(5)),
+    f.checkObject(RangeBucketPreDefFunctionNode(MU<AttributeNode>("foo")));
+    f.checkObject(DebugWaitFunctionNode(MU<ConstantNode>(MU<Int64ResultNode>(5)),
                                       3.3, false));
 }
 
 TEST_F("testAggregatorResults", Fixture("testAggregatorResults")) {
     f.checkObject(SumAggregationResult()
-                .setExpression(AttributeNode("attributeA"))
+                .setExpression(MU<AttributeNode>("attributeA"))
                 .setResult(Int64ResultNode(7)));
     f.checkObject(XorAggregationResult()
                 .setXor(Int64ResultNode(7))
-                .setExpression(AttributeNode("attributeA")));
+                .setExpression(MU<AttributeNode>("attributeA")));
     f.checkObject(CountAggregationResult()
                 .setCount(7)
-                .setExpression(AttributeNode("attributeA")));
+                .setExpression(MU<AttributeNode>("attributeA")));
     f.checkObject(MinAggregationResult()
-                .setExpression(AttributeNode("attributeA"))
+                .setExpression(MU<AttributeNode>("attributeA"))
                 .setResult(Int64ResultNode(7)));
     f.checkObject(MaxAggregationResult()
-                .setExpression(AttributeNode("attributeA"))
+                .setExpression(MU<AttributeNode>("attributeA"))
                 .setResult(Int64ResultNode(7)));
     f.checkObject(AverageAggregationResult()
-                .setExpression(AttributeNode("attributeA"))
+                .setExpression(MU<AttributeNode>("attributeA"))
                 .setResult(Int64ResultNode(7)));
     ExpressionCountAggregationResult expression_count;
-    expression_count.setExpression(ConstantNode(Int64ResultNode(67)))
+    expression_count.setExpression(MU<ConstantNode>(MU<Int64ResultNode>(67)))
         .aggregate(DocId(42), HitRank(21));
     f.checkObject(expression_count);
 }
@@ -245,7 +245,7 @@ TEST_F("testHitCollection", Fixture("testHitCollection")) {
                 .addHit(FS4Hit(0, 3.0).setGlobalId(getGlobalId(30)))
                 .addHit(FS4Hit(0, 4.0).setGlobalId(getGlobalId(40)))
                 .addHit(FS4Hit(0, 5.0).setGlobalId(getGlobalId(50)))
-                .setExpression(ConstantNode(Int64ResultNode(5))));
+                .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(5))));
     f.checkObject(HitsAggregationResult()
                 .setMaxHits(3)
                 .addHit(FS4Hit(0, 1.0).setGlobalId(getGlobalId(10))
@@ -254,20 +254,20 @@ TEST_F("testHitCollection", Fixture("testHitCollection")) {
                         .setDistributionKey(200))
                 .addHit(FS4Hit(0, 3.0).setGlobalId(getGlobalId(30))
                         .setDistributionKey(300))
-                .setExpression(ConstantNode(Int64ResultNode(5))));
+                .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(5))));
     f.checkObject(HitsAggregationResult()
                 .setMaxHits(3)
                 .addHit(VdsHit("10", 1.0).setSummary("100", 3))
                 .addHit(VdsHit("20", 2.0).setSummary("200", 3))
                 .addHit(VdsHit("30", 3.0).setSummary("300", 3))
-                .setExpression(ConstantNode(Int64ResultNode(5))));
+                .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(5))));
 }
 
 TEST_F("testGroupingLevel", Fixture("testGroupingLevel")) {
     f.checkObject(GroupingLevel()
                 .setMaxGroups(100)
                 .setExpression(createDummyExpression())
-                .addAggregationResult(SumAggregationResult()
+                .addResult(SumAggregationResult()
                            .setExpression(createDummyExpression())));
 }
 
@@ -279,9 +279,9 @@ TEST_F("testGroup", Fixture("testGroup")) {
                 .addChild(Group().setId(Int64ResultNode(110)))
                 .addChild(Group().setId(Int64ResultNode(120))
                           .setRank(20.5)
-                          .addAggregationResult(SumAggregationResult()
+                          .addResult(SumAggregationResult()
                                   .setExpression(createDummyExpression()))
-                          .addAggregationResult(SumAggregationResult()
+                          .addResult(SumAggregationResult()
                                   .setExpression(createDummyExpression())))
                 .addChild(Group().setId(Int64ResultNode(130))
                           .addChild(Group().setId(Int64ResultNode(131)))));
@@ -293,32 +293,31 @@ TEST_F("testGrouping", Fixture("testGrouping")) {
                 .addLevel(GroupingLevel()
                           .setMaxGroups(100)
                           .setExpression(createDummyExpression())
-                          .addAggregationResult(SumAggregationResult()
+                          .addResult(SumAggregationResult()
                                   .setExpression(createDummyExpression())))
                 .addLevel(GroupingLevel()
                           .setMaxGroups(10)
                           .setExpression(createDummyExpression())
-                          .addAggregationResult(SumAggregationResult()
+                          .addResult(SumAggregationResult()
                                   .setExpression(createDummyExpression()))
-                          .addAggregationResult(SumAggregationResult()
+                          .addResult(SumAggregationResult()
                                   .setExpression(createDummyExpression()))));
     f.checkObject(Grouping()
                 .addLevel(GroupingLevel()
-                          .setExpression(AttributeNode("folder"))
-                          .addAggregationResult(XorAggregationResult()
-                                  .setExpression(MD5BitFunctionNode(
-                                                  AttributeNode("docid"), 64)))
-                          .addAggregationResult(SumAggregationResult()
-                                  .setExpression(MinFunctionNode()
-                                          .addArg(AttributeNode("attribute1"))
-                                          .addArg(AttributeNode("attribute2")))
+                          .setExpression(MU<AttributeNode>("folder"))
+                          .addResult(XorAggregationResult()
+                                  .setExpression(MU<MD5BitFunctionNode>(MU<AttributeNode>("docid"), 64)))
+                          .addResult(SumAggregationResult()
+                                  .setExpression(ExpressionNode::UP(MinFunctionNode()
+                                          .addArg(MU<AttributeNode>("attribute1"))
+                                          .addArg(MU<AttributeNode>("attribute2")).clone()))
                                      )
-                          .addAggregationResult(XorAggregationResult()
+                          .addResult(XorAggregationResult()
                                   .setExpression(
-                                          XorBitFunctionNode(CatFunctionNode()
-                                                  .addArg(GetDocIdNamespaceSpecificFunctionNode())
-                                                  .addArg(DocumentFieldNode("folder"))
-                                                  .addArg(DocumentFieldNode("flags")), 64)))));
+                                          ExpressionNode::UP(XorBitFunctionNode(ExpressionNode::UP(CatFunctionNode()
+                                                  .addArg(MU<GetDocIdNamespaceSpecificFunctionNode>())
+                                                  .addArg(MU<DocumentFieldNode>("folder"))
+                                                  .addArg(MU<DocumentFieldNode>("flags")).clone()), 64).clone())))));
 }
 
 }  // namespace
diff --git a/searchlib/src/tests/grouping/grouping_test.cpp b/searchlib/src/tests/grouping/grouping_test.cpp
index 10fa3267c09..5e165954eba 100644
--- a/searchlib/src/tests/grouping/grouping_test.cpp
+++ b/searchlib/src/tests/grouping/grouping_test.cpp
@@ -1,7 +1,5 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#include <vespa/fastos/fastos.h>
-#include <vespa/log/log.h>
-LOG_SETUP("grouping_test");
+
 #include <vespa/vespalib/testkit/testapp.h>
 #include <vespa/searchlib/aggregation/perdocexpression.h>
 #include <vespa/searchlib/aggregation/aggregation.h>
@@ -39,7 +37,7 @@ public:
         for (uint32_t docid = 0; docid < numDocs; ++docid) {
             T val;
             uint32_t res = rhs._attr->get(docid, &val, 1);
-            LOG_ASSERT(res == 1);
+            assert(res == 1);
             add(val);
         }
     }
@@ -295,20 +293,34 @@ Test::testAggregationSimple()
     testAggregationSimpleSum(ctx, MaxAggregationResult(), Int64ResultNode(15), FloatResultNode(15), StringResultNode("7"));
 }
 
+#define MU std::make_unique
+using EUP = ExpressionNode::UP;
+
+std::unique_ptr<AggregationResult>
+prepareAggr(const AggregationResult & aggr, ExpressionNode::UP expr) {
+    std::unique_ptr<AggregationResult> clone(aggr.clone());
+    clone->setExpression(std::move(expr));
+    return clone;
+}
+
+ExpressionNode::UP
+prepareAggr(const AggregationResult & aggr, ExpressionNode::UP expr, const ResultNode & r) {
+    auto prepared = prepareAggr(aggr, std::move(expr));
+    prepared->setResult(r);
+    return prepared;
+}
 void Test::testAggregationSimpleSum(AggregationContext & ctx, const AggregationResult & aggr, const ResultNode & ir, const ResultNode & fr, const ResultNode & sr)
 {
     ExpressionNode::CP clone(aggr);
-    Grouping request = Grouping()
-                       .setRoot(Group()
-                                       .addResult(static_cast<AggregationResult &>(*clone).setExpression(AttributeNode("int")))
-                                       .addResult(static_cast<AggregationResult &>(*clone).setExpression(AttributeNode("float")))
-                                       .addResult(static_cast<AggregationResult &>(*clone).setExpression(AttributeNode("string")))
-                               );
+    Grouping request;
+    request.setRoot(Group().addResult(prepareAggr(aggr, MU<AttributeNode>("int")))
+                           .addResult(prepareAggr(aggr, MU<AttributeNode>("float")))
+                           .addResult(prepareAggr(aggr, MU<AttributeNode>("string"))));
 
-    Group expect = Group()
-                   .addResult(static_cast<AggregationResult &>(*clone).setExpression(AttributeNode("int")).setResult(ir))
-                   .addResult(static_cast<AggregationResult &>(*clone).setExpression(AttributeNode("float")).setResult(fr))
-                   .addResult(static_cast<AggregationResult &>(*clone).setExpression(AttributeNode("string")).setResult(sr));
+    Group expect;
+    expect.addResult(prepareAggr(aggr, MU<AttributeNode>("int"), ir))
+          .addResult(prepareAggr(aggr, MU<AttributeNode>("float"), fr))
+          .addResult(prepareAggr(aggr, MU<AttributeNode>("string"), sr));
 
     EXPECT_TRUE(testAggregation(ctx, request, expect));
 }
@@ -328,91 +340,73 @@ Test::testAggregationLevels()
     ctx.add(IntAttrBuilder("attr3").add(13).add(13).sp());
     ctx.result().add(0).add(1);
 
-    Grouping baseRequest = Grouping()
-                           .setRoot(Group()
-                                    .addResult(SumAggregationResult()
-                                            .setExpression(AttributeNode("attr0"))))
-                           .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("attr1"))
-                                     .addResult(SumAggregationResult()
-                                             .setExpression(AttributeNode("attr2"))))
-                           .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("attr2"))
-                                     .addResult(SumAggregationResult()
-                                             .setExpression(AttributeNode("attr3"))))
-                           .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("attr3"))
-                                     .addResult(SumAggregationResult()
-                                             .setExpression(AttributeNode("attr1"))));
-
-    Group notDone = Group()
-                    .addResult(SumAggregationResult()
-                               .setExpression(AttributeNode("attr0")));
+    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"))));
+
+    Group notDone;
+    notDone.addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr0")));
 // Hmm, do not need to prepare more than the levels needed.    .setResult(Int64ResultNode(0)));
 
-    Group done0 = Group()
-                  .addResult(SumAggregationResult()
-                             .setExpression(AttributeNode("attr0"))
-                             .setResult(Int64ResultNode(20)))
-                  .addChild(Group()
-                            .setId(Int64ResultNode(11))
-                            .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("attr2"))
+    Group done0;
+    done0.addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr0")).setResult(Int64ResultNode(20)))
+         .addChild(Group().setId(Int64ResultNode(11)).addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr2"))
                                        .setResult(Int64ResultNode(0))));
 
-    Group done1 = Group()
-                  .addResult(SumAggregationResult()
-                             .setExpression(AttributeNode("attr0"))
-                             .setResult(Int64ResultNode(20)))
-                  .addChild(Group()
-                            .setId(Int64ResultNode(11))
-                            .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("attr2"))
-                                       .setResult(Int64ResultNode(24)))
-                            .addChild(Group()
-                                      .setId(Int64ResultNode(12))
-                                      .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("attr3"))
-                                              .setResult(Int64ResultNode(0)))));
-
-    Group done2 = Group()
-                  .addResult(SumAggregationResult()
-                             .setExpression(AttributeNode("attr0"))
-                             .setResult(Int64ResultNode(20)))
-                  .addChild(Group()
-                            .setId(Int64ResultNode(11))
-                            .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("attr2"))
-                                       .setResult(Int64ResultNode(24)))
-                            .addChild(Group()
-                                      .setId(Int64ResultNode(12))
-                                      .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("attr3"))
-                                              .setResult(Int64ResultNode(26)))
-                                      .addChild(Group()
-                                              .setId(Int64ResultNode(13))
-                                              .addResult(SumAggregationResult()
-                                                      .setExpression(AttributeNode("attr1"))
-                                                      .setResult(Int64ResultNode(0))))));
-
-    Group done3 = Group()
-                  .addResult(SumAggregationResult()
-                             .setExpression(AttributeNode("attr0"))
-                             .setResult(Int64ResultNode(20)))
+    Group done1;
+    done1.addResult(SumAggregationResult()
+                            .setExpression(MU<AttributeNode>("attr0"))
+                            .setResult(Int64ResultNode(20)))
+         .addChild(Group().setId(Int64ResultNode(11))
+                          .addResult(SumAggregationResult()
+                                             .setExpression(MU<AttributeNode>("attr2"))
+                                             .setResult(Int64ResultNode(24)))
+                          .addChild(Group().setId(Int64ResultNode(12))
+                                           .addResult(SumAggregationResult()
+                                                              .setExpression(MU<AttributeNode>("attr3"))
+                                                              .setResult(Int64ResultNode(0)))));
+
+    Group done2;
+    done2.addResult(SumAggregationResult()
+                            .setExpression(MU<AttributeNode>("attr0"))
+                            .setResult(Int64ResultNode(20)))
+         .addChild(Group().setId(Int64ResultNode(11))
+                          .addResult(SumAggregationResult()
+                                             .setExpression(MU<AttributeNode>("attr2"))
+                                             .setResult(Int64ResultNode(24)))
+                          .addChild(Group().setId(Int64ResultNode(12))
+                                           .addResult(SumAggregationResult()
+                                                              .setExpression(MU<AttributeNode>("attr3"))
+                                                              .setResult(Int64ResultNode(26)))
+                                           .addChild(Group().setId(Int64ResultNode(13))
+                                                            .addResult(SumAggregationResult()
+                                                                               .setExpression(MU<AttributeNode>("attr1"))
+                                                                               .setResult(Int64ResultNode(0))))));
+
+    Group done3;
+    done3.addResult(SumAggregationResult()
+                            .setExpression(MU<AttributeNode>("attr0"))
+                            .setResult(Int64ResultNode(20)))
                   .addChild(Group()
                             .setId(Int64ResultNode(11))
                             .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("attr2"))
+                                       .setExpression(MU<AttributeNode>("attr2"))
                                        .setResult(Int64ResultNode(24)))
                             .addChild(Group()
                                       .setId(Int64ResultNode(12))
                                       .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("attr3"))
+                                              .setExpression(MU<AttributeNode>("attr3"))
                                               .setResult(Int64ResultNode(26)))
                                       .addChild(Group()
                                               .setId(Int64ResultNode(13))
                                               .addResult(SumAggregationResult()
-                                                      .setExpression(AttributeNode("attr1"))
+                                                      .setExpression(MU<AttributeNode>("attr1"))
                                                       .setResult(Int64ResultNode(22))))));
 
     { // level 0 only
@@ -466,7 +460,7 @@ Test::testAggregationMaxGroups()
 
     Grouping baseRequest = Grouping()
                            .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("attr")));
+                                     .setExpression(MU<AttributeNode>("attr")));
 
     Group empty = Group();
     Group grp1 = empty.unchain().addChild(Group().setId(Int64ResultNode(5)));
@@ -515,18 +509,17 @@ Test::testAggregationGroupOrder()
     ctx.add(IntAttrBuilder("attr").add(10).add(25).add(35).add(5).add(20).add(15).add(30).sp());
     ctx.result().add(0).add(1).add(2).add(3).add(4).add(5).add(6);
 
-    Grouping request = Grouping()
-                       .addLevel(GroupingLevel()
-                                 .setExpression(AttributeNode("attr")));
+    Grouping request;
+    request.addLevel(GroupingLevel().setExpression(MU<AttributeNode>("attr")));
 
-    Group expect = Group()
-                   .addChild(Group().setId(Int64ResultNode(5)))
-                   .addChild(Group().setId(Int64ResultNode(10)))
-                   .addChild(Group().setId(Int64ResultNode(15)))
-                   .addChild(Group().setId(Int64ResultNode(20)))
-                   .addChild(Group().setId(Int64ResultNode(25)))
-                   .addChild(Group().setId(Int64ResultNode(30)))
-                   .addChild(Group().setId(Int64ResultNode(35)));
+    Group expect;
+    expect.addChild(Group().setId(Int64ResultNode(5)))
+          .addChild(Group().setId(Int64ResultNode(10)))
+          .addChild(Group().setId(Int64ResultNode(15)))
+          .addChild(Group().setId(Int64ResultNode(20)))
+          .addChild(Group().setId(Int64ResultNode(25)))
+          .addChild(Group().setId(Int64ResultNode(30)))
+          .addChild(Group().setId(Int64ResultNode(35)));
 
     EXPECT_TRUE(testAggregation(ctx, request, expect));
 }
@@ -548,7 +541,7 @@ Test::testAggregationGroupRank()
         .add(6, 15).add(7, 5).add(8, 10);
 
     Grouping request = Grouping().addLevel(
-                           GroupingLevel().setExpression(AttributeNode("attr")));
+                           GroupingLevel().setExpression(MU<AttributeNode>("attr")));
 
     Group expect = Group()
                    .addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(15)))
@@ -572,81 +565,80 @@ Test::testAggregationGroupCapping()
         .add(6, 7).add(7, 8).add(8, 9);
 
     {
-        Grouping request = Grouping().addLevel(
-                               GroupingLevel().setExpression(AttributeNode("attr")));
-
-        Group expect = Group()
-                       .addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(1)))
-                       .addChild(Group().setId(Int64ResultNode(2)).setRank(RawRank(2)))
-                       .addChild(Group().setId(Int64ResultNode(3)).setRank(RawRank(3)))
-                       .addChild(Group().setId(Int64ResultNode(4)).setRank(RawRank(4)))
-                       .addChild(Group().setId(Int64ResultNode(5)).setRank(RawRank(5)))
-                       .addChild(Group().setId(Int64ResultNode(6)).setRank(RawRank(6)))
-                       .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7)))
-                       .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8)))
-                       .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9)));
+        Grouping request = Grouping().addLevel(GroupingLevel().setExpression(MU<AttributeNode>("attr")));
+
+        Group expect;
+        expect.addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(1)))
+              .addChild(Group().setId(Int64ResultNode(2)).setRank(RawRank(2)))
+              .addChild(Group().setId(Int64ResultNode(3)).setRank(RawRank(3)))
+              .addChild(Group().setId(Int64ResultNode(4)).setRank(RawRank(4)))
+              .addChild(Group().setId(Int64ResultNode(5)).setRank(RawRank(5)))
+              .addChild(Group().setId(Int64ResultNode(6)).setRank(RawRank(6)))
+              .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7)))
+              .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8)))
+              .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9)));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
     {
-        Grouping request = Grouping().addLevel(
-                               GroupingLevel().setMaxGroups(3).setExpression(AttributeNode("attr")));
+        Grouping request;
+        request.addLevel(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr")));
 
-        Group expect = Group()
-                       .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7)))
-                       .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8)))
-                       .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9)));
+        Group expect;
+        expect.addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7)))
+              .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8)))
+              .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9)));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
     {
-        Grouping request = Grouping().
-                               setFirstLevel(0).
-                               setLastLevel(1).
-                               addLevel(
-                                   GroupingLevel().setMaxGroups(3).setExpression(AttributeNode("attr")).
-                                       addAggregationResult(SumAggregationResult().setExpression(AttributeNode("attr"))).
-                                       addOrderBy(AggregationRefNode(0), false));
-
-        Group expect = Group()
-                       .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7)).addAggregationResult(SumAggregationResult(Int64ResultNode(7)).setExpression(AttributeNode("attr"))).addOrderBy(AggregationRefNode(0), false))
-                       .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8)).addAggregationResult(SumAggregationResult(Int64ResultNode(8)).setExpression(AttributeNode("attr"))).addOrderBy(AggregationRefNode(0), false))
-                       .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9)).addAggregationResult(SumAggregationResult(Int64ResultNode(9)).setExpression(AttributeNode("attr"))).addOrderBy(AggregationRefNode(0), false));
+        Grouping request;
+        request.setFirstLevel(0)
+                .setLastLevel(1)
+                .addLevel(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr"))
+                                  .addResult(SumAggregationResult().setExpression(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_TRUE(testAggregation(ctx, request, expect));
     }
     {
-        Grouping request = Grouping().
-                               setFirstLevel(0).
-                               setLastLevel(1).
-                               addLevel(
-                                   GroupingLevel().setMaxGroups(3).setExpression(AttributeNode("attr")).
-                                       addAggregationResult(SumAggregationResult().setExpression(AttributeNode("attr"))).addOrderBy(AggregationRefNode(0), true));
+        Grouping request;
+        request.setFirstLevel(0)
+                .setLastLevel(1)
+                .addLevel(GroupingLevel()
+                                  .setMaxGroups(3)
+                                  .setExpression(MU<AttributeNode>("attr"))
+                                  .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr")))
+                                  .addOrderBy(MU<AggregationRefNode>(0), true));
 
         Group expect = Group()
-                       .addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(1)).addAggregationResult(SumAggregationResult(Int64ResultNode(1)).setExpression(AttributeNode("attr"))).addOrderBy(AggregationRefNode(0), true))
-                       .addChild(Group().setId(Int64ResultNode(2)).setRank(RawRank(2)).addAggregationResult(SumAggregationResult(Int64ResultNode(2)).setExpression(AttributeNode("attr"))).addOrderBy(AggregationRefNode(0), true))
-                       .addChild(Group().setId(Int64ResultNode(3)).setRank(RawRank(3)).addAggregationResult(SumAggregationResult(Int64ResultNode(3)).setExpression(AttributeNode("attr"))).addOrderBy(AggregationRefNode(0), true));
+                       .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));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
     {
         AddFunctionNode *add = new AddFunctionNode();
-        add->addArg(AggregationRefNode(0));
-        add->appendArg(ConstantNode(Int64ResultNode(3)));
-        ExpressionNode::CP i1(add);
-        Grouping request = Grouping().
-                               setFirstLevel(0).
-                               setLastLevel(1).
-                               addLevel(
-                                   GroupingLevel().setMaxGroups(3).setExpression(AttributeNode("attr")).
-                                       addAggregationResult(SumAggregationResult().setExpression(AttributeNode("attr"))).
-                                       addOrderBy(i1, false));
+        add->addArg(MU<AggregationRefNode>(0));
+        add->appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3)));
 
-        Group expect = Group()
-                       .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7)).addAggregationResult(SumAggregationResult(Int64ResultNode(7)).setExpression(AttributeNode("attr"))).addOrderBy(AddFunctionNode().appendArg(AggregationRefNode(0)).appendArg(ConstantNode(Int64ResultNode(3))).setResult(Int64ResultNode(10)), false))
-                       .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8)).addAggregationResult(SumAggregationResult(Int64ResultNode(8)).setExpression(AttributeNode("attr"))).addOrderBy(AddFunctionNode().appendArg(AggregationRefNode(0)).appendArg(ConstantNode(Int64ResultNode(3))).setResult(Int64ResultNode(11)), false))
-                       .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9)).addAggregationResult(SumAggregationResult(Int64ResultNode(9)).setExpression(AttributeNode("attr"))).addOrderBy(AddFunctionNode().appendArg(AggregationRefNode(0)).appendArg(ConstantNode(Int64ResultNode(3))).setResult(Int64ResultNode(12)), false));
+        Grouping request;
+        request.setFirstLevel(0)
+                .setLastLevel(1)
+                .addLevel(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr"))
+                                  .addResult(SumAggregationResult().setExpression(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_TRUE(testAggregation(ctx, request, expect));
     }
@@ -667,20 +659,20 @@ Test::testMergeSimpleSum()
                   .setRoot(Group()
                            .setId(NullResultNode())
                            .addResult(SumAggregationResult()
-                                      .setExpression(AttributeNode("foo"))
+                                      .setExpression(MU<AttributeNode>("foo"))
                                       .setResult(Int64ResultNode(20))));
 
     Grouping b  = Grouping()
                   .setRoot(Group()
                            .setId(NullResultNode())
                            .addResult(SumAggregationResult()
-                                      .setExpression(AttributeNode("foo"))
+                                      .setExpression(MU<AttributeNode>("foo"))
                                       .setResult(Int64ResultNode(30))));
 
     Group expect = Group()
                    .setId(NullResultNode())
                    .addResult(SumAggregationResult()
-                              .setExpression(AttributeNode("foo"))
+                              .setExpression(MU<AttributeNode>("foo"))
                               .setResult(Int64ResultNode(50)));
 
     EXPECT_TRUE(testMerge(a, b, expect));
@@ -694,166 +686,166 @@ Test::testMergeLevels()
 {
     Grouping request = Grouping()
                        .addLevel(GroupingLevel()
-                                 .setExpression(AttributeNode("c1"))
+                                 .setExpression(MU<AttributeNode>("c1"))
                                  .addResult(SumAggregationResult()
-                                         .setExpression(AttributeNode("s1"))))
+                                         .setExpression(MU<AttributeNode>("s1"))))
                        .addLevel(GroupingLevel()
-                                 .setExpression(AttributeNode("c2"))
+                                 .setExpression(MU<AttributeNode>("c2"))
                                  .addResult(SumAggregationResult()
-                                         .setExpression(AttributeNode("s2"))))
+                                         .setExpression(MU<AttributeNode>("s2"))))
                        .addLevel(GroupingLevel()
-                                 .setExpression(AttributeNode("c3"))
+                                 .setExpression(MU<AttributeNode>("c3"))
                                  .addResult(SumAggregationResult()
-                                         .setExpression(AttributeNode("s3"))));
+                                         .setExpression(MU<AttributeNode>("s3"))));
 
     Group a = Group()
               .setId(NullResultNode())
               .addResult(SumAggregationResult()
-                         .setExpression(AttributeNode("s0"))
+                         .setExpression(MU<AttributeNode>("s0"))
                          .setResult(Int64ResultNode(5)))
               .addChild(Group()
                         .setId(Int64ResultNode(10))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(10)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(20))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(15)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(30))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(20))))));
 
     Group b = Group()
               .setId(NullResultNode())
               .addResult(SumAggregationResult()
-                         .setExpression(AttributeNode("s0"))
+                         .setExpression(MU<AttributeNode>("s0"))
                          .setResult(Int64ResultNode(5)))
               .addChild(Group()
                         .setId(Int64ResultNode(10))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(10)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(20))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(15)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(30))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(20))))));
 
     Group expect_all = Group()
                        .setId(NullResultNode())
                        .addResult(SumAggregationResult()
-                                  .setExpression(AttributeNode("s0"))
+                                  .setExpression(MU<AttributeNode>("s0"))
                                   .setResult(Int64ResultNode(10)))
                        .addChild(Group()
                                  .setId(Int64ResultNode(10))
                                  .addResult(SumAggregationResult()
-                                         .setExpression(AttributeNode("s1"))
+                                         .setExpression(MU<AttributeNode>("s1"))
                                          .setResult(Int64ResultNode(20)))
                                  .addChild(Group()
                                          .setId(Int64ResultNode(20))
                                          .addResult(SumAggregationResult()
-                                                 .setExpression(AttributeNode("s2"))
+                                                 .setExpression(MU<AttributeNode>("s2"))
                                                  .setResult(Int64ResultNode(30)))
                                          .addChild(Group()
                                                  .setId(Int64ResultNode(30))
                                                  .addResult(SumAggregationResult()
-                                                         .setExpression(AttributeNode("s3"))
+                                                         .setExpression(MU<AttributeNode>("s3"))
                                                          .setResult(Int64ResultNode(40))))));
 
     Group expect_0 = Group()
                      .setId(NullResultNode())
                      .addResult(SumAggregationResult()
-                                .setExpression(AttributeNode("s0"))
+                                .setExpression(MU<AttributeNode>("s0"))
                                 .setResult(Int64ResultNode(5)))
                      .addChild(Group()
                                .setId(Int64ResultNode(10))
                                .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(20)))
                                .addChild(Group()
                                        .setId(Int64ResultNode(20))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(30)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(30))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(40))))));
 
 
     Group expect_1 = Group()
                      .setId(NullResultNode())
                      .addResult(SumAggregationResult()
-                                .setExpression(AttributeNode("s0"))
+                                .setExpression(MU<AttributeNode>("s0"))
                                 .setResult(Int64ResultNode(5)))
                      .addChild(Group()
                                .setId(Int64ResultNode(10))
                                .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(10)))
                                .addChild(Group()
                                        .setId(Int64ResultNode(20))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(30)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(30))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(40))))));
 
 
     Group expect_2 = Group()
                      .setId(NullResultNode())
                      .addResult(SumAggregationResult()
-                                .setExpression(AttributeNode("s0"))
+                                .setExpression(MU<AttributeNode>("s0"))
                                 .setResult(Int64ResultNode(5)))
                      .addChild(Group()
                                .setId(Int64ResultNode(10))
                                .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(10)))
                                .addChild(Group()
                                        .setId(Int64ResultNode(20))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(15)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(30))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(40))))));
 
 
     Group expect_3 = Group()
                      .setId(NullResultNode())
                      .addResult(SumAggregationResult()
-                                .setExpression(AttributeNode("s0"))
+                                .setExpression(MU<AttributeNode>("s0"))
                                 .setResult(Int64ResultNode(5)))
                      .addChild(Group()
                                .setId(Int64ResultNode(10))
                                .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(10)))
                                .addChild(Group()
                                        .setId(Int64ResultNode(20))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(15)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(30))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(20))))));
 
     EXPECT_TRUE(testMerge(request.unchain().setFirstLevel(0).setLastLevel(3).setRoot(a),
@@ -883,7 +875,7 @@ Test::testMergeGroups()
 {
     Grouping request = Grouping()
                        .addLevel(GroupingLevel()
-                                 .setExpression(AttributeNode("attr")));
+                                 .setExpression(MU<AttributeNode>("attr")));
 
     Group a = Group()
               .setId(NullResultNode())
@@ -947,45 +939,45 @@ Test::testMergeTrees()
     Grouping request = Grouping()
                        .addLevel(GroupingLevel()
                                  .setMaxGroups(3)
-                                 .setExpression(AttributeNode("c1"))
+                                 .setExpression(MU<AttributeNode>("c1"))
                                  .addResult(SumAggregationResult()
-                                         .setExpression(AttributeNode("s1"))))
+                                         .setExpression(MU<AttributeNode>("s1"))))
                        .addLevel(GroupingLevel()
                                  .setMaxGroups(2)
-                                 .setExpression(AttributeNode("c2"))
+                                 .setExpression(MU<AttributeNode>("c2"))
                                  .addResult(SumAggregationResult()
-                                         .setExpression(AttributeNode("s2"))))
+                                         .setExpression(MU<AttributeNode>("s2"))))
                        .addLevel(GroupingLevel()
                                  .setMaxGroups(1)
-                                 .setExpression(AttributeNode("c3"))
+                                 .setExpression(MU<AttributeNode>("c3"))
                                  .addResult(SumAggregationResult()
-                                         .setExpression(AttributeNode("s3"))));
+                                         .setExpression(MU<AttributeNode>("s3"))));
 
     Group a = Group()
               .setId(NullResultNode())
               .addResult(SumAggregationResult()
-                         .setExpression(AttributeNode("s0"))
+                         .setExpression(MU<AttributeNode>("s0"))
                          .setResult(Int64ResultNode(100)))
               .addChild(Group().setId(Int64ResultNode(4)).setRank(RawRank(10)))
               .addChild(Group()
                         .setId(Int64ResultNode(5))
                         .setRank(RawRank(5)) // merged with 200 rank node
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(100)))
                         .addChild(Group().setId(Int64ResultNode(4)).setRank(RawRank(10)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(5))
                                   .setRank(RawRank(500))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   .addChild(Group().setId(Int64ResultNode(4)).setRank(RawRank(10)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(5))
                                           .setRank(RawRank(200))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(100)))
                                             )
                                   )
@@ -995,21 +987,21 @@ Test::testMergeTrees()
                         .setId(Int64ResultNode(10))
                         .setRank(RawRank(100))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(100)))
                         // dummy child would be picked up here
                         .addChild(Group()
                                   .setId(Int64ResultNode(15))
                                   .setRank(RawRank(200))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   .addChild(Group().setId(Int64ResultNode(14)).setRank(RawRank(10)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(15))
                                           .setRank(RawRank(300))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(100)))
                                             )
                                   )
@@ -1019,14 +1011,14 @@ Test::testMergeTrees()
                         .setId(Int64ResultNode(15))
                         .setRank(RawRank(300))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(100)))
                         .addChild(Group().setId(Int64ResultNode(19)).setRank(RawRank(10)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(20))
                                   .setRank(RawRank(100))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   )
                         );
@@ -1034,28 +1026,28 @@ Test::testMergeTrees()
     Group b = Group()
               .setId(NullResultNode())
               .addResult(SumAggregationResult()
-                         .setExpression(AttributeNode("s0"))
+                         .setExpression(MU<AttributeNode>("s0"))
                          .setResult(Int64ResultNode(100)))
               .addChild(Group().setId(Int64ResultNode(4)).setRank(RawRank(10)))
               .addChild(Group()
                         .setId(Int64ResultNode(5))
                         .setRank(RawRank(200))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(100)))
                         .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(10)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(10))
                                   .setRank(RawRank(400))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(10)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(10))
                                           .setRank(RawRank(100))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(100)))
                                             )
                                   )
@@ -1065,14 +1057,14 @@ Test::testMergeTrees()
                         .setId(Int64ResultNode(10))
                         .setRank(RawRank(100))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(100)))
                         // dummy child would be picket up here
                         .addChild(Group()
                                   .setId(Int64ResultNode(15))
                                   .setRank(RawRank(200))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   )
                         )
@@ -1081,21 +1073,21 @@ Test::testMergeTrees()
                         .setId(Int64ResultNode(15))
                         .setRank(RawRank(5)) // merged with 300 rank node
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(100)))
                         .addChild(Group().setId(Int64ResultNode(19)).setRank(RawRank(10)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(20))
                                   .setRank(RawRank(5)) // merged with 100 rank node
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   .addChild(Group().setId(Int64ResultNode(19)).setRank(RawRank(10)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(20))
                                           .setRank(RawRank(500))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(100)))
                                             )
                                   )
@@ -1104,14 +1096,14 @@ Test::testMergeTrees()
                                   .setId(Int64ResultNode(25))
                                   .setRank(RawRank(300))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   .addChild(Group().setId(Int64ResultNode(24)).setRank(RawRank(10)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(25))
                                           .setRank(RawRank(400))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(100)))
                                             )
                                   )
@@ -1120,25 +1112,25 @@ Test::testMergeTrees()
     Group expect = Group()
                    .setId(NullResultNode())
                    .addResult(SumAggregationResult()
-                              .setExpression(AttributeNode("s0"))
+                              .setExpression(MU<AttributeNode>("s0"))
                               .setResult(Int64ResultNode(200)))
                    .addChild(Group()
                              .setId(Int64ResultNode(5))
                              .setRank(RawRank(200))
                              .addResult(SumAggregationResult()
-                                        .setExpression(AttributeNode("s1"))
+                                        .setExpression(MU<AttributeNode>("s1"))
                                         .setResult(Int64ResultNode(200)))
                              .addChild(Group()
                                        .setId(Int64ResultNode(5))
                                        .setRank(RawRank(500))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(100)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(5))
                                                .setRank(RawRank(200))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(100)))
                                                  )
                                        )
@@ -1146,13 +1138,13 @@ Test::testMergeTrees()
                                        .setId(Int64ResultNode(10))
                                        .setRank(RawRank(400))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(100)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(10))
                                                .setRank(RawRank(100))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(100)))
                                                  )
                                        )
@@ -1161,19 +1153,19 @@ Test::testMergeTrees()
                              .setId(Int64ResultNode(10))
                              .setRank(RawRank(100))
                              .addResult(SumAggregationResult()
-                                        .setExpression(AttributeNode("s1"))
+                                        .setExpression(MU<AttributeNode>("s1"))
                                         .setResult(Int64ResultNode(200)))
                              .addChild(Group()
                                        .setId(Int64ResultNode(15))
                                        .setRank(RawRank(200))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(200)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(15))
                                                .setRank(RawRank(300))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(100)))
                                                  )
                                        )
@@ -1182,19 +1174,19 @@ Test::testMergeTrees()
                              .setId(Int64ResultNode(15))
                              .setRank(RawRank(300))
                              .addResult(SumAggregationResult()
-                                        .setExpression(AttributeNode("s1"))
+                                        .setExpression(MU<AttributeNode>("s1"))
                                         .setResult(Int64ResultNode(200)))
                              .addChild(Group()
                                        .setId(Int64ResultNode(20))
                                        .setRank(RawRank(100))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(200)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(20))
                                                .setRank(RawRank(500))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(100)))
                                                  )
                                        )
@@ -1202,13 +1194,13 @@ Test::testMergeTrees()
                                        .setId(Int64ResultNode(25))
                                        .setRank(RawRank(300))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(100)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(25))
                                                .setRank(RawRank(400))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(100)))
                                                  )
                                        )
@@ -1363,37 +1355,37 @@ Test::testPartialMerging()
 {
     Grouping baseRequest = Grouping()
                            .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("c1"))
+                                     .setExpression(MU<AttributeNode>("c1"))
                                      .addResult(SumAggregationResult()
-                                                .setExpression(AttributeNode("s1"))))
+                                                .setExpression(MU<AttributeNode>("s1"))))
                            .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("c2"))
+                                     .setExpression(MU<AttributeNode>("c2"))
                                      .addResult(SumAggregationResult()
-                                                .setExpression(AttributeNode("s2"))))
+                                                .setExpression(MU<AttributeNode>("s2"))))
                            .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("c3"))
+                                     .setExpression(MU<AttributeNode>("c3"))
                                      .addResult(SumAggregationResult()
-                                                .setExpression(AttributeNode("s3"))));
+                                                .setExpression(MU<AttributeNode>("s3"))));
 
     // Cached result
     Group cached = Group()
               .addResult(SumAggregationResult()
-                         .setExpression(AttributeNode("s0"))
+                         .setExpression(MU<AttributeNode>("s0"))
                          .setResult(Int64ResultNode(110)))
               .addChild(Group()
                         .setId(Int64ResultNode(5))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(10)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(13))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(14))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(100)))
                                             )
                                   )
@@ -1401,17 +1393,17 @@ Test::testPartialMerging()
               .addChild(Group()
                         .setId(Int64ResultNode(10))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(100)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(15))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(22))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(100)))
                                             )
                                   )
@@ -1422,23 +1414,23 @@ Test::testPartialMerging()
         Grouping request = baseRequest.unchain().setFirstLevel(0).setLastLevel(0);
         Group incoming = Group()
                          .addResult(SumAggregationResult()
-                                    .setExpression(AttributeNode("s0"))
+                                    .setExpression(MU<AttributeNode>("s0"))
                                     .setResult(Int64ResultNode(0)));
 
         Group expected = Group()
                          .addResult(SumAggregationResult()
-                                    .setExpression(AttributeNode("s0"))
+                                    .setExpression(MU<AttributeNode>("s0"))
                                     .setResult(Int64ResultNode(110)))
                          .addChild(Group()
                                    .setId(Int64ResultNode(5))
                                    .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s1"))
+                                              .setExpression(MU<AttributeNode>("s1"))
                                               .setResult(Int64ResultNode(0)))
                                    )
                          .addChild(Group()
                                    .setId(Int64ResultNode(10))
                                    .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s1"))
+                                              .setExpression(MU<AttributeNode>("s1"))
                                               .setResult(Int64ResultNode(0)))
                                   );
         EXPECT_TRUE(testPartialMerge(request.unchain().setRoot(incoming), request.unchain().setLastLevel(3).setRoot(cached), expected));
@@ -1448,81 +1440,81 @@ Test::testPartialMerging()
         Grouping request = baseRequest.unchain().setFirstLevel(1).setLastLevel(1);
         Group incoming = Group()
                          .addResult(SumAggregationResult()
-                                    .setExpression(AttributeNode("s0"))
+                                    .setExpression(MU<AttributeNode>("s0"))
                                     .setResult(Int64ResultNode(200)))
                          .addChild(Group()
                                    .setId(Int64ResultNode(3))
                                    .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s1"))
+                                              .setExpression(MU<AttributeNode>("s1"))
                                               .setResult(Int64ResultNode(0)))
                                    )
                          .addChild(Group()
                                    .setId(Int64ResultNode(5))
                                    .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s1"))
+                                              .setExpression(MU<AttributeNode>("s1"))
                                               .setResult(Int64ResultNode(0)))
                                    )
                          .addChild(Group()
                                    .setId(Int64ResultNode(7))
                                    .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s1"))
+                                              .setExpression(MU<AttributeNode>("s1"))
                                               .setResult(Int64ResultNode(0)))
                                    )
                          .addChild(Group()
                                    .setId(Int64ResultNode(10))
                                    .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s1"))
+                                              .setExpression(MU<AttributeNode>("s1"))
                                               .setResult(Int64ResultNode(0))))
                          .addChild(Group()
                                    .setId(Int64ResultNode(33))
                                    .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s1"))
+                                              .setExpression(MU<AttributeNode>("s1"))
                                               .setResult(Int64ResultNode(0)))
                                    );
         Group expected = Group()
                   .addResult(SumAggregationResult()
-                             .setExpression(AttributeNode("s0"))
+                             .setExpression(MU<AttributeNode>("s0"))
                              .setResult(Int64ResultNode(200)))
                   .addChild(Group()
                             .setId(Int64ResultNode(3))
                             .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(0)))
                             )
                   .addChild(Group()
                             .setId(Int64ResultNode(5))
                             .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(10)))
                             .addChild(Group()
                                       .setId(Int64ResultNode(13))
                                       .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s2"))
+                                              .setExpression(MU<AttributeNode>("s2"))
                                               .setResult(Int64ResultNode(0)))
                                       )
                             )
                   .addChild(Group()
                             .setId(Int64ResultNode(7))
                             .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(0)))
                             )
                   .addChild(Group()
                             .setId(Int64ResultNode(10))
                             .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(100)))
                             .addChild(Group()
                                       .setId(Int64ResultNode(15))
                                       .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s2"))
+                                              .setExpression(MU<AttributeNode>("s2"))
                                               .setResult(Int64ResultNode(0)))
                                       )
                             )
                   .addChild(Group()
                             .setId(Int64ResultNode(33))
                             .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(0)))
                             );
         EXPECT_TRUE(testPartialMerge(request.unchain().setRoot(incoming), request.unchain().setFirstLevel(0).setLastLevel(3).setRoot(cached), expected));
@@ -1538,7 +1530,7 @@ Test::testPruneSimple()
     {
         Grouping request = Grouping()
                            .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("attr")))
+                                     .setExpression(MU<AttributeNode>("attr")))
                            .setFirstLevel(1)
                            .setLastLevel(1);
 
@@ -1571,30 +1563,25 @@ Test::testTopN()
     Grouping request = Grouping()
                        .setRoot(Group()
                                 .addResult(CountAggregationResult()
-                                        .setExpression(ConstantNode(Int64ResultNode(0)))
+                                        .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0)))
                                            )
                                 );
     {
-        Group expect = Group()
-                       .addResult(CountAggregationResult().setCount(3)
-                                  .setExpression(ConstantNode(Int64ResultNode(0)))
-                                  );
+        Group expect;
+        expect.addResult(CountAggregationResult().setCount(3).setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
     {
-        Group expect = Group()
-                       .addResult(CountAggregationResult().setCount(1)
-                                  .setExpression(ConstantNode(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()
-                                      .addAggregationResult(SumAggregationResult())
-                                      .addOrderBy(AggregationRefNode(0), false));
+                                      .addResult(MU<SumAggregationResult>())
+                                      .addOrderBy(MU<AggregationRefNode>(0), false));
         EXPECT_TRUE(request2.needResort());
         request2.setTopN(0);
         EXPECT_TRUE(request2.needResort());
@@ -1616,17 +1603,11 @@ Test::testCount()
     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(ConstantNode(Int64ResultNode(0)))
-                                           )
-                                );
+    Grouping request;
+    request.setRoot(Group().addResult(CountAggregationResult().setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0)))));
 
-    Group expect = Group()
-                   .addResult(CountAggregationResult().setCount(3)
-                              .setExpression(ConstantNode(Int64ResultNode(0)))
-                              );
+    Group expect;
+    expect.addResult(CountAggregationResult().setCount(3).setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
     EXPECT_TRUE(testAggregation(ctx, request, expect));
 }
@@ -1653,7 +1634,7 @@ Test::testFS4HitCollection()
                            .setRoot(Group()
                                     .addResult(HitsAggregationResult()
                                             .setMaxHits(3)
-                                            .setExpression(ConstantNode(Int64ResultNode(0))))
+                                            .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))))
                                     );
 
         Group expect = Group()
@@ -1663,7 +1644,7 @@ Test::testFS4HitCollection()
                                   .addHit(FS4Hit(25, 25.0))
                                   .addHit(FS4Hit(20, 20.0))
                                   .sort()
-                                  .setExpression(ConstantNode(Int64ResultNode(0))));
+                                  .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
@@ -1673,7 +1654,7 @@ Test::testFS4HitCollection()
                            .setRoot(Group()
                                     .addResult(HitsAggregationResult()
                                             .setMaxHits(3)
-                                            .setExpression(ConstantNode(Int64ResultNode(0))))
+                                            .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))))
                                     );
 
         Group expect = Group()
@@ -1684,7 +1665,7 @@ Test::testFS4HitCollection()
                                   .addHit(FS4Hit(20, 20.0))
                                   .addHit(FS4Hit(10, 10.0))
                                   .sort()
-                                  .setExpression(ConstantNode(Int64ResultNode(0))));
+                                  .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
         Group a = Group()
                   .setId(NullResultNode())
@@ -1694,7 +1675,7 @@ Test::testFS4HitCollection()
                              .addHit(FS4Hit(1,   5.0))
                              .addHit(FS4Hit(2,   4.0))
                              .sort()
-                             .setExpression(ConstantNode(Int64ResultNode(0))));
+                             .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
         Group b = Group()
                   .setId(NullResultNode())
@@ -1704,7 +1685,7 @@ Test::testFS4HitCollection()
                              .addHit(FS4Hit(3,   7.0))
                              .addHit(FS4Hit(4,   6.0))
                              .sort()
-                             .setExpression(ConstantNode(Int64ResultNode(0))));
+                             .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
         Group c = Group()
                   .setId(NullResultNode())
@@ -1714,7 +1695,7 @@ Test::testFS4HitCollection()
                              .addHit(FS4Hit(5,   9.0))
                              .addHit(FS4Hit(6,   8.0))
                              .sort()
-                             .setExpression(ConstantNode(Int64ResultNode(0))));
+                             .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
         EXPECT_TRUE(testMerge(request.unchain().setRoot(a), request.unchain().setRoot(b), request.unchain().setRoot(c), expect));
         EXPECT_TRUE(testMerge(request.unchain().setRoot(b), request.unchain().setRoot(c), request.unchain().setRoot(a), expect));
@@ -1770,9 +1751,11 @@ Test::checkBucket(const NumericResultNode &width, const NumericResultNode &value
     } else {
         return EXPECT_TRUE(false);
     }
+    std::unique_ptr<FixedWidthBucketFunctionNode> fixed = MU<FixedWidthBucketFunctionNode>(MU<AttributeNode>("attr"));
+    fixed->setWidth(width);
     Grouping request = Grouping()
                        .addLevel(GroupingLevel()
-                                 .setExpression(FixedWidthBucketFunctionNode(AttributeNode("attr")).setWidth(width)));
+                                 .setExpression(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 4b65477224d..3fcec02fb34 100644
--- a/searchlib/src/tests/groupingengine/groupingengine_benchmark.cpp
+++ b/searchlib/src/tests/groupingengine/groupingengine_benchmark.cpp
@@ -1,6 +1,5 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#include <vespa/fastos/fastos.h>
-#include <vespa/log/log.h>
+
 #include <vespa/vespalib/testkit/testapp.h>
 #include <vespa/searchlib/aggregation/perdocexpression.h>
 #include <vespa/searchlib/aggregation/aggregation.h>
@@ -14,6 +13,7 @@
 #include <vespa/vespalib/objects/objectpredicate.h>
 #include <vespa/vespalib/objects/objectoperation.h>
 #include <vespa/vespalib/util/rusage.h>
+#include <vespa/log/log.h>
 LOG_SETUP("grouping_benchmark");
 
 using namespace vespalib;
@@ -41,7 +41,7 @@ public:
         for (uint32_t docid = 0; docid < numDocs; ++docid) {
             T val;
             uint32_t res = rhs._attr->get(docid, &val, 1);
-            LOG_ASSERT(res == 1);
+            assert(res == 1);
             add(val);
         }
     }
@@ -180,6 +180,8 @@ Test::testAggregation(AggregationContext &ctx, const Grouping &request, bool use
     return true;
 }
 
+#define MU std::make_unique
+
 void
 Test::benchmarkIntegerSum(bool useEngine, size_t numDocs, size_t numQueries, int64_t maxGroups)
 {
@@ -193,18 +195,16 @@ Test::benchmarkIntegerSum(bool useEngine, size_t numDocs, size_t numQueries, int
     }
     ctx.add(attrB.sp());
     GroupingLevel level;
-    level.setExpression(AttributeNode("attr0")).setMaxGroups(maxGroups);
-    level.addResult(SumAggregationResult().setExpression(AttributeNode("attr0")));
+    level.setExpression(MU<AttributeNode>("attr0")).setMaxGroups(maxGroups);
+    level.addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr0")));
     if (maxGroups >= 0) {
-        level.addOrderBy(AggregationRefNode(0), false);
+        level.addOrderBy(MU<AggregationRefNode>(0), false);
     }
-    Grouping baseRequest = Grouping()
-                           .setFirstLevel(0)
-                           .setLastLevel(1)
-                           .setRoot(Group()
-                                    .addResult(SumAggregationResult()
-                                            .setExpression(AttributeNode("attr0"))))
-                           .addLevel(level);
+    Grouping baseRequest;
+    baseRequest.setFirstLevel(0)
+               .setLastLevel(1)
+               .setRoot(Group().addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr0"))))
+               .addLevel(level);
 
     for (size_t i(0); i < numQueries; i++) {
         testAggregation(ctx, baseRequest, useEngine);
@@ -224,18 +224,16 @@ Test::benchmarkIntegerCount(bool useEngine, size_t numDocs, size_t numQueries, i
     }
     ctx.add(attrB.sp());
     GroupingLevel level;
-    level.setExpression(AttributeNode("attr0")).setMaxGroups(maxGroups);
-    level.addResult(CountAggregationResult().setExpression(AttributeNode("attr0")));
+    level.setExpression(MU<AttributeNode>("attr0")).setMaxGroups(maxGroups);
+    level.addResult(CountAggregationResult().setExpression(MU<AttributeNode>("attr0")));
     if (maxGroups >= 0) {
-        level.addOrderBy(AggregationRefNode(0), false);
+        level.addOrderBy(MU<AggregationRefNode>(0), false);
     }
-    Grouping baseRequest = Grouping()
-                           .setFirstLevel(0)
-                           .setLastLevel(1)
-                           .setRoot(Group()
-                                    .addResult(CountAggregationResult()
-                                            .setExpression(AttributeNode("attr0"))))
-                           .addLevel(level);
+    Grouping baseRequest;
+    baseRequest.setFirstLevel(0)
+               .setLastLevel(1)
+               .setRoot(Group().addResult(CountAggregationResult().setExpression(MU<AttributeNode>("attr0"))))
+               .addLevel(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 4b2cf6a708a..8a53460d323 100644
--- a/searchlib/src/tests/groupingengine/groupingengine_test.cpp
+++ b/searchlib/src/tests/groupingengine/groupingengine_test.cpp
@@ -1,7 +1,5 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#include <vespa/fastos/fastos.h>
-#include <vespa/log/log.h>
-LOG_SETUP("groupingengine_test");
+
 #include <vespa/vespalib/testkit/testapp.h>
 #include <vespa/searchlib/aggregation/perdocexpression.h>
 #include <vespa/searchlib/aggregation/aggregation.h>
@@ -41,7 +39,7 @@ public:
         for (uint32_t docid = 0; docid < numDocs; ++docid) {
             T val;
             uint32_t res = rhs._attr->get(docid, &val, 1);
-            LOG_ASSERT(res == 1);
+            assert(res == 1);
             add(val);
         }
     }
@@ -316,22 +314,22 @@ Test::testAggregationSimple()
     testAggregationSimpleSum(ctx, MaxAggregationResult(), Int64ResultNode(15), FloatResultNode(15), StringResultNode("7"));
 }
 
+#define MU std::make_unique
+
 void Test::testAggregationSimpleSum(AggregationContext & ctx, const AggregationResult & aggr, const ResultNode & ir, const ResultNode & fr, const ResultNode & sr)
 {
     ExpressionNode::CP clone(aggr);
-    Grouping request = Grouping()
-                       .setRoot(Group()
-                                    .setId(NullResultNode())
-                                    .addResult(static_cast<AggregationResult &>(*clone).setExpression(AttributeNode("int")))
-                                    .addResult(static_cast<AggregationResult &>(*clone).setExpression(AttributeNode("float")))
-                                    .addResult(static_cast<AggregationResult &>(*clone).setExpression(AttributeNode("string")))
-                               );
-
-    Group expect = Group()
-                   .setId(NullResultNode())
-                   .addResult(static_cast<AggregationResult &>(*clone).setExpression(AttributeNode("int")).setResult(ir))
-                   .addResult(static_cast<AggregationResult &>(*clone).setExpression(AttributeNode("float")).setResult(fr))
-                   .addResult(static_cast<AggregationResult &>(*clone).setExpression(AttributeNode("string")).setResult(sr));
+    Grouping request;
+    request.setRoot(Group().setId(NullResultNode())
+                           .addResult(static_cast<AggregationResult &>(*clone).setExpression(MU<AttributeNode>("int")))
+                           .addResult(static_cast<AggregationResult &>(*clone).setExpression(MU<AttributeNode>("float")))
+                           .addResult(static_cast<AggregationResult &>(*clone).setExpression(MU<AttributeNode>("string"))));
+
+    Group expect;
+    expect.setId(NullResultNode())
+          .addResult(static_cast<AggregationResult &>(*clone).setExpression(MU<AttributeNode>("int")).setResult(ir))
+          .addResult(static_cast<AggregationResult &>(*clone).setExpression(MU<AttributeNode>("float")).setResult(fr))
+          .addResult(static_cast<AggregationResult &>(*clone).setExpression(MU<AttributeNode>("string")).setResult(sr));
 
     EXPECT_TRUE(testAggregation(ctx, request, expect));
 }
@@ -351,97 +349,77 @@ Test::testAggregationLevels()
     ctx.add(IntAttrBuilder("attr3").add(13).add(13).sp());
     ctx.result().add(0).add(1);
 
-    Grouping baseRequest = Grouping()
-                           .setRoot(Group()
-                                    .setId(NullResultNode())
-                                    .addResult(SumAggregationResult()
-                                            .setExpression(AttributeNode("attr0"))))
-                           .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("attr1"))
-                                     .addResult(SumAggregationResult()
-                                             .setExpression(AttributeNode("attr2"))))
-                           .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("attr2"))
-                                     .addResult(SumAggregationResult()
-                                             .setExpression(AttributeNode("attr3"))))
-                           .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("attr3"))
-                                     .addResult(SumAggregationResult()
-                                             .setExpression(AttributeNode("attr1"))));
-
-    Group notDone = Group()
-                    .addResult(SumAggregationResult()
-                               .setExpression(AttributeNode("attr0")));
+    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"))));
+
+    Group notDone;
+    notDone.addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr0")));
 // Hmm, do not need to prepare more than the levels needed.    .setResult(Int64ResultNode(0)));
 
-    Group done0 = Group()
-                  .setId(NullResultNode())
-                  .addResult(SumAggregationResult()
-                             .setExpression(AttributeNode("attr0"))
-                             .setResult(Int64ResultNode(20)))
-                  .addChild(Group()
-                            .setId(Int64ResultNode(11))
-                            .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("attr2"))
-                                       .setResult(Int64ResultNode(0))));
-
-    Group done1 = Group()
-                  .setId(NullResultNode())
-                  .addResult(SumAggregationResult()
-                             .setExpression(AttributeNode("attr0"))
-                             .setResult(Int64ResultNode(20)))
-                  .addChild(Group()
-                            .setId(Int64ResultNode(11))
-                            .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("attr2"))
-                                       .setResult(Int64ResultNode(24)))
-                            .addChild(Group()
-                                      .setId(Int64ResultNode(12))
-                                      .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("attr3"))
-                                              .setResult(Int64ResultNode(0)))));
-
-    Group done2 = Group()
-                  .setId(NullResultNode())
-                  .addResult(SumAggregationResult()
-                             .setExpression(AttributeNode("attr0"))
-                             .setResult(Int64ResultNode(20)))
-                  .addChild(Group()
-                            .setId(Int64ResultNode(11))
-                            .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("attr2"))
-                                       .setResult(Int64ResultNode(24)))
-                            .addChild(Group()
+    Group done0;
+    done0.setId(NullResultNode())
+         .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr0"))
+                                          .setResult(Int64ResultNode(20)))
+         .addChild(Group().setId(Int64ResultNode(11))
+                          .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr2"))
+                                                           .setResult(Int64ResultNode(0))));
+
+    Group done1;
+    done1.setId(NullResultNode())
+         .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr0"))
+                                          .setResult(Int64ResultNode(20)))
+         .addChild(Group().setId(Int64ResultNode(11))
+                          .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr2"))
+                                                           .setResult(Int64ResultNode(24)))
+                          .addChild(Group().setId(Int64ResultNode(12))
+                                           .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr3"))
+                                                                            .setResult(Int64ResultNode(0)))));
+
+    Group done2;
+    done2.setId(NullResultNode())
+         .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr0"))
+                                          .setResult(Int64ResultNode(20)))
+         .addChild(Group().setId(Int64ResultNode(11))
+                          .addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr2"))
+                                                           .setResult(Int64ResultNode(24)))
+                          .addChild(Group()
                                       .setId(Int64ResultNode(12))
                                       .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("attr3"))
+                                              .setExpression(MU<AttributeNode>("attr3"))
                                               .setResult(Int64ResultNode(26)))
                                       .addChild(Group()
                                               .setId(Int64ResultNode(13))
                                               .addResult(SumAggregationResult()
-                                                      .setExpression(AttributeNode("attr1"))
+                                                      .setExpression(MU<AttributeNode>("attr1"))
                                                       .setResult(Int64ResultNode(0))))));
 
-    Group done3 = Group()
-                  .setId(NullResultNode())
-                  .addResult(SumAggregationResult()
-                             .setExpression(AttributeNode("attr0"))
-                             .setResult(Int64ResultNode(20)))
-                  .addChild(Group()
-                            .setId(Int64ResultNode(11))
-                            .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("attr2"))
-                                       .setResult(Int64ResultNode(24)))
-                            .addChild(Group()
-                                      .setId(Int64ResultNode(12))
-                                      .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("attr3"))
-                                              .setResult(Int64ResultNode(26)))
-                                      .addChild(Group()
-                                              .setId(Int64ResultNode(13))
-                                              .addResult(SumAggregationResult()
-                                                      .setExpression(AttributeNode("attr1"))
-                                                      .setResult(Int64ResultNode(22))))));
+    Group done3;
+    done3.setId(NullResultNode())
+         .addResult(SumAggregationResult()
+                            .setExpression(MU<AttributeNode>("attr0"))
+                            .setResult(Int64ResultNode(20)))
+         .addChild(Group().setId(Int64ResultNode(11))
+                          .addResult(SumAggregationResult()
+                                             .setExpression(MU<AttributeNode>("attr2"))
+                                             .setResult(Int64ResultNode(24)))
+                          .addChild(Group().setId(Int64ResultNode(12))
+                                           .addResult(SumAggregationResult()
+                                                              .setExpression(MU<AttributeNode>("attr3"))
+                                                              .setResult(Int64ResultNode(26)))
+                                           .addChild(Group().setId(Int64ResultNode(13))
+                                                            .addResult(SumAggregationResult()
+                                                                               .setExpression(MU<AttributeNode>("attr1"))
+                                                                               .setResult(Int64ResultNode(22))))));
 
     { // level 0 only
         Grouping request = baseRequest.unchain().setFirstLevel(0).setLastLevel(0);
@@ -499,7 +477,7 @@ Test::testAggregationMaxGroups()
     Grouping baseRequest = Grouping()
                            .setRoot(Group().setId(NullResultNode()))
                            .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("attr")));
+                                     .setExpression(MU<AttributeNode>("attr")));
 
     Group empty = Group().setId(NullResultNode());
     Group grp1 = empty.unchain().addChild(Group().setId(Int64ResultNode(5)));
@@ -551,17 +529,17 @@ Test::testAggregationGroupOrder()
     Grouping request = Grouping()
                        .setRoot(Group().setId(NullResultNode()))
                        .addLevel(GroupingLevel()
-                                 .setExpression(AttributeNode("attr")));
-
-    Group expect = Group()
-                   .setId(NullResultNode())
-                   .addChild(Group().setId(Int64ResultNode(5)))
-                   .addChild(Group().setId(Int64ResultNode(10)))
-                   .addChild(Group().setId(Int64ResultNode(15)))
-                   .addChild(Group().setId(Int64ResultNode(20)))
-                   .addChild(Group().setId(Int64ResultNode(25)))
-                   .addChild(Group().setId(Int64ResultNode(30)))
-                   .addChild(Group().setId(Int64ResultNode(35)));
+                                 .setExpression(MU<AttributeNode>("attr")));
+
+    Group expect;
+    expect.setId(NullResultNode())
+          .addChild(Group().setId(Int64ResultNode(5)))
+          .addChild(Group().setId(Int64ResultNode(10)))
+          .addChild(Group().setId(Int64ResultNode(15)))
+          .addChild(Group().setId(Int64ResultNode(20)))
+          .addChild(Group().setId(Int64ResultNode(25)))
+          .addChild(Group().setId(Int64ResultNode(30)))
+          .addChild(Group().setId(Int64ResultNode(35)));
 
     EXPECT_TRUE(testAggregation(ctx, request, expect));
 }
@@ -584,7 +562,7 @@ Test::testAggregationGroupRank()
 
     Grouping request = Grouping()
                            .setRoot(Group().setId(NullResultNode()))
-                           .addLevel(GroupingLevel().setExpression(AttributeNode("attr")));
+                           .addLevel(GroupingLevel().setExpression(MU<AttributeNode>("attr")));
 
     Group expect = Group()
                    .setId(NullResultNode())
@@ -610,7 +588,7 @@ Test::testAggregationGroupCapping()
 
     {
         Grouping request = Grouping().setRoot(Group().setId(NullResultNode())).addLevel(
-                               GroupingLevel().setExpression(AttributeNode("attr")));
+                               GroupingLevel().setExpression(MU<AttributeNode>("attr")));
 
         Group expect = Group().setId(NullResultNode())
                        .addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(1)))
@@ -626,66 +604,70 @@ Test::testAggregationGroupCapping()
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
     {
-        Grouping request = Grouping().setRoot(Group().setId(NullResultNode())).addLevel(
-                               GroupingLevel().setMaxGroups(3).setExpression(AttributeNode("attr")));
+        Grouping request;
+        request.setRoot(Group().setId(NullResultNode())).addLevel(
+                               GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr")));
 
-        Group expect = Group().setId(NullResultNode())
-                       .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7)))
-                       .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8)))
-                       .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9)));
+        Group expect;
+        expect.setId(NullResultNode())
+              .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7)))
+              .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8)))
+              .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9)));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
     {
-        Grouping request = Grouping().
-                               setRoot(Group().setId(NullResultNode())).
-                               setFirstLevel(0).
-                               setLastLevel(1).
-                               addLevel(
-                                   GroupingLevel().setMaxGroups(3).setExpression(AttributeNode("attr")).
-                                       addAggregationResult(SumAggregationResult().setExpression(AttributeNode("attr"))).
-                                       addOrderBy(AggregationRefNode(0), false));
-
-        Group expect = Group().setId(NullResultNode())
-                       .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7)).addAggregationResult(SumAggregationResult(Int64ResultNode(7)).setExpression(AttributeNode("attr"))).addOrderBy(AggregationRefNode(0), false))
-                       .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8)).addAggregationResult(SumAggregationResult(Int64ResultNode(8)).setExpression(AttributeNode("attr"))).addOrderBy(AggregationRefNode(0), false))
-                       .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9)).addAggregationResult(SumAggregationResult(Int64ResultNode(9)).setExpression(AttributeNode("attr"))).addOrderBy(AggregationRefNode(0), false));
+        Grouping request;
+        request.setRoot(Group().setId(NullResultNode()))
+                .setFirstLevel(0)
+                .setLastLevel(1)
+                .addLevel(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr"))
+                                  .addResult(SumAggregationResult().setExpression(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));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
     {
-        Grouping request = Grouping().
-                               setRoot(Group().setId(NullResultNode())).
-                               setFirstLevel(0).
-                               setLastLevel(1).
-                               addLevel(
-                                   GroupingLevel().setMaxGroups(3).setExpression(AttributeNode("attr")).
-                                       addAggregationResult(SumAggregationResult().setExpression(AttributeNode("attr"))).addOrderBy(AggregationRefNode(0), true));
-
-        Group expect = Group().setId(NullResultNode())
-                       .addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(1)).addAggregationResult(SumAggregationResult(Int64ResultNode(1)).setExpression(AttributeNode("attr"))).addOrderBy(AggregationRefNode(0), true))
-                       .addChild(Group().setId(Int64ResultNode(2)).setRank(RawRank(2)).addAggregationResult(SumAggregationResult(Int64ResultNode(2)).setExpression(AttributeNode("attr"))).addOrderBy(AggregationRefNode(0), true))
-                       .addChild(Group().setId(Int64ResultNode(3)).setRank(RawRank(3)).addAggregationResult(SumAggregationResult(Int64ResultNode(3)).setExpression(AttributeNode("attr"))).addOrderBy(AggregationRefNode(0), true));
+        Grouping request;
+        request.setRoot(Group().setId(NullResultNode()))
+               .setFirstLevel(0)
+                .setLastLevel(1)
+                .addLevel(GroupingLevel()
+                                  .setMaxGroups(3)
+                                  .setExpression(MU<AttributeNode>("attr"))
+                                  .addResult(SumAggregationResult().setExpression(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));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
     {
         AddFunctionNode *add = new AddFunctionNode();
-        add->addArg(AggregationRefNode(0));
-        add->appendArg(ConstantNode(Int64ResultNode(3)));
-        ExpressionNode::CP i1(add);
-        Grouping request = Grouping().
-                               setFirstLevel(0).
-                               setLastLevel(1).
-                               addLevel(
-                                   GroupingLevel().setMaxGroups(3).setExpression(AttributeNode("attr")).
-                                       addAggregationResult(SumAggregationResult().setExpression(AttributeNode("attr"))).
-                                       addOrderBy(i1, false));
+        add->addArg(MU<AggregationRefNode>(0));
+        add->appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3)));
+        ExpressionNode::UP i1(add);
+        Grouping request;
+        request.setFirstLevel(0)
+                .setLastLevel(1)
+                .addLevel(GroupingLevel().setMaxGroups(3).setExpression(MU<AttributeNode>("attr")).
+                        addResult(SumAggregationResult().setExpression(MU<AttributeNode>("attr"))).
+                        addOrderBy(std::move(i1), false));
 
         Group expect = Group()
-                       .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7)).addAggregationResult(SumAggregationResult(Int64ResultNode(7)).setExpression(AttributeNode("attr"))).addOrderBy(AddFunctionNode().appendArg(AggregationRefNode(0)).appendArg(ConstantNode(Int64ResultNode(3))).setResult(Int64ResultNode(10)), false))
-                       .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8)).addAggregationResult(SumAggregationResult(Int64ResultNode(8)).setExpression(AttributeNode("attr"))).addOrderBy(AddFunctionNode().appendArg(AggregationRefNode(0)).appendArg(ConstantNode(Int64ResultNode(3))).setResult(Int64ResultNode(11)), false))
-                       .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9)).addAggregationResult(SumAggregationResult(Int64ResultNode(9)).setExpression(AttributeNode("attr"))).addOrderBy(AddFunctionNode().appendArg(AggregationRefNode(0)).appendArg(ConstantNode(Int64ResultNode(3))).setResult(Int64ResultNode(12)), false));
+                       .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_TRUE(testAggregation(ctx, request, expect));
     }
@@ -706,20 +688,20 @@ Test::testMergeSimpleSum()
                   .setRoot(Group()
                            .setId(NullResultNode())
                            .addResult(SumAggregationResult()
-                                      .setExpression(AttributeNode("foo"))
+                                      .setExpression(MU<AttributeNode>("foo"))
                                       .setResult(Int64ResultNode(20))));
 
     Grouping b  = Grouping()
                   .setRoot(Group()
                            .setId(NullResultNode())
                            .addResult(SumAggregationResult()
-                                      .setExpression(AttributeNode("foo"))
+                                      .setExpression(MU<AttributeNode>("foo"))
                                       .setResult(Int64ResultNode(30))));
 
     Group expect = Group()
                    .setId(NullResultNode())
                    .addResult(SumAggregationResult()
-                              .setExpression(AttributeNode("foo"))
+                              .setExpression(MU<AttributeNode>("foo"))
                               .setResult(Int64ResultNode(50)));
 
     EXPECT_TRUE(testMerge(a, b, expect));
@@ -733,166 +715,166 @@ Test::testMergeLevels()
 {
     Grouping request = Grouping()
                        .addLevel(GroupingLevel()
-                                 .setExpression(AttributeNode("c1"))
+                                 .setExpression(MU<AttributeNode>("c1"))
                                  .addResult(SumAggregationResult()
-                                         .setExpression(AttributeNode("s1"))))
+                                         .setExpression(MU<AttributeNode>("s1"))))
                        .addLevel(GroupingLevel()
-                                 .setExpression(AttributeNode("c2"))
+                                 .setExpression(MU<AttributeNode>("c2"))
                                  .addResult(SumAggregationResult()
-                                         .setExpression(AttributeNode("s2"))))
+                                         .setExpression(MU<AttributeNode>("s2"))))
                        .addLevel(GroupingLevel()
-                                 .setExpression(AttributeNode("c3"))
+                                 .setExpression(MU<AttributeNode>("c3"))
                                  .addResult(SumAggregationResult()
-                                         .setExpression(AttributeNode("s3"))));
+                                         .setExpression(MU<AttributeNode>("s3"))));
 
     Group a = Group()
               .setId(NullResultNode())
               .addResult(SumAggregationResult()
-                         .setExpression(AttributeNode("s0"))
+                         .setExpression(MU<AttributeNode>("s0"))
                          .setResult(Int64ResultNode(5)))
               .addChild(Group()
                         .setId(Int64ResultNode(10))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(10)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(20))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(15)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(30))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(20))))));
 
     Group b = Group()
               .setId(NullResultNode())
               .addResult(SumAggregationResult()
-                         .setExpression(AttributeNode("s0"))
+                         .setExpression(MU<AttributeNode>("s0"))
                          .setResult(Int64ResultNode(5)))
               .addChild(Group()
                         .setId(Int64ResultNode(10))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(10)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(20))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(15)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(30))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(20))))));
 
     Group expect_all = Group()
                        .setId(NullResultNode())
                        .addResult(SumAggregationResult()
-                                  .setExpression(AttributeNode("s0"))
+                                  .setExpression(MU<AttributeNode>("s0"))
                                   .setResult(Int64ResultNode(10)))
                        .addChild(Group()
                                  .setId(Int64ResultNode(10))
                                  .addResult(SumAggregationResult()
-                                         .setExpression(AttributeNode("s1"))
+                                         .setExpression(MU<AttributeNode>("s1"))
                                          .setResult(Int64ResultNode(20)))
                                  .addChild(Group()
                                          .setId(Int64ResultNode(20))
                                          .addResult(SumAggregationResult()
-                                                 .setExpression(AttributeNode("s2"))
+                                                 .setExpression(MU<AttributeNode>("s2"))
                                                  .setResult(Int64ResultNode(30)))
                                          .addChild(Group()
                                                  .setId(Int64ResultNode(30))
                                                  .addResult(SumAggregationResult()
-                                                         .setExpression(AttributeNode("s3"))
+                                                         .setExpression(MU<AttributeNode>("s3"))
                                                          .setResult(Int64ResultNode(40))))));
 
     Group expect_0 = Group()
                      .setId(NullResultNode())
                      .addResult(SumAggregationResult()
-                                .setExpression(AttributeNode("s0"))
+                                .setExpression(MU<AttributeNode>("s0"))
                                 .setResult(Int64ResultNode(5)))
                      .addChild(Group()
                                .setId(Int64ResultNode(10))
                                .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(20)))
                                .addChild(Group()
                                        .setId(Int64ResultNode(20))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(30)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(30))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(40))))));
 
 
     Group expect_1 = Group()
                      .setId(NullResultNode())
                      .addResult(SumAggregationResult()
-                                .setExpression(AttributeNode("s0"))
+                                .setExpression(MU<AttributeNode>("s0"))
                                 .setResult(Int64ResultNode(5)))
                      .addChild(Group()
                                .setId(Int64ResultNode(10))
                                .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(10)))
                                .addChild(Group()
                                        .setId(Int64ResultNode(20))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(30)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(30))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(40))))));
 
 
     Group expect_2 = Group()
                      .setId(NullResultNode())
                      .addResult(SumAggregationResult()
-                                .setExpression(AttributeNode("s0"))
+                                .setExpression(MU<AttributeNode>("s0"))
                                 .setResult(Int64ResultNode(5)))
                      .addChild(Group()
                                .setId(Int64ResultNode(10))
                                .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(10)))
                                .addChild(Group()
                                        .setId(Int64ResultNode(20))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(15)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(30))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(40))))));
 
 
     Group expect_3 = Group()
                      .setId(NullResultNode())
                      .addResult(SumAggregationResult()
-                                .setExpression(AttributeNode("s0"))
+                                .setExpression(MU<AttributeNode>("s0"))
                                 .setResult(Int64ResultNode(5)))
                      .addChild(Group()
                                .setId(Int64ResultNode(10))
                                .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(10)))
                                .addChild(Group()
                                        .setId(Int64ResultNode(20))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(15)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(30))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(20))))));
 
     EXPECT_TRUE(testMerge(request.unchain().setFirstLevel(0).setLastLevel(3).setRoot(a),
@@ -922,7 +904,7 @@ Test::testMergeGroups()
 {
     Grouping request = Grouping()
                        .addLevel(GroupingLevel()
-                                 .setExpression(AttributeNode("attr")));
+                                 .setExpression(MU<AttributeNode>("attr")));
 
     Group a = Group()
               .setId(NullResultNode())
@@ -986,45 +968,45 @@ Test::testMergeTrees()
     Grouping request = Grouping()
                        .addLevel(GroupingLevel()
                                  .setMaxGroups(3)
-                                 .setExpression(AttributeNode("c1"))
+                                 .setExpression(MU<AttributeNode>("c1"))
                                  .addResult(SumAggregationResult()
-                                         .setExpression(AttributeNode("s1"))))
+                                         .setExpression(MU<AttributeNode>("s1"))))
                        .addLevel(GroupingLevel()
                                  .setMaxGroups(2)
-                                 .setExpression(AttributeNode("c2"))
+                                 .setExpression(MU<AttributeNode>("c2"))
                                  .addResult(SumAggregationResult()
-                                         .setExpression(AttributeNode("s2"))))
+                                         .setExpression(MU<AttributeNode>("s2"))))
                        .addLevel(GroupingLevel()
                                  .setMaxGroups(1)
-                                 .setExpression(AttributeNode("c3"))
+                                 .setExpression(MU<AttributeNode>("c3"))
                                  .addResult(SumAggregationResult()
-                                         .setExpression(AttributeNode("s3"))));
+                                         .setExpression(MU<AttributeNode>("s3"))));
 
     Group a = Group()
               .setId(NullResultNode())
               .addResult(SumAggregationResult()
-                         .setExpression(AttributeNode("s0"))
+                         .setExpression(MU<AttributeNode>("s0"))
                          .setResult(Int64ResultNode(100)))
               .addChild(Group().setId(Int64ResultNode(4)).setRank(RawRank(10)))
               .addChild(Group()
                         .setId(Int64ResultNode(5))
                         .setRank(RawRank(5)) // merged with 200 rank node
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(100)))
                         .addChild(Group().setId(Int64ResultNode(4)).setRank(RawRank(10)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(5))
                                   .setRank(RawRank(500))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   .addChild(Group().setId(Int64ResultNode(4)).setRank(RawRank(10)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(5))
                                           .setRank(RawRank(200))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(100)))
                                             )
                                   )
@@ -1034,21 +1016,21 @@ Test::testMergeTrees()
                         .setId(Int64ResultNode(10))
                         .setRank(RawRank(100))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(100)))
                         // dummy child would be picked up here
                         .addChild(Group()
                                   .setId(Int64ResultNode(15))
                                   .setRank(RawRank(200))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   .addChild(Group().setId(Int64ResultNode(14)).setRank(RawRank(10)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(15))
                                           .setRank(RawRank(300))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(100)))
                                             )
                                   )
@@ -1058,14 +1040,14 @@ Test::testMergeTrees()
                         .setId(Int64ResultNode(15))
                         .setRank(RawRank(300))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(100)))
                         .addChild(Group().setId(Int64ResultNode(19)).setRank(RawRank(10)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(20))
                                   .setRank(RawRank(100))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   )
                         );
@@ -1073,28 +1055,28 @@ Test::testMergeTrees()
     Group b = Group()
               .setId(NullResultNode())
               .addResult(SumAggregationResult()
-                         .setExpression(AttributeNode("s0"))
+                         .setExpression(MU<AttributeNode>("s0"))
                          .setResult(Int64ResultNode(100)))
               .addChild(Group().setId(Int64ResultNode(4)).setRank(RawRank(10)))
               .addChild(Group()
                         .setId(Int64ResultNode(5))
                         .setRank(RawRank(200))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(100)))
                         .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(10)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(10))
                                   .setRank(RawRank(400))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(10)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(10))
                                           .setRank(RawRank(100))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(100)))
                                             )
                                   )
@@ -1104,14 +1086,14 @@ Test::testMergeTrees()
                         .setId(Int64ResultNode(10))
                         .setRank(RawRank(100))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(100)))
                         // dummy child would be picket up here
                         .addChild(Group()
                                   .setId(Int64ResultNode(15))
                                   .setRank(RawRank(200))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   )
                         )
@@ -1120,21 +1102,21 @@ Test::testMergeTrees()
                         .setId(Int64ResultNode(15))
                         .setRank(RawRank(5)) // merged with 300 rank node
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(100)))
                         .addChild(Group().setId(Int64ResultNode(19)).setRank(RawRank(10)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(20))
                                   .setRank(RawRank(5)) // merged with 100 rank node
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   .addChild(Group().setId(Int64ResultNode(19)).setRank(RawRank(10)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(20))
                                           .setRank(RawRank(500))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(100)))
                                             )
                                   )
@@ -1143,14 +1125,14 @@ Test::testMergeTrees()
                                   .setId(Int64ResultNode(25))
                                   .setRank(RawRank(300))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   .addChild(Group().setId(Int64ResultNode(24)).setRank(RawRank(10)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(25))
                                           .setRank(RawRank(400))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(100)))
                                             )
                                   )
@@ -1159,25 +1141,25 @@ Test::testMergeTrees()
     Group expect = Group()
                    .setId(NullResultNode())
                    .addResult(SumAggregationResult()
-                              .setExpression(AttributeNode("s0"))
+                              .setExpression(MU<AttributeNode>("s0"))
                               .setResult(Int64ResultNode(200)))
                    .addChild(Group()
                              .setId(Int64ResultNode(5))
                              .setRank(RawRank(200))
                              .addResult(SumAggregationResult()
-                                        .setExpression(AttributeNode("s1"))
+                                        .setExpression(MU<AttributeNode>("s1"))
                                         .setResult(Int64ResultNode(200)))
                              .addChild(Group()
                                        .setId(Int64ResultNode(5))
                                        .setRank(RawRank(500))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(100)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(5))
                                                .setRank(RawRank(200))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(100)))
                                                  )
                                        )
@@ -1185,13 +1167,13 @@ Test::testMergeTrees()
                                        .setId(Int64ResultNode(10))
                                        .setRank(RawRank(400))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(100)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(10))
                                                .setRank(RawRank(100))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(100)))
                                                  )
                                        )
@@ -1200,19 +1182,19 @@ Test::testMergeTrees()
                              .setId(Int64ResultNode(10))
                              .setRank(RawRank(100))
                              .addResult(SumAggregationResult()
-                                        .setExpression(AttributeNode("s1"))
+                                        .setExpression(MU<AttributeNode>("s1"))
                                         .setResult(Int64ResultNode(200)))
                              .addChild(Group()
                                        .setId(Int64ResultNode(15))
                                        .setRank(RawRank(200))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(200)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(15))
                                                .setRank(RawRank(300))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(100)))
                                                  )
                                        )
@@ -1221,19 +1203,19 @@ Test::testMergeTrees()
                              .setId(Int64ResultNode(15))
                              .setRank(RawRank(300))
                              .addResult(SumAggregationResult()
-                                        .setExpression(AttributeNode("s1"))
+                                        .setExpression(MU<AttributeNode>("s1"))
                                         .setResult(Int64ResultNode(200)))
                              .addChild(Group()
                                        .setId(Int64ResultNode(20))
                                        .setRank(RawRank(100))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(200)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(20))
                                                .setRank(RawRank(500))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(100)))
                                                  )
                                        )
@@ -1241,13 +1223,13 @@ Test::testMergeTrees()
                                        .setId(Int64ResultNode(25))
                                        .setRank(RawRank(300))
                                        .addResult(SumAggregationResult()
-                                               .setExpression(AttributeNode("s2"))
+                                               .setExpression(MU<AttributeNode>("s2"))
                                                .setResult(Int64ResultNode(100)))
                                        .addChild(Group()
                                                .setId(Int64ResultNode(25))
                                                .setRank(RawRank(400))
                                                .addResult(SumAggregationResult()
-                                                       .setExpression(AttributeNode("s3"))
+                                                       .setExpression(MU<AttributeNode>("s3"))
                                                        .setResult(Int64ResultNode(100)))
                                                  )
                                        )
@@ -1402,37 +1384,37 @@ Test::testPartialMerging()
 {
     Grouping baseRequest = Grouping()
                            .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("c1"))
+                                     .setExpression(MU<AttributeNode>("c1"))
                                      .addResult(SumAggregationResult()
-                                                .setExpression(AttributeNode("s1"))))
+                                                .setExpression(MU<AttributeNode>("s1"))))
                            .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("c2"))
+                                     .setExpression(MU<AttributeNode>("c2"))
                                      .addResult(SumAggregationResult()
-                                                .setExpression(AttributeNode("s2"))))
+                                                .setExpression(MU<AttributeNode>("s2"))))
                            .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("c3"))
+                                     .setExpression(MU<AttributeNode>("c3"))
                                      .addResult(SumAggregationResult()
-                                                .setExpression(AttributeNode("s3"))));
+                                                .setExpression(MU<AttributeNode>("s3"))));
 
     // Cached result
     Group cached = Group()
               .addResult(SumAggregationResult()
-                         .setExpression(AttributeNode("s0"))
+                         .setExpression(MU<AttributeNode>("s0"))
                          .setResult(Int64ResultNode(110)))
               .addChild(Group()
                         .setId(Int64ResultNode(5))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(10)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(13))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(14))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(100)))
                                             )
                                   )
@@ -1440,17 +1422,17 @@ Test::testPartialMerging()
               .addChild(Group()
                         .setId(Int64ResultNode(10))
                         .addResult(SumAggregationResult()
-                                   .setExpression(AttributeNode("s1"))
+                                   .setExpression(MU<AttributeNode>("s1"))
                                    .setResult(Int64ResultNode(100)))
                         .addChild(Group()
                                   .setId(Int64ResultNode(15))
                                   .addResult(SumAggregationResult()
-                                          .setExpression(AttributeNode("s2"))
+                                          .setExpression(MU<AttributeNode>("s2"))
                                           .setResult(Int64ResultNode(100)))
                                   .addChild(Group()
                                           .setId(Int64ResultNode(22))
                                           .addResult(SumAggregationResult()
-                                                  .setExpression(AttributeNode("s3"))
+                                                  .setExpression(MU<AttributeNode>("s3"))
                                                   .setResult(Int64ResultNode(100)))
                                             )
                                   )
@@ -1461,23 +1443,23 @@ Test::testPartialMerging()
         Grouping request = baseRequest.unchain().setFirstLevel(0).setLastLevel(0);
         Group incoming = Group()
                          .addResult(SumAggregationResult()
-                                    .setExpression(AttributeNode("s0"))
+                                    .setExpression(MU<AttributeNode>("s0"))
                                     .setResult(Int64ResultNode(0)));
 
         Group expected = Group()
                          .addResult(SumAggregationResult()
-                                    .setExpression(AttributeNode("s0"))
+                                    .setExpression(MU<AttributeNode>("s0"))
                                     .setResult(Int64ResultNode(110)))
                          .addChild(Group()
                                    .setId(Int64ResultNode(5))
                                    .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s1"))
+                                              .setExpression(MU<AttributeNode>("s1"))
                                               .setResult(Int64ResultNode(0)))
                                    )
                          .addChild(Group()
                                    .setId(Int64ResultNode(10))
                                    .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s1"))
+                                              .setExpression(MU<AttributeNode>("s1"))
                                               .setResult(Int64ResultNode(0)))
                                   );
         EXPECT_TRUE(testPartialMerge(request.unchain().setRoot(incoming), request.unchain().setLastLevel(3).setRoot(cached), expected));
@@ -1487,81 +1469,81 @@ Test::testPartialMerging()
         Grouping request = baseRequest.unchain().setFirstLevel(1).setLastLevel(1);
         Group incoming = Group()
                          .addResult(SumAggregationResult()
-                                    .setExpression(AttributeNode("s0"))
+                                    .setExpression(MU<AttributeNode>("s0"))
                                     .setResult(Int64ResultNode(200)))
                          .addChild(Group()
                                    .setId(Int64ResultNode(3))
                                    .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s1"))
+                                              .setExpression(MU<AttributeNode>("s1"))
                                               .setResult(Int64ResultNode(0)))
                                    )
                          .addChild(Group()
                                    .setId(Int64ResultNode(5))
                                    .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s1"))
+                                              .setExpression(MU<AttributeNode>("s1"))
                                               .setResult(Int64ResultNode(0)))
                                    )
                          .addChild(Group()
                                    .setId(Int64ResultNode(7))
                                    .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s1"))
+                                              .setExpression(MU<AttributeNode>("s1"))
                                               .setResult(Int64ResultNode(0)))
                                    )
                          .addChild(Group()
                                    .setId(Int64ResultNode(10))
                                    .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s1"))
+                                              .setExpression(MU<AttributeNode>("s1"))
                                               .setResult(Int64ResultNode(0))))
                          .addChild(Group()
                                    .setId(Int64ResultNode(33))
                                    .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s1"))
+                                              .setExpression(MU<AttributeNode>("s1"))
                                               .setResult(Int64ResultNode(0)))
                                    );
         Group expected = Group()
                   .addResult(SumAggregationResult()
-                             .setExpression(AttributeNode("s0"))
+                             .setExpression(MU<AttributeNode>("s0"))
                              .setResult(Int64ResultNode(200)))
                   .addChild(Group()
                             .setId(Int64ResultNode(3))
                             .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(0)))
                             )
                   .addChild(Group()
                             .setId(Int64ResultNode(5))
                             .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(10)))
                             .addChild(Group()
                                       .setId(Int64ResultNode(13))
                                       .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s2"))
+                                              .setExpression(MU<AttributeNode>("s2"))
                                               .setResult(Int64ResultNode(0)))
                                       )
                             )
                   .addChild(Group()
                             .setId(Int64ResultNode(7))
                             .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(0)))
                             )
                   .addChild(Group()
                             .setId(Int64ResultNode(10))
                             .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(100)))
                             .addChild(Group()
                                       .setId(Int64ResultNode(15))
                                       .addResult(SumAggregationResult()
-                                              .setExpression(AttributeNode("s2"))
+                                              .setExpression(MU<AttributeNode>("s2"))
                                               .setResult(Int64ResultNode(0)))
                                       )
                             )
                   .addChild(Group()
                             .setId(Int64ResultNode(33))
                             .addResult(SumAggregationResult()
-                                       .setExpression(AttributeNode("s1"))
+                                       .setExpression(MU<AttributeNode>("s1"))
                                        .setResult(Int64ResultNode(0)))
                             );
         EXPECT_TRUE(testPartialMerge(request.unchain().setRoot(incoming), request.unchain().setFirstLevel(0).setLastLevel(3).setRoot(cached), expected));
@@ -1577,7 +1559,7 @@ Test::testPruneSimple()
     {
         Grouping request = Grouping()
                            .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("attr")))
+                                     .setExpression(MU<AttributeNode>("attr")))
                            .setFirstLevel(1)
                            .setLastLevel(1);
 
@@ -1607,25 +1589,17 @@ 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().setId(NullResultNode())
-                                .addResult(CountAggregationResult()
-                                        .setExpression(ConstantNode(Int64ResultNode(0)))
-                                           )
-                                );
+    Grouping request;
+    request.setRoot(Group().setId(NullResultNode()).addResult(CountAggregationResult().setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0)))));
     {
-        Group expect = Group().setId(NullResultNode())
-                       .addResult(CountAggregationResult().setCount(3)
-                                  .setExpression(ConstantNode(Int64ResultNode(0)))
-                                  );
+        Group expect;
+        expect.setId(NullResultNode()).addResult(CountAggregationResult().setCount(3).setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
     {
-        Group expect = Group().setId(NullResultNode())
-                       .addResult(CountAggregationResult().setCount(1)
-                                  .setExpression(ConstantNode(Int64ResultNode(0)))
-                                  );
+        Group expect;
+        expect.setId(NullResultNode()).addResult(CountAggregationResult().setCount(1).setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
         EXPECT_TRUE(testAggregation(ctx, request.setTopN(1), expect));
     }
@@ -1633,8 +1607,8 @@ Test::testTopN()
         Grouping request2 = Grouping()
                             .setRoot(Group().setId(NullResultNode()))
                             .addLevel(GroupingLevel()
-                                      .addAggregationResult(SumAggregationResult())
-                                      .addOrderBy(AggregationRefNode(0), false));
+                                      .addAggregationResult(MU<SumAggregationResult>())
+                                      .addOrderBy(MU<AggregationRefNode>(0), false));
         EXPECT_TRUE(request2.needResort());
         request2.setTopN(0);
         EXPECT_TRUE(request2.needResort());
@@ -1659,14 +1633,11 @@ Test::testCount()
     Grouping request = Grouping()
                        .setRoot(Group().setId(NullResultNode())
                                 .addResult(CountAggregationResult()
-                                        .setExpression(ConstantNode(Int64ResultNode(0)))
+                                        .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0)))
                                            )
                                 );
 
-    Group expect = Group().setId(NullResultNode())
-                   .addResult(CountAggregationResult().setCount(3)
-                              .setExpression(ConstantNode(Int64ResultNode(0)))
-                              );
+    Group expect = Group().setId(NullResultNode()).addResult(CountAggregationResult().setCount(3).setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
     EXPECT_TRUE(testAggregation(ctx, request, expect));
 }
@@ -1693,7 +1664,7 @@ Test::testFS4HitCollection()
                            .setRoot(Group().setId(NullResultNode())
                                     .addResult(HitsAggregationResult()
                                             .setMaxHits(3)
-                                            .setExpression(ConstantNode(Int64ResultNode(0))))
+                                            .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))))
                                     );
 
         Group expect = Group().setId(NullResultNode())
@@ -1703,7 +1674,7 @@ Test::testFS4HitCollection()
                                   .addHit(FS4Hit(25, 25.0))
                                   .addHit(FS4Hit(20, 20.0))
                                   .sort()
-                                  .setExpression(ConstantNode(Int64ResultNode(0))));
+                                  .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
     }
@@ -1713,7 +1684,7 @@ Test::testFS4HitCollection()
                            .setRoot(Group()
                                     .addResult(HitsAggregationResult()
                                             .setMaxHits(3)
-                                            .setExpression(ConstantNode(Int64ResultNode(0))))
+                                            .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))))
                                     );
 
         Group expect = Group()
@@ -1724,7 +1695,7 @@ Test::testFS4HitCollection()
                                   .addHit(FS4Hit(20, 20.0))
                                   .addHit(FS4Hit(10, 10.0))
                                   .sort()
-                                  .setExpression(ConstantNode(Int64ResultNode(0))));
+                                  .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
         Group a = Group()
                   .setId(NullResultNode())
@@ -1734,7 +1705,7 @@ Test::testFS4HitCollection()
                              .addHit(FS4Hit(1,   5.0))
                              .addHit(FS4Hit(2,   4.0))
                              .sort()
-                             .setExpression(ConstantNode(Int64ResultNode(0))));
+                             .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
         Group b = Group()
                   .setId(NullResultNode())
@@ -1744,7 +1715,7 @@ Test::testFS4HitCollection()
                              .addHit(FS4Hit(3,   7.0))
                              .addHit(FS4Hit(4,   6.0))
                              .sort()
-                             .setExpression(ConstantNode(Int64ResultNode(0))));
+                             .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
         Group c = Group()
                   .setId(NullResultNode())
@@ -1754,7 +1725,7 @@ Test::testFS4HitCollection()
                              .addHit(FS4Hit(5,   9.0))
                              .addHit(FS4Hit(6,   8.0))
                              .sort()
-                             .setExpression(ConstantNode(Int64ResultNode(0))));
+                             .setExpression(MU<ConstantNode>(MU<Int64ResultNode>(0))));
 
         EXPECT_TRUE(testMerge(request.unchain().setRoot(a), request.unchain().setRoot(b), request.unchain().setRoot(c), expect));
         EXPECT_TRUE(testMerge(request.unchain().setRoot(b), request.unchain().setRoot(c), request.unchain().setRoot(a), expect));
@@ -1810,9 +1781,11 @@ Test::checkBucket(const NumericResultNode &width, const NumericResultNode &value
     } else {
         return EXPECT_TRUE(false);
     }
+    std::unique_ptr<FixedWidthBucketFunctionNode> fixed = MU<FixedWidthBucketFunctionNode>(MU<AttributeNode>("attr"));
+    fixed->setWidth(width);
     Grouping request = Grouping().setRoot(Group().setId(NullResultNode()))
                        .addLevel(GroupingLevel()
-                                 .setExpression(FixedWidthBucketFunctionNode(AttributeNode("attr")).setWidth(width)));
+                                 .setExpression(std::move(fixed)));
     Group expect = Group().setId(NullResultNode()).addChild(Group().setId(bucket));
     return testAggregation(ctx, request, expect);
 }
@@ -1932,19 +1905,19 @@ Test::testGroupingEngineFromRequest()
     Grouping baseRequest = Grouping()
                            .setRoot(Group()
                                     .addResult(SumAggregationResult()
-                                            .setExpression(AttributeNode("attr0"))))
+                                            .setExpression(MU<AttributeNode>("attr0"))))
                            .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("attr1"))
+                                     .setExpression(MU<AttributeNode>("attr1"))
                                      .addResult(SumAggregationResult()
-                                             .setExpression(AttributeNode("attr2"))))
+                                             .setExpression(MU<AttributeNode>("attr2"))))
                            .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("attr2"))
+                                     .setExpression(MU<AttributeNode>("attr2"))
                                      .addResult(SumAggregationResult()
-                                             .setExpression(AttributeNode("attr3"))))
+                                             .setExpression(MU<AttributeNode>("attr3"))))
                            .addLevel(GroupingLevel()
-                                     .setExpression(AttributeNode("attr3"))
+                                     .setExpression(MU<AttributeNode>("attr3"))
                                      .addResult(SumAggregationResult()
-                                             .setExpression(AttributeNode("attr1"))));
+                                             .setExpression(MU<AttributeNode>("attr1"))));
     ctx.setup(baseRequest);
     GroupingEngine engine(baseRequest.setFirstLevel(0).setLastLevel(2));
     EXPECT_EQUAL(4u, engine.getEngines().size());