std::vector<catalog::Schema> Layout::GetLayoutSchemas(
catalog::Schema *const schema) const {
std::vector<catalog::Schema> schemas;
// Build the schema tile at a time
std::map<oid_t, std::vector<catalog::Column>> tile_schemas;
// Handle schemas population based on the layout type
if (layout_type_ == LayoutType::ROW) {
schemas.push_back(*schema);
} else if (layout_type_ == LayoutType::COLUMN) {
for (oid_t col_id = 0; col_id < num_columns_; col_id++) {
std::vector<catalog::Column> tile_schema({schema->GetColumn(col_id)});
schemas.push_back(tile_schema);
}
} else {
// For LayoutType::HYBRID, use the old technique.
// This only works if the order of columns in the tile are the same
// as the schema. This snipet was initially in abstract_table.cpp.
for (auto column_info : column_layout_) {
tile_schemas[column_info.second.first].push_back(
schema->GetColumn(column_info.first));
}
for (auto entry : tile_schemas) {
catalog::Schema tile_schema(entry.second);
schemas.push_back(tile_schema);
}
}
return schemas;
}
// Get the schema for the new transformed tile group
std::vector<catalog::Schema> TransformTileGroupSchema(
storage::TileGroup *tile_group, const column_map_type &column_map) {
std::vector<catalog::Schema> new_schema;
oid_t orig_tile_offset, orig_tile_column_offset;
oid_t new_tile_offset, new_tile_column_offset;
// First, get info from the original tile group's schema
std::map<oid_t, std::map<oid_t, catalog::Column>> schemas;
auto orig_schemas = tile_group->GetTileSchemas();
for (auto column_map_entry : column_map) {
new_tile_offset = column_map_entry.second.first;
new_tile_column_offset = column_map_entry.second.second;
oid_t column_offset = column_map_entry.first;
tile_group->LocateTileAndColumn(column_offset, orig_tile_offset,
orig_tile_column_offset);
// Get the column info from original schema
auto orig_schema = orig_schemas[orig_tile_offset];
auto column_info = orig_schema.GetColumn(orig_tile_column_offset);
schemas[new_tile_offset][new_tile_column_offset] = column_info;
}
// Then, build the new schema
for (auto schemas_tile_entry : schemas) {
std::vector<catalog::Column> columns;
for (auto schemas_column_entry : schemas_tile_entry.second)
columns.push_back(schemas_column_entry.second);
catalog::Schema tile_schema(columns);
new_schema.push_back(tile_schema);
}
return new_schema;
}
TileGroup *DataTable::GetTileGroupWithLayout(
const column_map_type &partitioning) {
std::vector<catalog::Schema> schemas;
oid_t tile_group_id = INVALID_OID;
tile_group_id = catalog::Manager::GetInstance().GetNextOid();
// Figure out the columns in each tile in new layout
std::map<std::pair<oid_t, oid_t>, oid_t> tile_column_map;
for (auto entry : partitioning) {
tile_column_map[entry.second] = entry.first;
}
// Build the schema tile at a time
std::map<oid_t, std::vector<catalog::Column>> tile_schemas;
for (auto entry : tile_column_map) {
tile_schemas[entry.first.first].push_back(schema->GetColumn(entry.second));
}
for (auto entry : tile_schemas) {
catalog::Schema tile_schema(entry.second);
schemas.push_back(tile_schema);
}
TileGroup *tile_group = TileGroupFactory::GetTileGroup(
database_oid, table_oid, tile_group_id, this, schemas, partitioning,
tuples_per_tilegroup_);
return tile_group;
}
