/**
* @ brief Build the joined tile with schema derived from children tiles
*/
std::unique_ptr<LogicalTile> AbstractJoinExecutor::BuildOutputLogicalTile(
LogicalTile *left_tile, LogicalTile *right_tile) {
// Check the input logical tiles.
PL_ASSERT(left_tile != nullptr);
PL_ASSERT(right_tile != nullptr);
// Construct output logical tile.
std::unique_ptr<LogicalTile> output_tile(LogicalTileFactory::GetTile());
auto left_tile_schema = left_tile->GetSchema();
auto right_tile_schema = right_tile->GetSchema();
// advance the position list index of right tile schema
for (auto &col : right_tile_schema) {
col.position_list_idx += left_tile->GetPositionLists().size();
}
/* build the schema given the projection */
auto output_tile_schema = BuildSchema(left_tile_schema, right_tile_schema);
// Set the output logical tile schema
output_tile->SetSchema(std::move(output_tile_schema));
return output_tile;
}
std::unique_ptr<LogicalTile> AbstractJoinExecutor::BuildOutputLogicalTile(
LogicalTile *left_tile, LogicalTile *right_tile,
const catalog::Schema *output_schema) {
PL_ASSERT(output_schema != nullptr);
std::unique_ptr<LogicalTile> output_tile(LogicalTileFactory::GetTile());
// get the non empty tile
LogicalTile *non_empty_tile = GetNonEmptyTile(left_tile, right_tile);
auto non_empty_tile_schema = non_empty_tile->GetSchema();
// left tile is empty
if (non_empty_tile == right_tile) {
/* build the schema given the projection */
output_tile->SetSchema(
BuildSchemaFromRightTile(&non_empty_tile_schema, output_schema));
} else {
// right tile is empty
output_tile->SetSchema(
BuildSchemaFromLeftTile(&non_empty_tile_schema, output_schema,
left_tile->GetPositionLists().size()));
}
return output_tile;
}
void output_tiles(COMPARISON comp, TILES t)
{
int i=1;
TILE tile = t->first;
printf(_("Number of tiles: %d\n"), t->num);
while (tile)
{
printf("%d:\n", i++);
output_tile(tile);
printf(_("Fragment of %s:\n"), comp->a->filename);
print_substring(comp->a->source,
tile->p_atoms[0]->start,
tile->p_atoms[tile->L-1]->start + tile->p_atoms[tile->L-1]->len);
printf(_("Fragment of %s:\n"), comp->b->filename);
print_substring(comp->b->source,
tile->t_atoms[0]->start,
tile->t_atoms[tile->L-1]->start + tile->t_atoms[tile->L-1]->len);
tile = tile->next;
}
}
/*
* build right join output by adding null rows for every row from left tile
* which doesn't have a match
*/
bool AbstractJoinExecutor::BuildRightJoinOutput() {
while (right_matching_idx < no_matching_right_row_sets_.size()) {
if (no_matching_right_row_sets_[right_matching_idx].empty()) {
right_matching_idx++;
continue;
}
std::unique_ptr<LogicalTile> output_tile(nullptr);
auto right_tile = right_result_tiles_[right_matching_idx].get();
LogicalTile::PositionListsBuilder pos_lists_builder;
if (left_result_tiles_.size() == 0) {
// no tile information for left tile. construct a output tile from right
// tile only
output_tile = BuildOutputLogicalTile(nullptr, right_tile, proj_schema_);
pos_lists_builder = LogicalTile::PositionListsBuilder(
nullptr, &(right_tile->GetPositionLists()));
} else {
PL_ASSERT(left_result_tiles_.size() > 0);
// construct the output tile from both children tiles
auto left_tile = left_result_tiles_.front().get();
output_tile = BuildOutputLogicalTile(left_tile, right_tile);
pos_lists_builder =
LogicalTile::PositionListsBuilder(left_tile, right_tile);
}
// add rows with null values on the left
for (auto right_row_itr : no_matching_right_row_sets_[right_matching_idx]) {
pos_lists_builder.AddLeftNullRow(right_row_itr);
}
PL_ASSERT(pos_lists_builder.Size() > 0);
output_tile->SetPositionListsAndVisibility(pos_lists_builder.Release());
SetOutput(output_tile.release());
right_matching_idx++;
return true;
}
return false;
}
