bool TransactionTestsUtil::ExecuteScan(concurrency::Transaction *transaction,
std::vector<int> &results,
storage::DataTable *table, int id) {
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(transaction));
// Predicate, WHERE `id`>=id1
auto tup_val_exp = new expression::TupleValueExpression(0, 0);
auto const_val_exp = new expression::ConstantValueExpression(
ValueFactory::GetIntegerValue(id));
auto predicate = new expression::ComparisonExpression<expression::CmpGte>(
EXPRESSION_TYPE_COMPARE_GREATERTHANOREQUALTO, tup_val_exp, const_val_exp);
// Seq scan
std::vector<oid_t> column_ids = {0, 1};
planner::SeqScanPlan seq_scan_node(table, predicate, column_ids);
executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get());
EXPECT_TRUE(seq_scan_executor.Init());
if (seq_scan_executor.Execute() == false) return false;
std::unique_ptr<executor::LogicalTile> result_tile(
seq_scan_executor.GetOutput());
for (size_t i = 0; i < result_tile->GetTupleCount(); i++) {
results.push_back(result_tile->GetValue(i, 1).GetIntegerForTestsOnly());
}
return true;
}
bool TransactionTestsUtil::ExecuteRead(concurrency::Transaction *transaction,
storage::DataTable *table, int id,
int &result) {
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(transaction));
// Predicate, WHERE `id`=id
auto predicate = MakePredicate(id);
// Seq scan
std::vector<oid_t> column_ids = {0, 1};
planner::SeqScanPlan seq_scan_node(table, predicate, column_ids);
executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get());
EXPECT_TRUE(seq_scan_executor.Init());
if (seq_scan_executor.Execute() == false) {
result = -1;
return false;
}
std::unique_ptr<executor::LogicalTile> result_tile(
seq_scan_executor.GetOutput());
// Read nothing
if (result_tile->GetTupleCount() == 0)
result = -1;
else {
EXPECT_EQ(1, result_tile->GetTupleCount());
result = result_tile->GetValue(0, 1).GetIntegerForTestsOnly();
}
return true;
}
bool TransactionTestsUtil::ExecuteDelete(concurrency::Transaction *transaction,
storage::DataTable *table, int id) {
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(transaction));
// Delete
planner::DeletePlan delete_node(table, false);
executor::DeleteExecutor delete_executor(&delete_node, context.get());
auto predicate = MakePredicate(id);
// Scan
std::vector<oid_t> column_ids = {0};
std::unique_ptr<planner::SeqScanPlan> seq_scan_node(
new planner::SeqScanPlan(table, predicate, column_ids));
executor::SeqScanExecutor seq_scan_executor(seq_scan_node.get(),
context.get());
delete_node.AddChild(std::move(seq_scan_node));
delete_executor.AddChild(&seq_scan_executor);
EXPECT_TRUE(delete_executor.Init());
return delete_executor.Execute();
}
TEST_F(MutateTests, DeleteTest) {
// We are going to insert a tile group into a table in this test
storage::DataTable *table = ExecutorTestsUtil::CreateTable();
auto testing_pool = TestingHarness::GetInstance().GetTestingPool();
LaunchParallelTest(1, InsertTuple, table, testing_pool);
LaunchParallelTest(1, DeleteTuple, table);
auto &txn_manager = concurrency::OptimisticTxnManager::GetInstance();
auto txn = txn_manager.BeginTransaction();
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(txn));
// Seq scan
std::vector<oid_t> column_ids = {0};
planner::SeqScanPlan seq_scan_node(table, nullptr, column_ids);
executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get());
EXPECT_TRUE(seq_scan_executor.Init());
auto tuple_cnt = 0;
while (seq_scan_executor.Execute()) {
std::unique_ptr<executor::LogicalTile> result_logical_tile(
seq_scan_executor.GetOutput());
tuple_cnt += result_logical_tile->GetTupleCount();
}
txn_manager.CommitTransaction();
EXPECT_EQ(tuple_cnt, 6);
delete table;
tuple_id = 0;
}
std::unique_ptr<std::vector<std::unique_ptr<executor::LogicalTile>>>
TupleSamplesStorage::GetTuplesWithSeqScan(
storage::DataTable *data_table, std::vector<oid_t> column_offsets,
concurrency::TransactionContext *txn) {
if (txn == nullptr) {
LOG_TRACE("Do not have transaction to perform the sequential scan");
return nullptr;
}
// Sequential scan
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(txn));
planner::SeqScanPlan seq_scan_node(data_table, nullptr, column_offsets);
executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get());
// Execute
seq_scan_executor.Init();
std::unique_ptr<std::vector<std::unique_ptr<executor::LogicalTile>>>
result_tiles(new std::vector<std::unique_ptr<executor::LogicalTile>>());
while (seq_scan_executor.Execute()) {
result_tiles->push_back(
std::unique_ptr<executor::LogicalTile>(seq_scan_executor.GetOutput()));
}
return result_tiles;
}
void UpdateTuple(storage::DataTable *table) {
auto &txn_manager = concurrency::OptimisticTxnManager::GetInstance();
auto txn = txn_manager.BeginTransaction();
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(txn));
// Update
std::vector<oid_t> update_column_ids = {2};
std::vector<Value> values;
Value update_val = ValueFactory::GetDoubleValue(23.5);
planner::ProjectInfo::TargetList target_list;
planner::ProjectInfo::DirectMapList direct_map_list;
target_list.emplace_back(
2, expression::ExpressionUtil::ConstantValueFactory(update_val));
LOG_INFO("%lu", target_list.at(0).first);
direct_map_list.emplace_back(0, std::pair<oid_t, oid_t>(0, 0));
direct_map_list.emplace_back(1, std::pair<oid_t, oid_t>(0, 1));
direct_map_list.emplace_back(3, std::pair<oid_t, oid_t>(0, 3));
planner::UpdatePlan update_node(
table, new planner::ProjectInfo(std::move(target_list),
std::move(direct_map_list)));
executor::UpdateExecutor update_executor(&update_node, context.get());
// Predicate
// WHERE ATTR_0 < 70
expression::TupleValueExpression *tup_val_exp =
new expression::TupleValueExpression(0, 0);
expression::ConstantValueExpression *const_val_exp =
new expression::ConstantValueExpression(
ValueFactory::GetIntegerValue(70));
auto predicate = new expression::ComparisonExpression<expression::CmpLt>(
EXPRESSION_TYPE_COMPARE_LESSTHAN, tup_val_exp, const_val_exp);
// Seq scan
std::vector<oid_t> column_ids = {0};
planner::SeqScanPlan seq_scan_node(table, predicate, column_ids);
executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get());
// Parent-Child relationship
update_node.AddChild(&seq_scan_node);
update_executor.AddChild(&seq_scan_executor);
EXPECT_TRUE(update_executor.Init());
while (update_executor.Execute())
;
txn_manager.CommitTransaction();
}
bool TransactionTestsUtil::ExecuteUpdateByValue(concurrency::Transaction *txn,
storage::DataTable *table,
int old_value,
int new_value) {
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(txn));
Value update_val = ValueFactory::GetIntegerValue(new_value);
// ProjectInfo
planner::ProjectInfo::TargetList target_list;
planner::ProjectInfo::DirectMapList direct_map_list;
target_list.emplace_back(
1, expression::ExpressionUtil::ConstantValueFactory(update_val));
direct_map_list.emplace_back(0, std::pair<oid_t, oid_t>(0, 0));
// Update plan
std::unique_ptr<const planner::ProjectInfo> project_info(
new planner::ProjectInfo(std::move(target_list),
std::move(direct_map_list)));
planner::UpdatePlan update_node(table, std::move(project_info));
executor::UpdateExecutor update_executor(&update_node, context.get());
// Predicate
auto tup_val_exp = new expression::TupleValueExpression(0, 1);
auto const_val_exp = new expression::ConstantValueExpression(
ValueFactory::GetIntegerValue(old_value));
auto predicate = new expression::ComparisonExpression<expression::CmpEq>(
EXPRESSION_TYPE_COMPARE_EQUAL, tup_val_exp, const_val_exp);
// Seq scan
std::vector<oid_t> column_ids = {0, 1};
std::unique_ptr<planner::SeqScanPlan> seq_scan_node(
new planner::SeqScanPlan(table, predicate, column_ids));
executor::SeqScanExecutor seq_scan_executor(seq_scan_node.get(),
context.get());
update_node.AddChild(std::move(seq_scan_node));
update_executor.AddChild(&seq_scan_executor);
EXPECT_TRUE(update_executor.Init());
return update_executor.Execute();
}
TEST_F(GCDeleteTestVacuum, DeleteTest) {
peloton::gc::GCManagerFactory::Configure(type);
peloton::gc::GCManagerFactory::GetInstance().StartGC();
auto *table = ExecutorTestsUtil::CreateTable(1024);
auto &manager = catalog::Manager::GetInstance();
storage::Database db(DEFAULT_DB_ID);
manager.AddDatabase(&db);
db.AddTable(table);
// We are going to insert a tile group into a table in this test
auto testing_pool = TestingHarness::GetInstance().GetTestingPool();
auto before_insert = catalog::Manager::GetInstance().GetMemoryFootprint();
LaunchParallelTest(1, InsertTuple, table, testing_pool);
auto after_insert = catalog::Manager::GetInstance().GetMemoryFootprint();
EXPECT_GT(after_insert, before_insert);
LaunchParallelTest(1, DeleteTuple, table);
std::this_thread::sleep_for(std::chrono::seconds(10));
auto after_delete = catalog::Manager::GetInstance().GetMemoryFootprint();
EXPECT_EQ(after_insert, after_delete);
auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
auto txn = txn_manager.BeginTransaction();
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(txn));
// Seq scan
std::vector<oid_t> column_ids = {0};
planner::SeqScanPlan seq_scan_node(table, nullptr, column_ids);
executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get());
EXPECT_TRUE(seq_scan_executor.Init());
auto tuple_cnt = 0;
while (seq_scan_executor.Execute()) {
std::unique_ptr<executor::LogicalTile> result_logical_tile(
seq_scan_executor.GetOutput());
tuple_cnt += result_logical_tile->GetTupleCount();
}
txn_manager.CommitTransaction();
EXPECT_EQ(tuple_cnt, 6);
tuple_id = 0;
}
void DeleteTuple(storage::DataTable *table) {
auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
auto txn = txn_manager.BeginTransaction();
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(txn));
std::vector<storage::Tuple *> tuples;
// Delete
planner::DeletePlan delete_node(table, false);
executor::DeleteExecutor delete_executor(&delete_node, context.get());
// Predicate
// WHERE ATTR_0 > 60
expression::TupleValueExpression *tup_val_exp =
new expression::TupleValueExpression(VALUE_TYPE_INTEGER, 0, 0);
expression::ConstantValueExpression *const_val_exp =
new expression::ConstantValueExpression(
ValueFactory::GetIntegerValue(60));
auto predicate = new expression::ComparisonExpression<expression::CmpGt>(
EXPRESSION_TYPE_COMPARE_GREATERTHAN, tup_val_exp, const_val_exp);
// Seq scan
std::vector<oid_t> column_ids = {0};
std::unique_ptr<planner::SeqScanPlan> seq_scan_node(
new planner::SeqScanPlan(table, predicate, column_ids));
executor::SeqScanExecutor seq_scan_executor(seq_scan_node.get(),
context.get());
// Parent-Child relationship
delete_node.AddChild(std::move(seq_scan_node));
delete_executor.AddChild(&seq_scan_executor);
EXPECT_TRUE(delete_executor.Init());
EXPECT_TRUE(delete_executor.Execute());
// EXPECT_TRUE(delete_executor.Execute());
txn_manager.CommitTransaction();
}
bool TransactionTestsUtil::ExecuteUpdate(concurrency::Transaction *transaction,
storage::DataTable *table, int id,
int value) {
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(transaction));
Value update_val = ValueFactory::GetIntegerValue(value);
// ProjectInfo
planner::ProjectInfo::TargetList target_list;
planner::ProjectInfo::DirectMapList direct_map_list;
target_list.emplace_back(
1, expression::ExpressionUtil::ConstantValueFactory(update_val));
direct_map_list.emplace_back(0, std::pair<oid_t, oid_t>(0, 0));
// Update plan
std::unique_ptr<const planner::ProjectInfo> project_info(
new planner::ProjectInfo(std::move(target_list),
std::move(direct_map_list)));
planner::UpdatePlan update_node(table, std::move(project_info));
executor::UpdateExecutor update_executor(&update_node, context.get());
// Predicate
auto predicate = MakePredicate(id);
// Seq scan
std::vector<oid_t> column_ids = {0};
std::unique_ptr<planner::SeqScanPlan> seq_scan_node(
new planner::SeqScanPlan(table, predicate, column_ids));
executor::SeqScanExecutor seq_scan_executor(seq_scan_node.get(),
context.get());
update_node.AddChild(std::move(seq_scan_node));
update_executor.AddChild(&seq_scan_executor);
EXPECT_TRUE(update_executor.Init());
return update_executor.Execute();
}
void DeleteTuple(storage::DataTable *table, oid_t id){
auto txn = peloton::concurrency::current_txn;
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(txn));
LOG_INFO("Removing tuple with id %d from table %s", (int)id, table->GetName().c_str());
LOG_INFO("Transaction ID: %d", (int)txn->GetTransactionId());
// Delete
planner::DeletePlan delete_node(table, false);
executor::DeleteExecutor delete_executor(&delete_node, context.get());
// Predicate
// WHERE id_in_table = id
expression::TupleValueExpression *tup_val_exp =
new expression::TupleValueExpression(VALUE_TYPE_INTEGER, 0, 0);
expression::ConstantValueExpression *const_val_exp =
new expression::ConstantValueExpression(
ValueFactory::GetIntegerValue(id));
auto predicate = new expression::ComparisonExpression<expression::CmpEq>(
EXPRESSION_TYPE_COMPARE_EQUAL, tup_val_exp, const_val_exp);
// Seq scan
std::vector<oid_t> column_ids = {0, 1};
std::unique_ptr<planner::SeqScanPlan> seq_scan_node(
new planner::SeqScanPlan(table, predicate, column_ids));
executor::SeqScanExecutor seq_scan_executor(seq_scan_node.get(),
context.get());
// Parent-Child relationship
delete_node.AddChild(std::move(seq_scan_node));
delete_executor.AddChild(&seq_scan_executor);
delete_executor.Init();
delete_executor.Execute();
}
int SeqScanCount(storage::DataTable *table,
const std::vector<oid_t> &column_ids,
expression::AbstractExpression *predicate) {
auto &txn_manager = concurrency::OptimisticTxnManager::GetInstance();
auto txn = txn_manager.BeginTransaction();
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(txn));
planner::SeqScanPlan seq_scan_node(table, predicate, column_ids);
executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get());
EXPECT_TRUE(seq_scan_executor.Init());
auto tuple_cnt = 0;
while (seq_scan_executor.Execute()) {
std::unique_ptr<executor::LogicalTile> result_logical_tile(
seq_scan_executor.GetOutput());
tuple_cnt += result_logical_tile->GetTupleCount();
}
txn_manager.CommitTransaction();
return tuple_cnt;
}
void ExecuteTileGroupTest() {
const int tuples_per_tilegroup_count = 10;
const int tile_group_count = 5;
const int tuple_count = tuples_per_tilegroup_count * tile_group_count;
const oid_t col_count = 250;
const bool is_inlined = true;
const bool indexes = false;
std::vector<catalog::Column> columns;
for (oid_t col_itr = 0; col_itr <= col_count; col_itr++) {
auto column =
catalog::Column(VALUE_TYPE_INTEGER, GetTypeSize(VALUE_TYPE_INTEGER),
"FIELD" + std::to_string(col_itr), is_inlined);
columns.push_back(column);
}
catalog::Schema *table_schema = new catalog::Schema(columns);
std::string table_name("TEST_TABLE");
/////////////////////////////////////////////////////////
// Create table.
/////////////////////////////////////////////////////////
bool own_schema = true;
bool adapt_table = true;
std::unique_ptr<storage::DataTable> table(storage::TableFactory::GetDataTable(
INVALID_OID, INVALID_OID, table_schema, table_name,
tuples_per_tilegroup_count, own_schema, adapt_table));
// PRIMARY INDEX
if (indexes == true) {
std::vector<oid_t> key_attrs;
auto tuple_schema = table->GetSchema();
catalog::Schema *key_schema;
index::IndexMetadata *index_metadata;
bool unique;
key_attrs = {0};
key_schema = catalog::Schema::CopySchema(tuple_schema, key_attrs);
key_schema->SetIndexedColumns(key_attrs);
unique = true;
index_metadata = new index::IndexMetadata(
"primary_index", 123, INDEX_TYPE_BTREE,
INDEX_CONSTRAINT_TYPE_PRIMARY_KEY, tuple_schema, key_schema, unique);
index::Index *pkey_index = index::IndexFactory::GetInstance(index_metadata);
table->AddIndex(pkey_index);
}
/////////////////////////////////////////////////////////
// Load in the data
/////////////////////////////////////////////////////////
// Insert tuples into tile_group.
auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
const bool allocate = true;
auto txn = txn_manager.BeginTransaction();
auto testing_pool = TestingHarness::GetInstance().GetTestingPool();
for (int 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 + col_itr);
tuple.SetValue(col_itr, value, testing_pool);
}
ItemPointer tuple_slot_id = table->InsertTuple(&tuple);
EXPECT_TRUE(tuple_slot_id.block != INVALID_OID);
EXPECT_TRUE(tuple_slot_id.offset != INVALID_OID);
txn_manager.PerformInsert(tuple_slot_id.block, tuple_slot_id.offset);
}
txn_manager.CommitTransaction();
/////////////////////////////////////////////////////////
// Do a seq scan with predicate on top of the table
/////////////////////////////////////////////////////////
txn = txn_manager.BeginTransaction();
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(txn));
// Column ids to be added to logical tile after scan.
// std::vector<oid_t> column_ids;
// for(oid_t col_itr = 0 ; col_itr <= 200; col_itr++) {
// column_ids.push_back(col_itr);
//}
std::vector<oid_t> column_ids({198, 206});
// Create and set up seq scan executor
planner::SeqScanPlan seq_scan_node(table.get(), nullptr, column_ids);
int expected_num_tiles = tile_group_count;
executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get());
// Create and set up materialization executor
std::vector<catalog::Column> output_columns;
std::unordered_map<oid_t, oid_t> old_to_new_cols;
oid_t col_itr = 0;
for (auto column_id : column_ids) {
auto column =
catalog::Column(VALUE_TYPE_INTEGER, GetTypeSize(VALUE_TYPE_INTEGER),
"FIELD" + std::to_string(column_id), is_inlined);
output_columns.push_back(column);
old_to_new_cols[col_itr] = col_itr;
col_itr++;
}
std::unique_ptr<catalog::Schema> output_schema(
new catalog::Schema(output_columns));
bool physify_flag = true; // is going to create a physical tile
planner::MaterializationPlan mat_node(old_to_new_cols,
output_schema.release(), physify_flag);
executor::MaterializationExecutor mat_executor(&mat_node, nullptr);
mat_executor.AddChild(&seq_scan_executor);
EXPECT_TRUE(mat_executor.Init());
std::vector<std::unique_ptr<executor::LogicalTile>> result_tiles;
for (int i = 0; i < expected_num_tiles; i++) {
EXPECT_TRUE(mat_executor.Execute());
std::unique_ptr<executor::LogicalTile> result_tile(
mat_executor.GetOutput());
EXPECT_THAT(result_tile, NotNull());
result_tiles.emplace_back(result_tile.release());
}
EXPECT_FALSE(mat_executor.Execute());
txn_manager.CommitTransaction();
}
