TEST_F(ReplaceTableTests, basic_replace_table_test) {
auto t1 = Loader::shortcuts::load("test/lin_xxs.tbl");
auto t2 = Loader::shortcuts::load("test/10_30_group.tbl");
auto sm = StorageManager::getInstance();
sm->loadTable("replaceMe", t1);
ASSERT_TABLE_EQUAL(t1, sm->getTable("replaceMe"));
ReplaceTable rt("replaceMe");
rt.addInput(t2);
rt.execute();
ASSERT_TABLE_EQUAL(t2, sm->getTable("replaceMe"));
}
TEST_F(GroupByTests, group_by_scan_with_count) {
hyrise::storage::atable_ptr_t t = Loader::shortcuts::load("test/10_30_group.tbl");
auto count = new CountAggregateFun(0);
hyrise::access::GroupByScan gs;
gs.addInput(t);
gs.addFunction(count);
gs.addField(0);
hyrise::access::HashBuild hs;
hs.addInput(t);
hs.addField(0);
hs.setKey("groupby");
auto group_map = hs.execute()->getResultHashTable();
gs.addInput(group_map);
const auto& result = gs.execute()->getResultTable();
const auto& reference = Loader::shortcuts::load("test/reference/group_by_scan_with_count.tbl");
SortScan so;
so.addInput(result);
so.setSortField(0);
const auto& r2 = so.execute()->getResultTable();
SortScan so2;
so2.addInput(reference);
so2.setSortField(0);
const auto& ref2 = so2.execute()->getResultTable();
ASSERT_TABLE_EQUAL(r2, ref2);
}
TEST_F(GroupByTests, group_by_scan_using_table_multiple_fields) {
auto t = io::Loader::shortcuts::load("test/10_30_group.tbl");
hyrise::access::GroupByScan gs;
gs.addInput(t);
gs.addField(0);
gs.addField(1);
hyrise::access::HashBuild hs;
hs.addInput(t);
hs.addField(0);
hs.addField(1);
hs.setKey("groupby");
auto group_map = hs.execute()->getResultHashTable();
gs.addInput(group_map);
const auto& result = gs.execute()->getResultTable();
SortScan so;
so.addInput(result);
so.setSortField(0);
const auto& r2 = so.execute()->getResultTable();
const auto& reference = io::Loader::shortcuts::load("test/reference/group_by_scan_using_table_multiple_fields.tbl");
SortScan so2;
so2.addInput(reference);
so2.setSortField(0);
const auto& ref2 = so2.execute()->getResultTable();
ASSERT_TABLE_EQUAL(r2, ref2);
}
TEST_F(GetTableTests, basic_get_table_test) {
io::StorageManager::getInstance()->loadTable("new_table", _table);
GetTable gt("new_table");
gt.execute();
const auto &result = gt.getResultTable();
ASSERT_TABLE_EQUAL(_table, result);
}
TEST_F(LoadFileTests, basic_load_file_test) {
auto t = io::Loader::shortcuts::load("test/tables/employees.tbl");
LoadFile lf("tables/employees.tbl");
lf.execute();
const auto &result = lf.getResultTable();
ASSERT_TABLE_EQUAL(result, t);
}
TEST_F(GroupByTests, group_by_scan_using_table_2) {
hyrise::storage::atable_ptr_t t = Loader::shortcuts::load("test/10_30_group.tbl");
{
auto gs = std::make_shared<hyrise::access::GroupByScan>();
gs->addInput(t);
gs->addField(0);
auto hs = std::make_shared<hyrise::access::HashBuild>();
hs->addInput(t);
hs->addField(0);
hs->setKey("groupby");
auto group_map = hs->execute()->getResultHashTable();
gs->addInput(group_map);
const auto& result = gs->execute()->getResultTable();
ASSERT_EQ(result->size(), t->size());
hyrise::access::GroupByScan gs2;
gs2.addInput(t);
gs2.addField(1);
hyrise::access::HashBuild hs2;
hs2.addInput(t);
hs2.addField(1);
hs2.setKey("groupby");
auto group_map2 = hs2.execute()->getResultHashTable();
gs2.addInput(group_map2);
const auto& result2 = gs2.execute()->getResultTable();
SortScan s;
s.addInput(result2);
s.setSortField(0);
const auto& r2 = s.execute()->getResultTable();
hyrise::storage::atable_ptr_t reference = Loader::shortcuts::load("test/reference/group_by_scan_using_table_2.tbl");
SortScan s2;
s2.addInput(reference);
s2.setSortField(0);
const auto& ref2 = s2.execute()->getResultTable();
ASSERT_TABLE_EQUAL(r2, ref2);
}
ASSERT_EQ(1u, t.use_count());
}
TEST_F(GetLastRecordsTests, get_last_records_empty_table_test) {
auto t = io::Loader::shortcuts::load("test/empty.tbl");
GetLastRecords gs;
gs.addInput(t);
gs._records = 2;
gs.execute();
const auto& result = gs.getResultTable();
ASSERT_TABLE_EQUAL(t, result);
}
TEST_F(GetLastRecordsTests, basic_get_last_records_test) {
auto t = io::Loader::shortcuts::load("test/tables/companies.tbl");
auto reference = io::Loader::shortcuts::load("test/tables/companies_last2.tbl");
GetLastRecords gs;
gs.addInput(t);
gs._records = 2;
gs.execute();
const auto& result = gs.getResultTable();
ASSERT_TABLE_EQUAL(reference, result);
}
TEST_F(SelectTests, simple_select_with_raw_table_greater_than_predicate) {
auto t = createRawTable();
auto expr1 = new GreaterThanExpressionRaw<hyrise_int_t>(t, 0, 98);
auto scan = std::make_shared<SimpleRawTableScan>(expr1);
scan->addInput(t);
scan->execute();
const auto& out = scan->getResultTable();
const auto& reference = Loader::shortcuts::load("test/reference/simple_raw_select_integer_greater_than.tbl");
ASSERT_TABLE_EQUAL(reference, out);
}
TEST_F(GroupByTests, group_by_scan_with_sum) {
hyrise::storage::atable_ptr_t t = Loader::shortcuts::load("test/10_30_group.tbl");
hyrise::access::GroupByScan gs;
auto count = new SumAggregateFun(0);
gs.addInput(t);
gs.addFunction(count);
const auto& result = gs.execute()->getResultTable();
const auto& reference = Loader::shortcuts::load("test/reference/group_by_scan_with_sum.tbl");
ASSERT_TABLE_EQUAL(result, reference);
}
TEST_F(SelectTests, simple_select_with_raw_table_equals_predicate) {
hyrise::storage::c_atable_ptr_t t = createRawTable();
auto expr1 = new EqualsExpressionRaw<hyrise_int_t>(t, 0, 75);
auto scan = std::make_shared<SimpleRawTableScan>(expr1);
scan->addInput(t);
scan->execute();
ASSERT_EQ(1u, scan->getResultTable(0)->size());
const auto& out = scan->getResultTable();
const auto& reference = Loader::shortcuts::load("test/reference/simple_raw_select_integer.tbl");
ASSERT_TABLE_EQUAL(reference, out);
}
TEST_F(CompoundIndexScanTests, two_ints) {
auto reference = io::Loader::shortcuts::load("test/reference/index_aware_test_result.tbl");
CompoundIndexScan is;
is.addInput(t);
is.setMainIndex("test_main_idx_0_and_3");
is.setDeltaIndex("test_delta_idx_0_and_3");
is.addPredicate(0, (hyrise_int_t)200);
is.addPredicate(3, (hyrise_int_t)203);
is.execute();
auto result = is.getResultTable();
ASSERT_TABLE_EQUAL(result, reference);
}
TEST_F(JSONTests, parse_papi_event_set) {
StorageManager::getInstance()->loadTableFile("lin_xxs", "lin_xxs.tbl");
StorageManager::getInstance()->loadTableFile("lin_xxs_comp", "reference/simple_projection.tbl");
std::string q = loadFromFile("test/json/simple_query_with_papi.json");
std::string papi;
const auto& out = executeAndWait(q, 1, &papi);
ASSERT_FALSE(!out);
ASSERT_TABLE_EQUAL(out, StorageManager::getInstance()->getTable("lin_xxs_comp"));
ASSERT_EQ("PAPI_L2_DCM", papi);
StorageManager::getInstance()->removeAll();
}
TEST_F(SelectTests, simple_select_with_raw_table_equals_predicate_string) {
auto t = createRawTable();
auto expr1 = new EqualsExpressionRaw<hyrise_string_t>(t, 1, "MeinNameIstSlimShady75");
auto scan = std::make_shared<SimpleRawTableScan>(expr1);
scan->addInput(t);
scan->execute();
ASSERT_EQ(1u, scan->getResultTable(0)->size());
const auto& out = scan->getResultTable();
const auto& reference = Loader::shortcuts::load("test/reference/simple_raw_select_integer.tbl");
ASSERT_TABLE_EQUAL(reference, out);
}
TEST_F(IndexScanTests, basic_index_scan_test) {
auto reference = io::Loader::shortcuts::load("test/reference/index_test_result.tbl");
IndexScan is;
is.addInput(t);
is.addField(0);
is.setIndexName("my_index");
is.setValue<hyrise_int_t>(200);
is.execute();
auto result = is.getResultTable();
ASSERT_TABLE_EQUAL(result, reference);
}
TEST_F(MergeTableOpTests, simple) {
LoadFile t1("tables/employees.tbl");
auto load_main = t1.execute()->getResultTable();
LoadFile t2("tables/employees_new_row.tbl");
auto load_delta = t2.execute()->getResultTable();
MergeTable mop;
mop.addInput(load_main);
mop.addInput(load_delta);
auto result = mop.execute()->getResultTable();
ASSERT_TABLE_EQUAL(Loader::shortcuts::load("test/tables/employees_revised.tbl"), result);
}
TEST_F(SmallestTableScanTests, basic_smallest_table_scan_test) {
auto t1 = Loader::shortcuts::load("test/10_30_group.tbl");
auto t2 = Loader::shortcuts::load("test/lin_xxs.tbl");
auto t3 = Loader::shortcuts::load("test/lin_xxxs.tbl");
SmallestTableScan stc;
stc.addInput(t1);
stc.addInput(t2);
stc.addInput(t3);
stc.execute();
const auto &result = stc.getResultTable();
ASSERT_TABLE_EQUAL(result, t3);
}
TEST_F(CompoundIndexScanTests, two_ints_validation_nonunique) {
auto reference = io::Loader::shortcuts::load("test/reference/index_aware_test_result.tbl");
auto index_ctx = tx::TransactionManager::getInstance().buildContext();
CompoundIndexScan is;
is.addInput(t);
is.setTXContext(index_ctx);
is.setValidation(true);
is.setMainIndex("test_main_idx_0_and_3");
is.setDeltaIndex("test_delta_idx_0_and_3");
is.addPredicate(0, (hyrise_int_t)200);
is.addPredicate(3, (hyrise_int_t)203);
is.execute();
auto result = is.getResultTable();
ASSERT_TABLE_EQUAL(result, reference);
}
TEST_F(MergeTableTests, basic_merge_table_test) {
auto s = io::Loader::shortcuts::loadMainDelta("test/merge1_main.tbl", "test/merge1_delta.tbl");
auto reference = io::Loader::shortcuts::load("test/merge1_result.tbl");
ASSERT_EQ(4u, s->getMainTable()->size());
ASSERT_EQ(5u, s->getDeltaTable()->size());
MergeTable mt;
mt.addInput(s);
mt.execute();
const auto& result = mt.getResultTable();
ASSERT_EQ(9u, result->size());
ASSERT_TABLE_EQUAL(result, reference);
}
TEST_F(CompoundIndexRangeScanTests, simplePredicate) {
auto reference = io::Loader::shortcuts::load("test/reference/range_index_test_result.tbl");
auto index_ctx = tx::TransactionManager::getInstance().buildContext();
CompoundIndexRangeScan is;
is.addInput(t);
is.setTXContext(index_ctx);
is.setValidation(true);
is.setMainIndex("test_main_idx_0_2_3");
is.setDeltaIndex("test_delta_idx_0_2_3");
is.addPredicate("col_0", (hyrise_int_t)10);
is.execute();
auto result = is.getResultTable();
ASSERT_TABLE_EQUAL(result, reference);
}
TEST_F(JoinScanTests, basic_join_scan_test) {
auto t1 = io::Loader::shortcuts::load("test/join_transactions.tbl");
auto t2 = io::Loader::shortcuts::load("test/join_exchange.tbl");
auto reference = io::Loader::shortcuts::load("test/reference/join_result.tbl");
JoinScan js(JoinType::EQUI);
js.addInput(t1);
js.addInput(t2);
js.addCombiningClause(AND);
js.addJoinClause<int>(0,0,1,0);
js.addJoinClause<std::string>(0,1,1,1);
js.execute();
const auto &result = js.getResultTable();
ASSERT_TABLE_EQUAL(result, reference);
}
TEST_F(SelectTests, simple_projection_with_position_mat_memcpy) {
auto t = Loader::shortcuts::load("test/lin_xxs.tbl");
ProjectionScan gs;
gs.setProducesPositions(true);
gs.addInput(t);
gs.addField(0);
ASSERT_EQ((unsigned) 10, t->columnCount());
auto result = gs.execute()->getResultTable();
MaterializingScan ms(true);
ms.addInput(result);
const auto& result2 = ms.execute()->getResultTable();
ASSERT_EQ((unsigned) 100, result2->size());
const auto& reference = Loader::shortcuts::load("test/reference/simple_projection.tbl");
ASSERT_TABLE_EQUAL(reference, result2);
}
TEST_F(CompoundIndexScanTests, two_ints_validation_unique) {
auto reference = io::Loader::shortcuts::load("test/reference/index_aware_test_result_unique.tbl");
auto index_ctx = tx::TransactionManager::getInstance().buildContext();
CompoundIndexScan is;
is.addInput(t);
is.setTXContext(index_ctx);
is.setValidation(true);
is.setUniqueIndex(true); // allow index scan to get out once the first valid entry is found.
is.setMainIndex("test_main_idx_0_and_3");
is.setDeltaIndex("test_delta_idx_0_and_3");
// 123 _ _ 123 is one hit in delta
is.addPredicate(0, (hyrise_int_t)123);
is.addPredicate(3, (hyrise_int_t)123);
is.execute();
auto result = is.getResultTable();
ASSERT_TABLE_EQUAL(result, reference);
}
TEST_F(PersistTableTests, basic_persist_and_restore_test) {
const std::string tableName = "PersistTableTestTable";
auto* sm = io::StorageManager::getInstance();
auto t = io::Loader::shortcuts::load("test/lin_xxs.tbl");
sm->loadTable(tableName, t);
PersistTable pt;
pt.setTableName(tableName);
pt.execute();
sm->removeTable(tableName);
ASSERT_FALSE(sm->exists(tableName));
RecoverTable rt;
rt.setTableName(tableName);
rt.execute();
ASSERT_TRUE(sm->exists(tableName));
ASSERT_TABLE_EQUAL(t, sm->getTable(tableName));
}
TEST_F(GroupByTests, group_by_scan_with_avg_on_float) {
hyrise::storage::atable_ptr_t t = Loader::shortcuts::load("test/tables/revenue_float.tbl");
hyrise::access::GroupByScan gs;
auto average = new AverageAggregateFun("amount");
gs.addInput(t);
gs.addField("year");
gs.addFunction(average);
hyrise::access::HashBuild hs;
hs.addInput(t);
hs.addField("year");
hs.setKey("groupby");
auto group_map = hs.execute()->getResultHashTable();
gs.addInput(group_map);
const auto& result = sort(gs.execute()->getResultTable());
const auto& reference = Loader::shortcuts::load("test/tables/revenue_average_per_year.tbl");
ASSERT_TABLE_EQUAL(result, reference);
}
