bool CreateExecutor::DExecute() {
LOG_TRACE("Executing Create...");
const planner::CreatePlan &node = GetPlanNode<planner::CreatePlan>();
auto current_txn = context->GetTransaction();
// Check if query was for creating table
if (node.GetCreateType() == CreateType::TABLE) {
std::string table_name = node.GetTableName();
auto database_name = node.GetDatabaseName();
std::unique_ptr<catalog::Schema> schema(node.GetSchema());
ResultType result = catalog::Catalog::GetInstance()->CreateTable(
database_name, table_name, std::move(schema), current_txn);
current_txn->SetResult(result);
if (current_txn->GetResult() == ResultType::SUCCESS) {
LOG_TRACE("Creating table succeeded!");
} else if (current_txn->GetResult() == ResultType::FAILURE) {
LOG_TRACE("Creating table failed!");
} else {
LOG_TRACE("Result is: %s",
ResultTypeToString(current_txn->GetResult()).c_str());
}
}
// Check if query was for creating index
if (node.GetCreateType() == CreateType::INDEX) {
std::string table_name = node.GetTableName();
std::string index_name = node.GetIndexName();
bool unique_flag = node.IsUnique();
IndexType index_type = node.GetIndexType();
auto index_attrs = node.GetIndexAttributes();
ResultType result = catalog::Catalog::GetInstance()->CreateIndex(
DEFAULT_DB_NAME, table_name, index_attrs, index_name, unique_flag,
index_type, current_txn);
current_txn->SetResult(result);
if (current_txn->GetResult() == ResultType::SUCCESS) {
LOG_TRACE("Creating table succeeded!");
} else if (current_txn->GetResult() == ResultType::FAILURE) {
LOG_TRACE("Creating table failed!");
} else {
LOG_TRACE("Result is: %s",
ResultTypeToString(current_txn->GetResult()).c_str());
}
}
return false;
}
void SetupTables() {
LOG_INFO("Creating default database");
auto& txn_manager = concurrency::TransactionManagerFactory::GetInstance();
auto txn = txn_manager.BeginTransaction();
catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn);
txn_manager.CommitTransaction(txn);
LOG_INFO("Default database created!");
auto& parser = parser::PostgresParser::GetInstance();
auto& traffic_cop = tcop::TrafficCop::GetInstance();
optimizer::Optimizer optimizer;
txn = txn_manager.BeginTransaction();
vector<string> createTableSQLs{"CREATE TABLE A(A1 int, a2 varchar)",
"CREATE TABLE b(B1 int, b2 varchar)"};
for (auto& sql : createTableSQLs) {
LOG_INFO("%s", sql.c_str());
vector<type::Value> params;
vector<StatementResult> result;
vector<int> result_format;
unique_ptr<Statement> statement(new Statement("CREATE", sql));
auto parse_tree = parser.BuildParseTree(sql);
statement->SetPlanTree(optimizer.BuildPelotonPlanTree(parse_tree));
auto status = traffic_cop.ExecuteStatementPlan(
statement->GetPlanTree().get(), params, result, result_format);
LOG_INFO("Table create result: %s",
ResultTypeToString(status.m_result).c_str());
}
txn_manager.CommitTransaction(txn);
}
ResultType TrafficCop::ExecuteStatement(
const std::shared_ptr<Statement> &statement,
const std::vector<type::Value> ¶ms, UNUSED_ATTRIBUTE const bool unnamed,
std::shared_ptr<stats::QueryMetric::QueryParams> param_stats,
const std::vector<int> &result_format, std::vector<StatementResult> &result,
int &rows_changed, UNUSED_ATTRIBUTE std::string &error_message,
const size_t thread_id UNUSED_ATTRIBUTE) {
if (FLAGS_stats_mode != STATS_TYPE_INVALID) {
stats::BackendStatsContext::GetInstance()->InitQueryMetric(statement,
param_stats);
}
LOG_TRACE("Execute Statement of name: %s",
statement->GetStatementName().c_str());
LOG_TRACE("Execute Statement of query: %s",
statement->GetStatementName().c_str());
LOG_TRACE("Execute Statement Plan:\n%s",
planner::PlanUtil::GetInfo(statement->GetPlanTree().get()).c_str());
try {
if (statement->GetQueryType() == "BEGIN")
return BeginQueryHelper(thread_id);
else if (statement->GetQueryType() == "COMMIT")
return CommitQueryHelper();
else if (statement->GetQueryType() == "ROLLBACK")
return AbortQueryHelper();
else {
auto status = ExecuteStatementPlan(statement->GetPlanTree().get(), params,
result, result_format,
thread_id);
LOG_TRACE("Statement executed. Result: %s",
ResultTypeToString(status.m_result).c_str());
rows_changed = status.m_processed;
return status.m_result;
}
} catch (Exception &e) {
error_message = e.what();
return ResultType::FAILURE;
}
}
TEST_F(CreateIndexTests, CreatingIndex) {
LOG_INFO("Bootstrapping...");
auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
auto txn = txn_manager.BeginTransaction();
catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn);
txn_manager.CommitTransaction(txn);
LOG_INFO("Bootstrapping completed!");
std::unique_ptr<optimizer::AbstractOptimizer> optimizer;
optimizer.reset(new optimizer::Optimizer);
auto &traffic_cop = tcop::TrafficCop::GetInstance();
traffic_cop.SetTaskCallback(TestingSQLUtil::UtilTestTaskCallback,
&TestingSQLUtil::counter_);
// Create a table first
txn = txn_manager.BeginTransaction();
traffic_cop.SetTcopTxnState(txn);
LOG_INFO("Creating table");
LOG_INFO(
"Query: CREATE TABLE department_table(dept_id INT PRIMARY KEY,student_id "
"INT, dept_name TEXT);");
std::unique_ptr<Statement> statement;
statement.reset(new Statement("CREATE",
"CREATE TABLE department_table(dept_id INT "
"PRIMARY KEY, student_id INT, dept_name "
"TEXT);"));
auto &peloton_parser = parser::PostgresParser::GetInstance();
LOG_INFO("Building parse tree...");
auto create_stmt = peloton_parser.BuildParseTree(
"CREATE TABLE department_table(dept_id INT PRIMARY KEY, student_id INT, "
"dept_name TEXT);");
LOG_INFO("Building parse tree completed!");
LOG_INFO("Binding parse tree...");
auto parse_tree = create_stmt->GetStatement(0);
auto bind_node_visitor = binder::BindNodeVisitor(txn, DEFAULT_DB_NAME);
bind_node_visitor.BindNameToNode(parse_tree);
LOG_INFO("Binding parse tree completed!");
LOG_INFO("Building plan tree...");
statement->SetPlanTree(optimizer->BuildPelotonPlanTree(create_stmt, txn));
LOG_INFO("Building plan tree completed!");
std::vector<type::Value> params;
std::vector<ResultValue> result;
LOG_INFO("Executing plan...\n%s",
planner::PlanUtil::GetInfo(statement->GetPlanTree().get()).c_str());
std::vector<int> result_format;
result_format = std::vector<int>(statement->GetTupleDescriptor().size(), 0);
TestingSQLUtil::counter_.store(1);
executor::ExecutionResult status = traffic_cop.ExecuteHelper(
statement->GetPlanTree(), params, result, result_format);
if (traffic_cop.GetQueuing()) {
TestingSQLUtil::ContinueAfterComplete();
traffic_cop.ExecuteStatementPlanGetResult();
status = traffic_cop.p_status_;
traffic_cop.SetQueuing(false);
}
LOG_INFO("Statement executed. Result: %s",
ResultTypeToString(status.m_result).c_str());
LOG_INFO("Table Created");
traffic_cop.CommitQueryHelper();
txn = txn_manager.BeginTransaction();
// Inserting a tuple end-to-end
traffic_cop.SetTcopTxnState(txn);
LOG_INFO("Inserting a tuple...");
LOG_INFO(
"Query: INSERT INTO department_table(dept_id,student_id ,dept_name) "
"VALUES (1,52,'hello_1');");
statement.reset(new Statement("INSERT",
"INSERT INTO department_table(dept_id, "
"student_id, dept_name) VALUES "
"(1,52,'hello_1');"));
LOG_INFO("Building parse tree...");
auto insert_stmt = peloton_parser.BuildParseTree(
"INSERT INTO department_table(dept_id,student_id,dept_name) VALUES "
"(1,52,'hello_1');");
LOG_INFO("Building parse tree completed!");
LOG_INFO("Binding parse tree...");
parse_tree = insert_stmt->GetStatement(0);
bind_node_visitor = binder::BindNodeVisitor(txn, DEFAULT_DB_NAME);
bind_node_visitor.BindNameToNode(parse_tree);
LOG_INFO("Binding parse tree completed!");
LOG_INFO("Building plan tree...");
statement->SetPlanTree(optimizer->BuildPelotonPlanTree(insert_stmt, txn));
LOG_INFO("Building plan tree completed!\n%s",
planner::PlanUtil::GetInfo(statement->GetPlanTree().get()).c_str());
LOG_INFO("Executing plan...");
result_format = std::vector<int>(statement->GetTupleDescriptor().size(), 0);
TestingSQLUtil::counter_.store(1);
status = traffic_cop.ExecuteHelper(statement->GetPlanTree(), params, result,
result_format);
if (traffic_cop.GetQueuing()) {
TestingSQLUtil::ContinueAfterComplete();
traffic_cop.ExecuteStatementPlanGetResult();
status = traffic_cop.p_status_;
traffic_cop.SetQueuing(false);
}
LOG_INFO("Statement executed. Result: %s",
ResultTypeToString(status.m_result).c_str());
LOG_INFO("Tuple inserted!");
traffic_cop.CommitQueryHelper();
// Now Updating end-to-end
txn = txn_manager.BeginTransaction();
traffic_cop.SetTcopTxnState(txn);
LOG_INFO("Creating and Index");
LOG_INFO("Query: CREATE INDEX saif ON department_table (student_id);");
statement.reset(new Statement(
"CREATE", "CREATE INDEX saif ON department_table (student_id);"));
LOG_INFO("Building parse tree...");
auto update_stmt = peloton_parser.BuildParseTree(
"CREATE INDEX saif ON department_table (student_id);");
LOG_INFO("Building parse tree completed!");
LOG_INFO("Binding parse tree...");
parse_tree = update_stmt->GetStatement(0);
bind_node_visitor = binder::BindNodeVisitor(txn, DEFAULT_DB_NAME);
bind_node_visitor.BindNameToNode(parse_tree);
LOG_INFO("Binding parse tree completed!");
LOG_INFO("Building plan tree...");
statement->SetPlanTree(optimizer->BuildPelotonPlanTree(update_stmt, txn));
LOG_INFO("Building plan tree completed!\n%s",
planner::PlanUtil::GetInfo(statement->GetPlanTree().get()).c_str());
LOG_INFO("Executing plan...");
result_format = std::vector<int>(statement->GetTupleDescriptor().size(), 0);
TestingSQLUtil::counter_.store(1);
status = traffic_cop.ExecuteHelper(statement->GetPlanTree(), params, result,
result_format);
if (traffic_cop.GetQueuing()) {
TestingSQLUtil::ContinueAfterComplete();
traffic_cop.ExecuteStatementPlanGetResult();
status = traffic_cop.p_status_;
traffic_cop.SetQueuing(false);
}
LOG_INFO("Statement executed. Result: %s",
ResultTypeToString(status.m_result).c_str());
LOG_INFO("INDEX CREATED!");
traffic_cop.CommitQueryHelper();
txn = txn_manager.BeginTransaction();
auto target_table_ = catalog::Catalog::GetInstance()->GetTableWithName(
DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", txn);
// Expected 2 , Primary key index + created index
EXPECT_EQ(target_table_->GetIndexCount(), 2);
// free the database just created
catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn);
txn_manager.CommitTransaction(txn);
}
bridge::peloton_status TrafficCop::ExecuteStatementPlan(
const planner::AbstractPlan *plan, const std::vector<type::Value> ¶ms,
std::vector<StatementResult> &result, const std::vector<int> &result_format,
const size_t thread_id) {
concurrency::Transaction *txn;
bool single_statement_txn = false, init_failure = false;
bridge::peloton_status p_status;
auto &curr_state = GetCurrentTxnState();
if (tcop_txn_state_.empty()) {
// no active txn, single-statement txn
auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
// new txn, reset result status
curr_state.second = ResultType::SUCCESS;
txn = txn_manager.BeginTransaction(thread_id);
single_statement_txn = true;
} else {
// get ptr to current active txn
txn = curr_state.first;
}
// skip if already aborted
if (curr_state.second != ResultType::ABORTED) {
PL_ASSERT(txn);
p_status = bridge::PlanExecutor::ExecutePlan(plan, txn, params, result,
result_format);
if (p_status.m_result == ResultType::FAILURE) {
// only possible if init failed
init_failure = true;
}
auto txn_result = txn->GetResult();
if (single_statement_txn == true || init_failure == true ||
txn_result == ResultType::FAILURE) {
auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
LOG_TRACE(
"About to commit: single stmt: %d, init_failure: %d, txn_result: %s",
single_statement_txn, init_failure,
ResultTypeToString(txn_result).c_str());
switch (txn_result) {
case ResultType::SUCCESS:
// Commit
LOG_TRACE("Commit Transaction");
p_status.m_result = txn_manager.CommitTransaction(txn);
break;
case ResultType::FAILURE:
default:
// Abort
LOG_TRACE("Abort Transaction");
p_status.m_result = txn_manager.AbortTransaction(txn);
curr_state.second = ResultType::ABORTED;
}
}
} else {
// otherwise, we have already aborted
p_status.m_result = ResultType::ABORTED;
}
return p_status;
}
TEST_F(DeleteTests, VariousOperations) {
LOG_INFO("Bootstrapping...");
auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
auto txn = txn_manager.BeginTransaction();
catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn);
LOG_INFO("Bootstrapping completed!");
// optimizer::SimpleOptimizer optimizer;
std::unique_ptr<optimizer::AbstractOptimizer> optimizer;
optimizer.reset(new optimizer::Optimizer);
auto &traffic_cop = tcop::TrafficCop::GetInstance();
traffic_cop.SetTaskCallback(TestingSQLUtil::UtilTestTaskCallback,
&TestingSQLUtil::counter_);
// Create a table first
LOG_INFO("Creating a table...");
auto id_column = catalog::Column(
type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER),
"dept_id", true);
auto name_column =
catalog::Column(type::TypeId::VARCHAR, 32, "dept_name", false);
std::unique_ptr<catalog::Schema> table_schema(
new catalog::Schema({id_column, name_column}));
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(txn));
planner::CreatePlan node("department_table", DEFUALT_SCHEMA_NAME,
DEFAULT_DB_NAME, std::move(table_schema),
CreateType::TABLE);
executor::CreateExecutor create_executor(&node, context.get());
create_executor.Init();
create_executor.Execute();
LOG_INFO("Table created!");
storage::DataTable *table = catalog::Catalog::GetInstance()->GetTableWithName(
DEFAULT_DB_NAME, DEFUALT_SCHEMA_NAME, "department_table", txn);
txn_manager.CommitTransaction(txn);
txn = txn_manager.BeginTransaction();
traffic_cop.SetTcopTxnState(txn);
// Inserting a tuple end-to-end
LOG_INFO("Inserting a tuple...");
LOG_INFO(
"Query: INSERT INTO department_table(dept_id,dept_name) VALUES "
"(1,'hello_1');");
std::unique_ptr<Statement> statement;
statement.reset(new Statement(
"INSERT",
"INSERT INTO department_table(dept_id,dept_name) VALUES (1,'hello_1');"));
auto &peloton_parser = parser::PostgresParser::GetInstance();
LOG_INFO("Building parse tree...");
auto insert_stmt = peloton_parser.BuildParseTree(
"INSERT INTO department_table(dept_id,dept_name) VALUES (1,'hello_1');");
LOG_INFO("Building parse tree completed!");
LOG_INFO("Binding parse tree...");
auto parse_tree = insert_stmt->GetStatement(0);
auto bind_node_visitor = binder::BindNodeVisitor(txn, DEFAULT_DB_NAME);
bind_node_visitor.BindNameToNode(parse_tree);
LOG_INFO("Binding parse tree completed!");
LOG_INFO("Building plan tree...");
statement->SetPlanTree(optimizer->BuildPelotonPlanTree(insert_stmt, txn));
LOG_INFO("Building plan tree completed!");
std::vector<type::Value> params;
std::vector<ResultValue> result;
LOG_INFO("Executing plan...\n%s",
planner::PlanUtil::GetInfo(statement->GetPlanTree().get()).c_str());
std::vector<int> result_format;
result_format = std::vector<int>(0, 0);
TestingSQLUtil::counter_.store(1);
executor::ExecutionResult status = traffic_cop.ExecuteHelper(
statement->GetPlanTree(), params, result, result_format);
if (traffic_cop.GetQueuing()) {
TestingSQLUtil::ContinueAfterComplete();
traffic_cop.ExecuteStatementPlanGetResult();
status = traffic_cop.p_status_;
traffic_cop.SetQueuing(false);
}
LOG_INFO("Statement executed. Result: %s",
ResultTypeToString(status.m_result).c_str());
LOG_INFO("Tuple inserted!");
traffic_cop.CommitQueryHelper();
ShowTable(DEFAULT_DB_NAME, "department_table");
txn = txn_manager.BeginTransaction();
traffic_cop.SetTcopTxnState(txn);
LOG_INFO("Inserting a tuple...");
LOG_INFO(
"Query: INSERT INTO department_table(dept_id,dept_name) VALUES "
"(2,'hello_2');");
statement.reset(new Statement(
"INSERT",
"INSERT INTO department_table(dept_id,dept_name) VALUES (2,'hello_2');"));
LOG_INFO("Building parse tree...");
insert_stmt = peloton_parser.BuildParseTree(
"INSERT INTO department_table(dept_id,dept_name) VALUES (2,'hello_2');");
LOG_INFO("Building parse tree completed!");
LOG_INFO("Binding parse tree...");
parse_tree = insert_stmt->GetStatement(0);
bind_node_visitor = binder::BindNodeVisitor(txn, DEFAULT_DB_NAME);
bind_node_visitor.BindNameToNode(parse_tree);
LOG_INFO("Binding parse tree completed!");
LOG_INFO("Building plan tree...");
statement->SetPlanTree(optimizer->BuildPelotonPlanTree(insert_stmt, txn));
LOG_INFO("Building plan tree completed!\n%s",
planner::PlanUtil::GetInfo(statement->GetPlanTree().get()).c_str());
LOG_INFO("Executing plan...");
result_format = std::vector<int>(0, 0);
TestingSQLUtil::counter_.store(1);
status = traffic_cop.ExecuteHelper(statement->GetPlanTree(), params, result,
result_format);
if (traffic_cop.GetQueuing()) {
TestingSQLUtil::ContinueAfterComplete();
traffic_cop.ExecuteStatementPlanGetResult();
status = traffic_cop.p_status_;
traffic_cop.SetQueuing(false);
}
LOG_INFO("Statement executed. Result: %s",
ResultTypeToString(status.m_result).c_str());
LOG_INFO("Tuple inserted!");
traffic_cop.CommitQueryHelper();
ShowTable(DEFAULT_DB_NAME, "department_table");
txn = txn_manager.BeginTransaction();
traffic_cop.SetTcopTxnState(txn);
LOG_INFO("Inserting a tuple...");
LOG_INFO(
"Query: INSERT INTO department_table(dept_id,dept_name) VALUES "
"(3,'hello_2');");
statement.reset(new Statement(
"INSERT",
"INSERT INTO department_table(dept_id,dept_name) VALUES (3,'hello_2');"));
LOG_INFO("Building parse tree...");
insert_stmt = peloton_parser.BuildParseTree(
"INSERT INTO department_table(dept_id,dept_name) VALUES (3,'hello_2');");
LOG_INFO("Building parse tree completed!");
LOG_INFO("Binding parse tree...");
parse_tree = insert_stmt->GetStatement(0);
bind_node_visitor = binder::BindNodeVisitor(txn, DEFAULT_DB_NAME);
bind_node_visitor.BindNameToNode(parse_tree);
LOG_INFO("Binding parse tree completed!");
LOG_INFO("Building plan tree...");
statement->SetPlanTree(optimizer->BuildPelotonPlanTree(insert_stmt, txn));
LOG_INFO("Building plan tree completed!\n%s",
planner::PlanUtil::GetInfo(statement->GetPlanTree().get()).c_str());
LOG_INFO("Executing plan...");
result_format = std::vector<int>(0, 0);
TestingSQLUtil::counter_.store(1);
status = traffic_cop.ExecuteHelper(statement->GetPlanTree(), params, result,
result_format);
if (traffic_cop.GetQueuing()) {
TestingSQLUtil::ContinueAfterComplete();
traffic_cop.ExecuteStatementPlanGetResult();
status = traffic_cop.p_status_;
traffic_cop.SetQueuing(false);
}
LOG_INFO("Statement executed. Result: %s",
ResultTypeToString(status.m_result).c_str());
LOG_INFO("Tuple inserted!");
traffic_cop.CommitQueryHelper();
ShowTable(DEFAULT_DB_NAME, "department_table");
LOG_INFO("%s", table->GetInfo().c_str());
txn = txn_manager.BeginTransaction();
traffic_cop.SetTcopTxnState(txn);
// Just Counting number of tuples in table
LOG_INFO("Selecting MAX(dept_id)");
LOG_INFO("Query: SELECT MAX(dept_id) FROM department_table;");
statement.reset(
new Statement("MAX", "SELECT MAX(dept_id) FROM department_table;"));
LOG_INFO("Building parse tree...");
auto select_stmt = peloton_parser.BuildParseTree(
"SELECT MAX(dept_id) FROM department_table;");
LOG_INFO("Building parse tree completed!");
LOG_INFO("Binding parse tree...");
parse_tree = select_stmt->GetStatement(0);
bind_node_visitor = binder::BindNodeVisitor(txn, DEFAULT_DB_NAME);
bind_node_visitor.BindNameToNode(parse_tree);
LOG_INFO("Binding parse tree completed!");
LOG_INFO("Building plan tree...");
statement->SetPlanTree(optimizer->BuildPelotonPlanTree(select_stmt, txn));
LOG_INFO("Building plan tree completed!\n%s",
planner::PlanUtil::GetInfo(statement->GetPlanTree().get()).c_str());
LOG_INFO("Executing plan...");
auto tuple_descriptor =
traffic_cop.GenerateTupleDescriptor(select_stmt->GetStatement(0));
result_format = std::vector<int>(tuple_descriptor.size(), 0);
TestingSQLUtil::counter_.store(1);
status = traffic_cop.ExecuteHelper(statement->GetPlanTree(), params, result,
result_format);
if (traffic_cop.GetQueuing()) {
TestingSQLUtil::ContinueAfterComplete();
traffic_cop.ExecuteStatementPlanGetResult();
status = traffic_cop.p_status_;
traffic_cop.SetQueuing(false);
}
LOG_INFO("Statement executed. Result: %s",
ResultTypeToString(status.m_result).c_str());
LOG_INFO("Counted Tuples!");
traffic_cop.CommitQueryHelper();
txn = txn_manager.BeginTransaction();
traffic_cop.SetTcopTxnState(txn);
// Test Another delete. Should not find any tuple to be deleted
LOG_INFO("Deleting a tuple...");
LOG_INFO("Query: DELETE FROM department_table WHERE dept_id < 2");
statement.reset(new Statement(
"DELETE", "DELETE FROM department_table WHERE dept_id < 2"));
LOG_INFO("Building parse tree...");
auto delete_stmt_2 = peloton_parser.BuildParseTree(
"DELETE FROM department_table WHERE dept_id < 2");
LOG_INFO("Building parse tree completed!");
LOG_INFO("Binding parse tree...");
parse_tree = delete_stmt_2->GetStatement(0);
bind_node_visitor = binder::BindNodeVisitor(txn, DEFAULT_DB_NAME);
bind_node_visitor.BindNameToNode(parse_tree);
LOG_INFO("Binding parse tree completed!");
LOG_INFO("Building plan tree...");
statement->SetPlanTree(optimizer->BuildPelotonPlanTree(delete_stmt_2, txn));
LOG_INFO("Building plan tree completed!\n%s",
planner::PlanUtil::GetInfo(statement->GetPlanTree().get()).c_str());
LOG_INFO("Executing plan...");
result_format = std::vector<int>(0, 0);
TestingSQLUtil::counter_.store(1);
status = traffic_cop.ExecuteHelper(statement->GetPlanTree(), params, result,
result_format);
if (traffic_cop.GetQueuing()) {
TestingSQLUtil::ContinueAfterComplete();
traffic_cop.ExecuteStatementPlanGetResult();
status = traffic_cop.p_status_;
traffic_cop.SetQueuing(false);
}
LOG_INFO("Statement executed. Result: %s",
ResultTypeToString(status.m_result).c_str());
LOG_INFO("Tuple deleted!");
traffic_cop.CommitQueryHelper();
ShowTable(DEFAULT_DB_NAME, "department_table");
LOG_INFO("%s", table->GetInfo().c_str());
txn = txn_manager.BeginTransaction();
traffic_cop.SetTcopTxnState(txn);
// Now deleting end-to-end
LOG_INFO("Deleting a tuple...");
LOG_INFO("Query: DELETE FROM department_table");
statement.reset(new Statement("DELETE", "DELETE FROM department_table"));
LOG_INFO("Building parse tree...");
auto delete_stmt =
peloton_parser.BuildParseTree("DELETE FROM department_table");
LOG_INFO("Building parse tree completed!");
LOG_INFO("Binding parse tree...");
parse_tree = delete_stmt->GetStatement(0);
bind_node_visitor = binder::BindNodeVisitor(txn, DEFAULT_DB_NAME);
bind_node_visitor.BindNameToNode(parse_tree);
LOG_INFO("Binding parse tree completed!");
LOG_INFO("Building plan tree...");
statement->SetPlanTree(optimizer->BuildPelotonPlanTree(delete_stmt, txn));
LOG_INFO("Building plan tree completed!\n%s",
planner::PlanUtil::GetInfo(statement->GetPlanTree().get()).c_str());
LOG_INFO("Executing plan...");
result_format = std::vector<int>(0, 0);
TestingSQLUtil::counter_.store(1);
status = traffic_cop.ExecuteHelper(statement->GetPlanTree(), params, result,
result_format);
if (traffic_cop.GetQueuing()) {
TestingSQLUtil::ContinueAfterComplete();
traffic_cop.ExecuteStatementPlanGetResult();
status = traffic_cop.p_status_;
traffic_cop.SetQueuing(false);
}
LOG_INFO("Statement executed. Result: %s",
ResultTypeToString(status.m_result).c_str());
LOG_INFO("Tuple deleted!");
traffic_cop.CommitQueryHelper();
ShowTable(DEFAULT_DB_NAME, "department_table");
LOG_INFO("%s", table->GetInfo().c_str());
// free the database just created
txn = txn_manager.BeginTransaction();
catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn);
txn_manager.CommitTransaction(txn);
}
