void LoadTable() {
const oid_t col_count = state.column_count + 1;
const int tuple_count = state.scale_factor * state.tuples_per_tilegroup;
auto table_schema = sdbench_table->GetSchema();
/////////////////////////////////////////////////////////
// Load in the data
/////////////////////////////////////////////////////////
// Insert tuples into tile_group.
auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
const bool allocate = true;
auto txn = txn_manager.BeginTransaction();
std::unique_ptr<VarlenPool> pool(new VarlenPool(BACKEND_TYPE_MM));
int rowid;
for (rowid = 0; rowid < tuple_count; rowid++) {
int populate_value = rowid;
storage::Tuple tuple(table_schema, allocate);
for (oid_t col_itr = 0; col_itr < col_count; col_itr++) {
auto value = ValueFactory::GetIntegerValue(populate_value);
tuple.SetValue(col_itr, value, pool.get());
}
ItemPointer tuple_slot_id = sdbench_table->InsertTuple(&tuple);
PL_ASSERT(tuple_slot_id.block != INVALID_OID);
PL_ASSERT(tuple_slot_id.offset != INVALID_OID);
txn->RecordInsert(tuple_slot_id);
}
txn_manager.CommitTransaction();
}
/**
* @brief Populates the table
* @param table Table to populate with values.
* @param num_rows Number of tuples to insert.
*/
void ExecutorTestsUtil::PopulateTable(storage::DataTable *table, int num_rows,
bool mutate, bool random, bool group_by) {
// Random values
if (random) std::srand(std::time(nullptr));
const catalog::Schema *schema = table->GetSchema();
// Ensure that the tile group is as expected.
assert(schema->GetColumnCount() == 4);
// Insert tuples into tile_group.
auto &txn_manager = concurrency::TransactionManager::GetInstance();
const bool allocate = true;
auto txn = txn_manager.BeginTransaction();
auto testing_pool = TestingHarness::GetInstance().GetTestingPool();
for (int rowid = 0; rowid < num_rows; rowid++) {
int populate_value = rowid;
if (mutate) populate_value *= 3;
storage::Tuple tuple(schema, allocate);
if (group_by) {
// First column has only two distinct values
tuple.SetValue(0, ValueFactory::GetIntegerValue(PopulatedValue(
int(populate_value / (num_rows / 2)), 0)),
testing_pool);
} else {
// First column is unique in this case
tuple.SetValue(
0, ValueFactory::GetIntegerValue(PopulatedValue(populate_value, 0)),
testing_pool);
}
// In case of random, make sure this column has duplicated values
tuple.SetValue(
1, ValueFactory::GetIntegerValue(PopulatedValue(
random ? std::rand() % (num_rows / 3) : populate_value, 1)),
testing_pool);
tuple.SetValue(2, ValueFactory::GetDoubleValue(PopulatedValue(
random ? std::rand() : populate_value, 2)),
testing_pool);
// In case of random, make sure this column has duplicated values
Value string_value =
ValueFactory::GetStringValue(std::to_string(PopulatedValue(
random ? std::rand() % (num_rows / 3) : populate_value, 3)));
tuple.SetValue(3, string_value, testing_pool);
ItemPointer tuple_slot_id = table->InsertTuple(txn, &tuple);
EXPECT_TRUE(tuple_slot_id.block != INVALID_OID);
EXPECT_TRUE(tuple_slot_id.offset != INVALID_OID);
txn->RecordInsert(tuple_slot_id);
}
txn_manager.CommitTransaction();
}
/**
* @brief read tuple record from log file and add them tuples to recovery txn
* @param recovery txn
*/
void AriesFrontendLogger::InsertTuple(concurrency::Transaction *recovery_txn) {
TupleRecord tuple_record(LOGRECORD_TYPE_ARIES_TUPLE_INSERT);
// Check for torn log write
if (ReadTupleRecordHeader(tuple_record, log_file, log_file_size) == false) {
LOG_ERROR("Could not read tuple record header.");
return;
}
auto txn_id = tuple_record.GetTransactionId();
if (recovery_txn_table.find(txn_id) == recovery_txn_table.end()) {
LOG_ERROR("Insert txd id %d not found in recovery txn table", (int)txn_id);
return;
}
auto table = GetTable(tuple_record);
// Read off the tuple record body from the log
auto tuple = ReadTupleRecordBody(table->GetSchema(), recovery_pool, log_file,
log_file_size);
// Check for torn log write
if (tuple == nullptr) {
return;
}
auto target_location = tuple_record.GetInsertLocation();
auto tile_group_id = target_location.block;
auto tuple_slot = target_location.offset;
auto &manager = catalog::Manager::GetInstance();
auto tile_group = manager.GetTileGroup(tile_group_id);
auto txn = recovery_txn_table.at(txn_id);
// Create new tile group if table doesn't already have that tile group
if (tile_group == nullptr) {
table->AddTileGroupWithOid(tile_group_id);
tile_group = manager.GetTileGroup(tile_group_id);
if (max_oid < tile_group_id) {
max_oid = tile_group_id;
}
}
// Do the insert !
auto inserted_tuple_slot = tile_group->InsertTuple(
recovery_txn->GetTransactionId(), tuple_slot, tuple);
if (inserted_tuple_slot == INVALID_OID) {
// TODO: We need to abort on failure !
recovery_txn->SetResult(Result::RESULT_FAILURE);
} else {
txn->RecordInsert(target_location);
table->IncreaseNumberOfTuplesBy(1);
}
delete tuple;
}
// Do insert and create insert tuple log records
std::vector<ItemPointer> InsertTuples(
storage::DataTable* table, const std::vector<storage::Tuple*>& tuples,
bool committed) {
std::vector<ItemPointer> locations;
auto& txn_manager = concurrency::TransactionManagerFactory::GetInstance();
for (auto tuple : tuples) {
auto txn = txn_manager.BeginTransaction();
ItemPointer location = table->InsertTuple(tuple);
if (location.block == INVALID_OID) {
txn->SetResult(Result::RESULT_FAILURE);
LOG_ERROR("Insert failed");
exit(EXIT_FAILURE);
}
txn->RecordInsert(location);
locations.push_back(location);
// Logging
{
auto& log_manager = logging::LogManager::GetInstance();
if (log_manager.IsInLoggingMode()) {
auto logger = log_manager.GetBackendLogger();
auto record = logger->GetTupleRecord(
LOGRECORD_TYPE_TUPLE_INSERT, txn->GetTransactionId(),
table->GetOid(), location, INVALID_ITEMPOINTER, tuple,
LOGGING_TESTS_DATABASE_OID);
logger->Log(record);
}
}
// commit or abort as required
if (committed) {
txn_manager.CommitTransaction();
} else {
txn_manager.AbortTransaction();
}
}
return locations;
}
/**
* @brief read tuple record from log file and add them tuples to recovery txn
* @param recovery txn
*/
void AriesFrontendLogger::UpdateTuple(concurrency::Transaction *recovery_txn) {
TupleRecord tuple_record(LOGRECORD_TYPE_ARIES_TUPLE_UPDATE);
// Check for torn log write
if (ReadTupleRecordHeader(tuple_record, log_file, log_file_size) == false) {
return;
}
auto txn_id = tuple_record.GetTransactionId();
if (recovery_txn_table.find(txn_id) == recovery_txn_table.end()) {
LOG_TRACE("Update txd id %d not found in recovery txn table", (int)txn_id);
return;
}
auto txn = recovery_txn_table.at(txn_id);
auto table = GetTable(tuple_record);
auto tuple = ReadTupleRecordBody(table->GetSchema(), recovery_pool, log_file,
log_file_size);
// Check for torn log write
if (tuple == nullptr) {
return;
}
// First, redo the delete
ItemPointer delete_location = tuple_record.GetDeleteLocation();
bool status = table->DeleteTuple(recovery_txn, delete_location);
if (status == false) {
recovery_txn->SetResult(Result::RESULT_FAILURE);
} else {
txn->RecordDelete(delete_location);
auto target_location = tuple_record.GetInsertLocation();
auto tile_group_id = target_location.block;
auto tuple_slot = target_location.offset;
auto &manager = catalog::Manager::GetInstance();
auto tile_group = manager.GetTileGroup(tile_group_id);
// Create new tile group if table doesn't already have that tile group
if (tile_group == nullptr) {
table->AddTileGroupWithOid(tile_group_id);
tile_group = manager.GetTileGroup(tile_group_id);
if (max_oid < tile_group_id) {
max_oid = tile_group_id;
}
}
// Do the insert !
auto inserted_tuple_slot = tile_group->InsertTuple(
recovery_txn->GetTransactionId(), tuple_slot, tuple);
if (inserted_tuple_slot == INVALID_OID) {
recovery_txn->SetResult(Result::RESULT_FAILURE);
} else {
txn->RecordInsert(target_location);
}
}
delete tuple;
}
/**
* @brief Adds a column to the logical tile, using the position lists.
* @return true on success, false otherwise.
*/
bool InsertExecutor::DExecute() {
if (done_) return false;
assert(!done_);
assert(executor_context_ != nullptr);
const planner::InsertPlan &node = GetPlanNode<planner::InsertPlan>();
storage::DataTable *target_table_ = node.GetTable();
oid_t bulk_insert_count = node.GetBulkInsertCount();
assert(target_table_);
auto transaction_ = executor_context_->GetTransaction();
auto executor_pool = executor_context_->GetExecutorContextPool();
// Inserting a logical tile.
if (children_.size() == 1) {
LOG_INFO("Insert executor :: 1 child \n");
if (!children_[0]->Execute()) {
return false;
}
std::unique_ptr<LogicalTile> logical_tile(children_[0]->GetOutput());
assert(logical_tile.get() != nullptr);
auto target_table_schema = target_table_->GetSchema();
auto column_count = target_table_schema->GetColumnCount();
std::unique_ptr<storage::Tuple> tuple(
new storage::Tuple(target_table_schema, true));
// Go over the logical tile
for (oid_t tuple_id : *logical_tile) {
expression::ContainerTuple<LogicalTile> cur_tuple(logical_tile.get(),
tuple_id);
// Materialize the logical tile tuple
for (oid_t column_itr = 0; column_itr < column_count; column_itr++)
tuple->SetValue(column_itr, cur_tuple.GetValue(column_itr),
executor_pool);
peloton::ItemPointer location =
target_table_->InsertTuple(transaction_, tuple.get());
if (location.block == INVALID_OID) {
transaction_->SetResult(peloton::Result::RESULT_FAILURE);
return false;
}
transaction_->RecordInsert(location);
executor_context_->num_processed += 1; // insert one
}
return true;
}
// Inserting a collection of tuples from plan node
else if (children_.size() == 0) {
LOG_INFO("Insert executor :: 0 child \n");
// Extract expressions from plan node and construct the tuple.
// For now we just handle a single tuple
auto schema = target_table_->GetSchema();
std::unique_ptr<storage::Tuple> tuple(new storage::Tuple(schema, true));
auto project_info = node.GetProjectInfo();
// There should be no direct maps
assert(project_info);
assert(project_info->GetDirectMapList().size() == 0);
for (auto target : project_info->GetTargetList()) {
peloton::Value value =
target.second->Evaluate(nullptr, nullptr, executor_context_);
tuple->SetValue(target.first, value, executor_pool);
}
// Bulk Insert Mode
for (oid_t insert_itr = 0; insert_itr < bulk_insert_count; insert_itr++) {
// Carry out insertion
ItemPointer location =
target_table_->InsertTuple(transaction_, tuple.get());
LOG_INFO("Inserted into location: %lu, %lu", location.block,
location.offset);
if (location.block == INVALID_OID) {
LOG_INFO("Failed to Insert. Set txn failure.");
transaction_->SetResult(peloton::Result::RESULT_FAILURE);
return false;
}
transaction_->RecordInsert(location);
// Logging
{
auto &log_manager = logging::LogManager::GetInstance();
if (log_manager.IsInLoggingMode()) {
auto logger = log_manager.GetBackendLogger();
auto record = logger->GetTupleRecord(
LOGRECORD_TYPE_TUPLE_INSERT, transaction_->GetTransactionId(),
target_table_->GetOid(), location, INVALID_ITEMPOINTER,
tuple.get());
logger->Log(record);
}
}
}
executor_context_->num_processed += 1; // insert one
done_ = true;
return true;
}
return true;
}
