int main()
{
fillArray(test_array, 4, 128);
cache = cache_new(CACHE_SIZE_IN_BLOCKS, block_size, 1, CACHE_REPLACEMENTPOLICY_LRU);
print_stats(sumA(test_array, 4, 128));
cache = cache_new(CACHE_SIZE_IN_BLOCKS, block_size, 1, CACHE_REPLACEMENTPOLICY_LRU);
print_stats(sumB(test_array, 4, 128));
cache = cache_new(CACHE_SIZE_IN_BLOCKS, block_size, 1, CACHE_REPLACEMENTPOLICY_LRU);
print_stats(sumC(test_array, 4, 128));
}
TEST(AggregateTests, HashSumGroupByTest) {
/*
* SELECT b, SUM(c) from table GROUP BY b;
*/
const int tuple_count = TESTS_TUPLES_PER_TILEGROUP;
// Create a table and wrap it in logical tiles
auto &txn_manager = concurrency::TransactionManager::GetInstance();
auto txn = txn_manager.BeginTransaction();
auto txn_id = txn->GetTransactionId();
std::unique_ptr<storage::DataTable> data_table(
ExecutorTestsUtil::CreateTable(tuple_count, false));
ExecutorTestsUtil::PopulateTable(txn, data_table.get(),
2 * tuple_count, false,
true, true);
txn_manager.CommitTransaction();
std::unique_ptr<executor::LogicalTile> source_logical_tile1(
executor::LogicalTileFactory::WrapTileGroup(data_table->GetTileGroup(0),
txn_id));
std::unique_ptr<executor::LogicalTile> source_logical_tile2(
executor::LogicalTileFactory::WrapTileGroup(data_table->GetTileGroup(1),
txn_id));
// (1-5) Setup plan node
// 1) Set up group-by columns
std::vector<oid_t> group_by_columns = {1};
// 2) Set up project info
planner::ProjectInfo::DirectMapList direct_map_list = {{0, {0, 1}},
{1, {1, 0}}};
auto proj_info = new planner::ProjectInfo(planner::ProjectInfo::TargetList(),
std::move(direct_map_list));
// 3) Set up unique aggregates
std::vector<planner::AggregatePlan::AggTerm> agg_terms;
planner::AggregatePlan::AggTerm sumC(EXPRESSION_TYPE_AGGREGATE_SUM,
expression::TupleValueFactory(0, 2));
agg_terms.push_back(sumC);
// 4) Set up predicate (empty)
expression::AbstractExpression* predicate = nullptr;
// 5) Create output table schema
auto data_table_schema = data_table.get()->GetSchema();
std::vector<oid_t> set = {1, 2};
std::vector<catalog::Column> columns;
for (auto column_index : set) {
columns.push_back(data_table_schema->GetColumn(column_index));
}
auto output_table_schema = new catalog::Schema(columns);
// OK) Create the plan node
planner::AggregatePlan node(proj_info, predicate, std::move(agg_terms),
std::move(group_by_columns), output_table_schema,
AGGREGATE_TYPE_HASH);
// Create and set up executor
auto txn2 = txn_manager.BeginTransaction();
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(txn2));
executor::AggregateExecutor executor(&node, context.get());
MockExecutor child_executor;
executor.AddChild(&child_executor);
EXPECT_CALL(child_executor, DInit()).WillOnce(Return(true));
EXPECT_CALL(child_executor, DExecute())
.WillOnce(Return(true))
.WillOnce(Return(true))
.WillOnce(Return(false));
EXPECT_CALL(child_executor, GetOutput())
.WillOnce(Return(source_logical_tile1.release()))
.WillOnce(Return(source_logical_tile2.release()));
EXPECT_TRUE(executor.Init());
EXPECT_TRUE(executor.Execute());
txn_manager.CommitTransaction();
/* Verify result */
std::unique_ptr<executor::LogicalTile> result_tile(executor.GetOutput());
/* FIXME This should pass */
// EXPECT_GE(3, result_tile->GetTupleCount());
// std::cout << *result_tile;
}
