oid_t DataTable::AddDefaultTileGroup(const size_t &active_tile_group_id) {
column_map_type column_map;
oid_t tile_group_id = INVALID_OID;
// Figure out the partitioning for given tilegroup layout
column_map = GetTileGroupLayout((LayoutType)peloton_layout_mode);
// Create a tile group with that partitioning
std::shared_ptr<TileGroup> tile_group(GetTileGroupWithLayout(column_map));
PL_ASSERT(tile_group.get());
tile_group_id = tile_group->GetTileGroupId();
LOG_TRACE("Added a tile group ");
tile_groups_.Append(tile_group_id);
// add tile group metadata in locator
catalog::Manager::GetInstance().AddTileGroup(tile_group_id, tile_group);
COMPILER_MEMORY_FENCE;
active_tile_groups_[active_tile_group_id] = tile_group;
// we must guarantee that the compiler always add tile group before adding
// tile_group_count_.
COMPILER_MEMORY_FENCE;
tile_group_count_++;
LOG_TRACE("Recording tile group : %u ", tile_group_id);
return tile_group_id;
}
oid_t DataTable::AddDefaultTileGroup() {
column_map_type column_map;
oid_t tile_group_id = INVALID_OID;
// Figure out the partitioning for given tilegroup layout
column_map = GetTileGroupLayout((LayoutType)peloton_layout_mode);
// Create a tile group with that partitioning
std::shared_ptr<TileGroup> tile_group(GetTileGroupWithLayout(column_map));
assert(tile_group.get());
tile_group_id = tile_group->GetTileGroupId();
LOG_TRACE("Trying to add a tile group ");
{
LOG_TRACE("Added a tile group ");
tile_group_lock_.WriteLock();
tile_groups_.push_back(tile_group_id);
tile_group_lock_.Unlock();
// add tile group metadata in locator
catalog::Manager::GetInstance().AddTileGroup(tile_group_id, tile_group);
// we must guarantee that the compiler always add tile group before adding
// tile_group_count_.
COMPILER_MEMORY_FENCE;
tile_group_count_++;
LOG_TRACE("Recording tile group : %u ", tile_group_id);
}
return tile_group_id;
}
void AddTileGroup(UNUSED_ATTRIBUTE uint64_t thread_id) {
// TILES
std::vector<std::string> tile_column_names;
std::vector<std::vector<std::string>> column_names;
tile_column_names.push_back("INTEGER COL");
column_names.push_back(tile_column_names);
std::vector<catalog::Schema> schemas;
std::vector<catalog::Column> columns;
// SCHEMA
catalog::Column column1(type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER),
"A", true);
columns.push_back(column1);
std::unique_ptr<catalog::Schema> schema1(new catalog::Schema(columns));
schemas.push_back(*schema1);
std::map<oid_t, std::pair<oid_t, oid_t>> column_map;
column_map[0] = std::make_pair(0, 0);
for (oid_t txn_itr = 0; txn_itr < 100; txn_itr++) {
std::unique_ptr<storage::TileGroup> tile_group(storage::TileGroupFactory::GetTileGroup(
INVALID_OID, INVALID_OID, INVALID_OID, nullptr, schemas, column_map, 3));
}
}
// "Pass-through" test case. There is nothing to materialize as
// there is only one base tile in the logical tile.
TEST_F(MaterializationTests, SingleBaseTileTest) {
const int tuple_count = 9;
std::shared_ptr<storage::TileGroup> tile_group(
ExecutorTestsUtil::CreateTileGroup(tuple_count));
ExecutorTestsUtil::PopulateTiles(tile_group, tuple_count);
// Create logical tile from single base tile.
auto source_base_tile = tile_group->GetTileReference(0);
// Add a reference because we are going to wrap around it and we don't own it
std::unique_ptr<executor::LogicalTile> source_logical_tile(
executor::LogicalTileFactory::WrapTiles({source_base_tile}));
// Pass through materialization executor.
executor::MaterializationExecutor executor(nullptr, nullptr);
std::unique_ptr<executor::LogicalTile> result_logical_tile(
ExecutorTestsUtil::ExecuteTile(&executor, source_logical_tile.release()));
// Verify that logical tile is only made up of a single base tile.
int num_cols = result_logical_tile->GetColumnCount();
EXPECT_EQ(2, num_cols);
storage::Tile *result_base_tile = result_logical_tile->GetBaseTile(0);
EXPECT_THAT(result_base_tile, NotNull());
EXPECT_TRUE(source_base_tile.get() == result_base_tile);
EXPECT_EQ(result_logical_tile->GetBaseTile(1), result_base_tile);
// Check that the base tile has the correct values.
for (int i = 0; i < tuple_count; i++) {
type::Value val0 = (result_base_tile->GetValue(i, 0));
type::Value val1 = (result_base_tile->GetValue(i, 1));
type::CmpBool cmp = (val0.CompareEquals(
type::ValueFactory::GetIntegerValue(ExecutorTestsUtil::PopulatedValue(i, 0))));
EXPECT_TRUE(cmp == type::CMP_TRUE);
cmp = val1.CompareEquals(type::ValueFactory::GetIntegerValue(
ExecutorTestsUtil::PopulatedValue(i, 1)));
EXPECT_TRUE(cmp == type::CMP_TRUE);
// Double check that logical tile is functioning.
type::Value logic_val0 = (result_logical_tile->GetValue(i, 0));
type::Value logic_val1 = (result_logical_tile->GetValue(i, 1));
cmp = (logic_val0.CompareEquals(val0));
EXPECT_TRUE(cmp == type::CMP_TRUE);
cmp = (logic_val1.CompareEquals(val1));
EXPECT_TRUE(cmp == type::CMP_TRUE);
}
}
void DataTable::AddTileGroupWithOidForRecovery(const oid_t &tile_group_id) {
assert(tile_group_id);
std::vector<catalog::Schema> schemas;
schemas.push_back(*schema);
column_map_type column_map;
// default column map
auto col_count = schema->GetColumnCount();
for (oid_t col_itr = 0; col_itr < col_count; col_itr++) {
column_map[col_itr] = std::make_pair(0, col_itr);
}
std::shared_ptr<TileGroup> tile_group(TileGroupFactory::GetTileGroup(
database_oid, table_oid, tile_group_id, this, schemas, column_map,
tuples_per_tilegroup_));
tile_group_lock_.WriteLock();
if (std::find(tile_groups_.begin(), tile_groups_.end(),
tile_group->GetTileGroupId()) == tile_groups_.end()) {
tile_groups_.push_back(tile_group->GetTileGroupId());
LOG_TRACE("Added a tile group ");
// add tile group metadata in locator
catalog::Manager::GetInstance().AddTileGroup(tile_group_id, tile_group);
// we must guarantee that the compiler always add tile group before adding
// tile_group_count_.
COMPILER_MEMORY_FENCE;
tile_group_count_++;
LOG_TRACE("Recording tile group : %u ", tile_group_id);
}
tile_group_lock_.Unlock();
}
TEST_F(LogicalTileTests, TileMaterializationTest) {
const int tuple_count = 4;
std::shared_ptr<storage::TileGroup> tile_group(
ExecutorTestsUtil::CreateTileGroup(tuple_count));
// Create tuple schema from tile schemas.
std::vector<catalog::Schema> &tile_schemas = tile_group->GetTileSchemas();
std::unique_ptr<catalog::Schema> schema(
catalog::Schema::AppendSchemaList(tile_schemas));
// Create tuples and insert them into tile group.
const bool allocate = true;
storage::Tuple tuple1(schema.get(), allocate);
storage::Tuple tuple2(schema.get(), allocate);
auto pool = tile_group->GetTilePool(1);
tuple1.SetValue(0, ValueFactory::GetIntegerValue(1), pool);
tuple1.SetValue(1, ValueFactory::GetIntegerValue(1), pool);
tuple1.SetValue(2, ValueFactory::GetTinyIntValue(1), pool);
tuple1.SetValue(3, ValueFactory::GetStringValue("tuple 1"), pool);
tuple2.SetValue(0, ValueFactory::GetIntegerValue(2), pool);
tuple2.SetValue(1, ValueFactory::GetIntegerValue(2), pool);
tuple2.SetValue(2, ValueFactory::GetTinyIntValue(2), pool);
tuple2.SetValue(3, ValueFactory::GetStringValue("tuple 2"), pool);
auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
txn_manager.BeginTransaction();
// txn_id_t txn_id = txn->GetTransactionId();
auto tuple_id1 = tile_group->InsertTuple(&tuple1);
auto tuple_id2 = tile_group->InsertTuple(&tuple2);
auto tuple_id3 = tile_group->InsertTuple(&tuple1);
txn_manager.PerformInsert(ItemPointer(tile_group->GetTileGroupId(), tuple_id1));
txn_manager.PerformInsert(ItemPointer(tile_group->GetTileGroupId(), tuple_id2));
txn_manager.PerformInsert(ItemPointer(tile_group->GetTileGroupId(), tuple_id3));
txn_manager.CommitTransaction();
////////////////////////////////////////////////////////////////
// LOGICAL TILE (1 BASE TILE)
////////////////////////////////////////////////////////////////
// Don't transfer ownership of any base tile to logical tile.
auto base_tile_ref = tile_group->GetTileReference(1);
std::vector<oid_t> position_list1 = {0, 1};
std::vector<oid_t> position_list2 = {0, 1};
std::unique_ptr<executor::LogicalTile> logical_tile(
executor::LogicalTileFactory::GetTile());
logical_tile->AddPositionList(std::move(position_list1));
logical_tile->AddPositionList(std::move(position_list2));
assert(tile_schemas.size() == 2);
catalog::Schema *schema1 = &tile_schemas[0];
catalog::Schema *schema2 = &tile_schemas[1];
oid_t column_count = schema2->GetColumnCount();
for (oid_t column_itr = 0; column_itr < column_count; column_itr++) {
logical_tile->AddColumn(base_tile_ref, column_itr, column_itr);
}
LOG_INFO("%s", logical_tile->GetInfo().c_str());
////////////////////////////////////////////////////////////////
// LOGICAL TILE (2 BASE TILE)
////////////////////////////////////////////////////////////////
logical_tile.reset(executor::LogicalTileFactory::GetTile());
auto base_tile_ref1 = tile_group->GetTileReference(0);
auto base_tile_ref2 = tile_group->GetTileReference(1);
position_list1 = {0, 1};
position_list2 = {0, 1};
std::vector<oid_t> position_list3 = {0, 1};
std::vector<oid_t> position_list4 = {0, 1};
logical_tile->AddPositionList(std::move(position_list1));
logical_tile->AddPositionList(std::move(position_list2));
logical_tile->AddPositionList(std::move(position_list3));
logical_tile->AddPositionList(std::move(position_list4));
oid_t column_count1 = schema1->GetColumnCount();
for (oid_t column_itr = 0; column_itr < column_count1; column_itr++) {
logical_tile->AddColumn(base_tile_ref1, column_itr, column_itr);
}
oid_t column_count2 = schema2->GetColumnCount();
for (oid_t column_itr = 0; column_itr < column_count2; column_itr++) {
logical_tile->AddColumn(base_tile_ref2, column_itr,
column_count1 + column_itr);
}
LOG_INFO("%s", logical_tile->GetInfo().c_str());
}
// Materializing logical tile composed of two base tiles.
// The materialized tile's output columns are reordered.
// Also, one of the columns is dropped.
TEST_F(MaterializationTests, TwoBaseTilesWithReorderTest) {
const int tuple_count = 9;
std::shared_ptr<storage::TileGroup> tile_group(
ExecutorTestsUtil::CreateTileGroup(tuple_count));
ExecutorTestsUtil::PopulateTiles(tile_group, tuple_count);
// Create logical tile from two base tiles.
const std::vector<std::shared_ptr<storage::Tile> > source_base_tiles = {
tile_group->GetTileReference(0), tile_group->GetTileReference(1)};
// Add a reference because we are going to wrap around it and we don't own it
std::unique_ptr<executor::LogicalTile> source_logical_tile(
executor::LogicalTileFactory::WrapTiles(source_base_tiles));
// Create materialization node for this test.
// Construct output schema. We drop column 3 and reorder the others to 3,1,0.
std::vector<catalog::Column> output_columns;
// Note that Column 3 in the tile group is column 1 in the second tile.
output_columns.push_back(source_base_tiles[1]->GetSchema()->GetColumn(1));
output_columns.push_back(source_base_tiles[0]->GetSchema()->GetColumn(1));
output_columns.push_back(source_base_tiles[0]->GetSchema()->GetColumn(0));
std::unique_ptr<catalog::Schema> output_schema(
new catalog::Schema(output_columns));
// Construct mapping using the ordering mentioned above.
std::unordered_map<oid_t, oid_t> old_to_new_cols;
old_to_new_cols[3] = 0;
old_to_new_cols[1] = 1;
old_to_new_cols[0] = 2;
bool physify_flag = true; // is going to create a physical tile
planner::MaterializationPlan node(old_to_new_cols, output_schema.release(),
physify_flag);
// Pass through materialization executor.
executor::MaterializationExecutor executor(&node, nullptr);
std::unique_ptr<executor::LogicalTile> result_logical_tile(
ExecutorTestsUtil::ExecuteTile(&executor, source_logical_tile.release()));
// Verify that logical tile is only made up of a single base tile.
int num_cols = result_logical_tile->GetColumnCount();
EXPECT_EQ(3, num_cols);
storage::Tile *result_base_tile = result_logical_tile->GetBaseTile(0);
EXPECT_THAT(result_base_tile, NotNull());
EXPECT_EQ(result_base_tile, result_logical_tile->GetBaseTile(1));
EXPECT_EQ(result_base_tile, result_logical_tile->GetBaseTile(2));
// Check that the base tile has the correct values.
for (int i = 0; i < tuple_count; i++) {
// Output column 2.
EXPECT_EQ(
ValueFactory::GetIntegerValue(ExecutorTestsUtil::PopulatedValue(i, 0)),
result_base_tile->GetValue(i, 2));
// Output column 1.
EXPECT_EQ(
ValueFactory::GetIntegerValue(ExecutorTestsUtil::PopulatedValue(i, 1)),
result_base_tile->GetValue(i, 1));
// Output column 0.
Value string_value(ValueFactory::GetStringValue(
std::to_string(ExecutorTestsUtil::PopulatedValue(i, 3))));
EXPECT_EQ(string_value, result_base_tile->GetValue(i, 0));
// Double check that logical tile is functioning.
EXPECT_EQ(result_base_tile->GetValue(i, 0),
result_logical_tile->GetValue(i, 0));
EXPECT_EQ(result_base_tile->GetValue(i, 1),
result_logical_tile->GetValue(i, 1));
EXPECT_EQ(result_base_tile->GetValue(i, 2),
result_logical_tile->GetValue(i, 2));
}
}
TEST_F(LogicalTileTests, TileMaterializationTest) {
const int tuple_count = 4;
std::shared_ptr<storage::TileGroup> tile_group(
TestingExecutorUtil::CreateTileGroup(tuple_count));
std::vector<const catalog::Schema *> tile_schemas;
for (unsigned int i = 0; i < tile_group->NumTiles(); i++) {
tile_schemas.push_back(tile_group->GetTile(i)->GetSchema());
}
// Create tuple schema from tile schemas.
std::unique_ptr<catalog::Schema> schema(
catalog::Schema::AppendSchemaPtrList(tile_schemas));
// Create tuples and insert them into tile group.
const bool allocate = true;
storage::Tuple tuple1(schema.get(), allocate);
storage::Tuple tuple2(schema.get(), allocate);
auto pool = tile_group->GetTilePool(1);
tuple1.SetValue(0, type::ValueFactory::GetIntegerValue(1), pool);
tuple1.SetValue(1, type::ValueFactory::GetIntegerValue(1), pool);
tuple1.SetValue(2, type::ValueFactory::GetTinyIntValue(1), pool);
tuple1.SetValue(3, type::ValueFactory::GetVarcharValue("tuple 1"), pool);
tuple2.SetValue(0, type::ValueFactory::GetIntegerValue(2), pool);
tuple2.SetValue(1, type::ValueFactory::GetIntegerValue(2), pool);
tuple2.SetValue(2, type::ValueFactory::GetTinyIntValue(2), pool);
tuple2.SetValue(3, type::ValueFactory::GetVarcharValue("tuple 2"), pool);
auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
auto txn = txn_manager.BeginTransaction();
// txn_id_t txn_id = txn->GetTransactionId();
auto tuple_id1 = tile_group->InsertTuple(&tuple1);
auto tuple_id2 = tile_group->InsertTuple(&tuple2);
auto tuple_id3 = tile_group->InsertTuple(&tuple1);
ItemPointer *index_entry_ptr = nullptr;
txn_manager.PerformInsert(
txn, ItemPointer(tile_group->GetTileGroupId(), tuple_id1),
index_entry_ptr);
txn_manager.PerformInsert(
txn, ItemPointer(tile_group->GetTileGroupId(), tuple_id2),
index_entry_ptr);
txn_manager.PerformInsert(
txn, ItemPointer(tile_group->GetTileGroupId(), tuple_id3),
index_entry_ptr);
txn_manager.CommitTransaction(txn);
////////////////////////////////////////////////////////////////
// LOGICAL TILE (1 BASE TILE)
////////////////////////////////////////////////////////////////
// Don't transfer ownership of any base tile to logical tile.
auto base_tile_ref = tile_group->GetTileReference(1);
std::vector<oid_t> position_list1 = {0, 1};
std::vector<oid_t> position_list2 = {0, 1};
std::unique_ptr<executor::LogicalTile> logical_tile(
executor::LogicalTileFactory::GetTile());
logical_tile->AddPositionList(std::move(position_list1));
logical_tile->AddPositionList(std::move(position_list2));
oid_t column_count = tile_schemas[1]->GetColumnCount();
for (oid_t column_itr = 0; column_itr < column_count; column_itr++) {
logical_tile->AddColumn(base_tile_ref, column_itr, column_itr);
}
LOG_TRACE("%s", logical_tile->GetInfo().c_str());
////////////////////////////////////////////////////////////////
// LOGICAL TILE (2 BASE TILE)
////////////////////////////////////////////////////////////////
logical_tile.reset(executor::LogicalTileFactory::GetTile());
auto base_tile_ref1 = tile_group->GetTileReference(0);
auto base_tile_ref2 = tile_group->GetTileReference(1);
position_list1 = {0, 1};
position_list2 = {0, 1};
std::vector<oid_t> position_list3 = {0, 1};
std::vector<oid_t> position_list4 = {0, 1};
logical_tile->AddPositionList(std::move(position_list1));
logical_tile->AddPositionList(std::move(position_list2));
logical_tile->AddPositionList(std::move(position_list3));
logical_tile->AddPositionList(std::move(position_list4));
oid_t column_count1 = tile_schemas[0]->GetColumnCount();
for (oid_t column_itr = 0; column_itr < column_count1; column_itr++) {
logical_tile->AddColumn(base_tile_ref1, column_itr, column_itr);
}
oid_t column_count2 = tile_schemas[1]->GetColumnCount();
for (oid_t column_itr = 0; column_itr < column_count2; column_itr++) {
logical_tile->AddColumn(base_tile_ref2, column_itr,
column_count1 + column_itr);
}
LOG_TRACE("%s", logical_tile->GetInfo().c_str());
}
