summaryrefslogtreecommitdiffstats
path: root/searchlib/src/tests/grouping
diff options
context:
space:
mode:
authorHenning Baldersheim <balder@yahoo-inc.com>2017-03-23 10:30:23 +0100
committerHenning Baldersheim <balder@yahoo-inc.com>2017-03-27 16:21:01 +0200
commit3656023785d17d513b67f4cbe8686a40141e06d8 (patch)
treed3e26110f82326573c0378d74f8d1dc189b32973 /searchlib/src/tests/grouping
parent0cd6a2c04f90ffbdba4d585f1d71a5dd2b4e8311 (diff)
Remove ExpressionNode::CP from interfaces.
Diffstat (limited to 'searchlib/src/tests/grouping')
-rw-r--r--searchlib/src/tests/grouping/grouping_serialization_test.cpp153
-rw-r--r--searchlib/src/tests/grouping/grouping_test.cpp563
2 files changed, 349 insertions, 367 deletions
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);
}