TEST_F(LogicalTileTests, TempTableTest) {
const int tuple_count = TESTS_TUPLES_PER_TILEGROUP;
auto pool = TestingHarness::GetInstance().GetTestingPool();
catalog::Schema *schema = new catalog::Schema(
{ExecutorTestsUtil::GetColumnInfo(0), ExecutorTestsUtil::GetColumnInfo(1),
ExecutorTestsUtil::GetColumnInfo(2)});
// Create our TempTable
storage::TempTable table(INVALID_OID, schema, true);
EXPECT_EQ(0, table.GetTupleCount());
// Then shove some tuples in it
for (int i = 0; i < tuple_count; i++) {
storage::Tuple *tuple = new storage::Tuple(table.GetSchema(), true);
auto val1 = type::ValueFactory::GetIntegerValue(
ExecutorTestsUtil::PopulatedValue(i, 0));
auto val2 = type::ValueFactory::GetIntegerValue(
ExecutorTestsUtil::PopulatedValue(i, 1));
auto val3 = type::ValueFactory::GetDoubleValue(
ExecutorTestsUtil::PopulatedValue(i, 2));
tuple->SetValue(0, val1, pool);
tuple->SetValue(1, val2, pool);
tuple->SetValue(2, val3, pool);
table.InsertTuple(tuple);
delete tuple;
}
LOG_INFO("%s", table.GetInfo().c_str());
LOG_INFO("%s", GETINFO_SINGLE_LINE.c_str());
// Check to see whether we can wrap a LogicalTile around it
auto tile_group_count = table.GetTileGroupCount();
std::vector<executor::LogicalTile *> logicalTiles;
for (oid_t tile_group_itr = 0; tile_group_itr < tile_group_count;
tile_group_itr++) {
auto tile_group = table.GetTileGroup(tile_group_itr);
EXPECT_NE(nullptr, tile_group);
auto logical_tile = executor::LogicalTileFactory::WrapTileGroup(tile_group);
EXPECT_NE(nullptr, logical_tile);
logicalTiles.push_back(logical_tile);
// Make sure that we can iterate over the LogicalTile and get
// at our TempTable tuples
EXPECT_NE(0, logical_tile->GetTupleCount());
LOG_INFO("GetActiveTupleCount() = %d",
(int)tile_group->GetActiveTupleCount());
LOG_INFO("%s", tile_group->GetInfo().c_str());
LOG_INFO("*****************************************");
LOG_INFO("%s", logical_tile->GetInfo().c_str());
}
EXPECT_FALSE(logicalTiles.empty());
for (executor::LogicalTile *lt : logicalTiles) {
delete lt;
}
}
oid_t DataTable::GetAllActiveTupleCount() {
oid_t count = 0;
for (auto tile_group_id : tile_groups_) {
auto tile_group = GetTileGroupById(tile_group_id);
auto tile_group_header = tile_group->GetHeader();
count += tile_group_header->GetActiveTupleCount();
}
return count;
}
oid_t GetTotalTupleCount(size_t table_tile_group_count, cid_t next_cid) {
auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
txn_manager.SetNextCid(next_cid);
txn_manager.BeginTransaction();
auto &catalog_manager = catalog::Manager::GetInstance();
oid_t total_tuple_count = 0;
for (size_t tile_group_id = 1; tile_group_id <= table_tile_group_count;
tile_group_id++) {
auto tile_group = catalog_manager.GetTileGroup(tile_group_id);
total_tuple_count += tile_group->GetActiveTupleCount();
}
txn_manager.CommitTransaction();
return total_tuple_count;
}
void CheckTupleCount(oid_t db_oid, oid_t table_oid, oid_t expected) {
auto& manager = catalog::Manager::GetInstance();
storage::Database* db = manager.GetDatabaseWithOid(db_oid);
auto table = db->GetTableWithOid(table_oid);
oid_t tile_group_count = table->GetTileGroupCount();
oid_t active_tuple_count = 0;
for (oid_t tile_group_itr = 0; tile_group_itr < tile_group_count;
tile_group_itr++) {
auto tile_group = table->GetTileGroup(tile_group_itr);
active_tuple_count += tile_group->GetActiveTupleCount(INVALID_TXN_ID);
}
// check # of active tuples
if (expected != active_tuple_count) {
throw Exception("Tuple count does not match \n");
}
}
