/**
* @brief Create a physical tile
* @param
* @return Physical tile
*/
std::unique_ptr<storage::Tile> LogicalTile::Materialize() {
// Create new schema according underlying physical tile
std::unique_ptr<catalog::Schema> source_tile_schema(GetPhysicalSchema());
// Get the number of tuples within this logical tiles
const int num_tuples = GetTupleCount();
//const catalog::Schema *output_schema;
std::unordered_map<oid_t, oid_t> old_to_new_cols;
oid_t column_count = source_tile_schema->GetColumnCount();
for (oid_t col = 0; col < column_count; col++) {
old_to_new_cols[col] = col;
}
// Generate mappings.
std::unordered_map<storage::Tile *, std::vector<oid_t>> tile_to_cols;
GenerateTileToColMap(old_to_new_cols, tile_to_cols);
// Create new physical tile.
std::unique_ptr<storage::Tile> dest_tile(
storage::TileFactory::GetTempTile(*source_tile_schema, num_tuples));
// Proceed to materialize logical tile by physical tile at a time.
MaterializeByTiles(old_to_new_cols, tile_to_cols,
dest_tile.get());
// Wrap physical tile in logical tile.
return std::move(dest_tile);
}
/**
* @brief Create projected tuples based on one or two input.
* Newly-created physical tiles are needed.
*
* @return true on success, false otherwise.
*/
bool ProjectionExecutor::DExecute() {
PL_ASSERT(project_info_);
PL_ASSERT(schema_);
PL_ASSERT(children_.size() == 1);
// NOTE: We only handle 1 child for now
if (children_.size() == 1) {
LOG_TRACE("Projection : child 1 ");
// Execute child
auto status = children_[0]->Execute();
if (false == status) return false;
// Get input from child
std::unique_ptr<LogicalTile> source_tile(children_[0]->GetOutput());
auto num_tuples = source_tile->GetTupleCount();
// Create new physical tile where we store projected tuples
std::shared_ptr<storage::Tile> dest_tile(
storage::TileFactory::GetTempTile(*schema_, num_tuples));
// Create projections tuple-at-a-time from original tile
oid_t new_tuple_id = 0;
for (oid_t old_tuple_id : *source_tile) {
storage::Tuple *buffer = new storage::Tuple(schema_, true);
expression::ContainerTuple<LogicalTile> tuple(source_tile.get(),
old_tuple_id);
project_info_->Evaluate(buffer, &tuple, nullptr, executor_context_);
// Insert projected tuple into the new tile
dest_tile.get()->InsertTuple(new_tuple_id, buffer);
delete buffer;
new_tuple_id++;
}
// Wrap physical tile in logical tile and return it
SetOutput(LogicalTileFactory::WrapTiles({dest_tile}));
return true;
}
return false;
}
/**
* @brief Create a physical tile for the given logical tile
* @param source_tile Source tile from which the physical tile is created
* @return a logical tile wrapper for the created physical tile
*/
LogicalTile *MaterializationExecutor::Physify(LogicalTile *source_tile) {
std::unique_ptr<catalog::Schema> source_tile_schema(
source_tile->GetPhysicalSchema());
const int num_tuples = source_tile->GetTupleCount();
const catalog::Schema *output_schema;
std::unordered_map<oid_t, oid_t> old_to_new_cols;
auto node = GetRawNode();
// Create a default identity mapping node if we did not get one
if (node == nullptr) {
assert(source_tile_schema.get());
output_schema = source_tile_schema.get();
old_to_new_cols = BuildIdentityMapping(output_schema);
}
// Else use the mapping in the given plan node
else {
const planner::MaterializationPlan &node =
GetPlanNode<planner::MaterializationPlan>();
if (node.GetSchema()) {
output_schema = node.GetSchema();
old_to_new_cols = node.old_to_new_cols();
} else {
output_schema = source_tile_schema.get();
old_to_new_cols = BuildIdentityMapping(output_schema);
}
}
// Generate mappings.
std::unordered_map<storage::Tile *, std::vector<oid_t>> tile_to_cols;
GenerateTileToColMap(old_to_new_cols, source_tile, tile_to_cols);
// Create new physical tile.
std::shared_ptr<storage::Tile> dest_tile(
storage::TileFactory::GetTempTile(*output_schema, num_tuples));
// Proceed to materialize logical tile by physical tile at a time.
MaterializeByTiles(source_tile, old_to_new_cols, tile_to_cols,
dest_tile.get());
// Wrap physical tile in logical tile.
return LogicalTileFactory::WrapTiles({dest_tile});
}
