void RunNewOrder(){
/*
"NEW_ORDER": {
"getWarehouseTaxRate": "SELECT W_TAX FROM WAREHOUSE WHERE W_ID = ?", # w_id
"getDistrict": "SELECT D_TAX, D_NEXT_O_ID FROM DISTRICT WHERE D_ID = ? AND D_W_ID = ?", # d_id, w_id
"getCustomer": "SELECT C_DISCOUNT, C_LAST, C_CREDIT FROM CUSTOMER WHERE C_W_ID = ? AND C_D_ID = ? AND C_ID = ?", # w_id, d_id, c_id
"incrementNextOrderId": "UPDATE DISTRICT SET D_NEXT_O_ID = ? WHERE D_ID = ? AND D_W_ID = ?", # d_next_o_id, d_id, w_id
"createOrder": "INSERT INTO ORDERS (O_ID, O_D_ID, O_W_ID, O_C_ID, O_ENTRY_D, O_CARRIER_ID, O_OL_CNT, O_ALL_LOCAL) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", # d_next_o_id, d_id, w_id, c_id, o_entry_d, o_carrier_id, o_ol_cnt, o_all_local
"createNewOrder": "INSERT INTO NEW_ORDER (NO_O_ID, NO_D_ID, NO_W_ID) VALUES (?, ?, ?)", # o_id, d_id, w_id
"getItemInfo": "SELECT I_PRICE, I_NAME, I_DATA FROM ITEM WHERE I_ID = ?", # ol_i_id
"getStockInfo": "SELECT S_QUANTITY, S_DATA, S_YTD, S_ORDER_CNT, S_REMOTE_CNT, S_DIST_%02d FROM STOCK WHERE S_I_ID = ? AND S_W_ID = ?", # d_id, ol_i_id, ol_supply_w_id
"updateStock": "UPDATE STOCK SET S_QUANTITY = ?, S_YTD = ?, S_ORDER_CNT = ?, S_REMOTE_CNT = ? WHERE S_I_ID = ? AND S_W_ID = ?", # s_quantity, s_order_cnt, s_remote_cnt, ol_i_id, ol_supply_w_id
"createOrderLine": "INSERT INTO ORDER_LINE (OL_O_ID, OL_D_ID, OL_W_ID, OL_NUMBER, OL_I_ID, OL_SUPPLY_W_ID, OL_DELIVERY_D, OL_QUANTITY, OL_AMOUNT, OL_DIST_INFO) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", # o_id, d_id, w_id, ol_number, ol_i_id, ol_supply_w_id, ol_quantity, ol_amount, ol_dist_info
}
*/
LOG_INFO("-------------------------------------");
int warehouse_id = GetRandomInteger(0, state.warehouse_count - 1);
int district_id = GetRandomInteger(0, state.districts_per_warehouse - 1);
//int customer_id = GetRandomInteger(0, state.customers_per_district);
int o_ol_cnt = GetRandomInteger(orders_min_ol_cnt, orders_max_ol_cnt);
//auto o_entry_ts = GetTimeStamp();
std::vector<int> i_ids, i_w_ids, i_qtys;
//bool o_all_local = true;
for (auto ol_itr = 0; ol_itr < o_ol_cnt; ol_itr++) {
i_ids.push_back(GetRandomInteger(0, state.item_count));
bool remote = GetRandomBoolean(new_order_remote_txns);
i_w_ids.push_back(warehouse_id);
if(remote == true) {
i_w_ids[ol_itr] = GetRandomIntegerExcluding(0, state.warehouse_count - 1, warehouse_id);
//o_all_local = false;
}
i_qtys.push_back(GetRandomInteger(0, order_line_max_ol_quantity));
}
auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
auto txn = txn_manager.BeginTransaction();
std::unique_ptr<VarlenPool> pool(new VarlenPool(BACKEND_TYPE_MM));
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(txn));
// getWarehouseTaxRate
std::vector<oid_t> warehouse_column_ids = {7}; // W_TAX
// Create and set up index scan executor
std::vector<oid_t> warehouse_key_column_ids = {0}; // W_ID
std::vector<ExpressionType> warehouse_expr_types;
std::vector<Value> warehouse_key_values;
std::vector<expression::AbstractExpression *> runtime_keys;
warehouse_expr_types.push_back(
ExpressionType::EXPRESSION_TYPE_COMPARE_EQUAL);
warehouse_key_values.push_back(ValueFactory::GetIntegerValue(warehouse_id));
auto warehouse_pkey_index = warehouse_table->GetIndexWithOid(
warehouse_table_pkey_index_oid);
planner::IndexScanPlan::IndexScanDesc warehouse_index_scan_desc(
warehouse_pkey_index, warehouse_key_column_ids, warehouse_expr_types,
warehouse_key_values, runtime_keys);
// Create plan node.
auto predicate = nullptr;
planner::IndexScanPlan warehouse_index_scan_node(warehouse_table, predicate,
warehouse_column_ids,
warehouse_index_scan_desc);
executor::IndexScanExecutor warehouse_index_scan_executor(&warehouse_index_scan_node,
context.get());
auto gwtr_lists_values = ExecuteTest(&warehouse_index_scan_executor);
if(gwtr_lists_values.empty() == true) {
LOG_ERROR("getWarehouseTaxRate failed");
txn_manager.AbortTransaction();
return;
}
auto w_tax = gwtr_lists_values[0][0];
LOG_TRACE("W_TAX: %d", w_tax);
// getDistrict
std::vector<oid_t> district_column_ids = {8, 10}; // D_TAX, D_NEXT_O_ID
// Create and set up index scan executor
std::vector<oid_t> district_key_column_ids = {0, 1}; // D_ID, D_W_ID
std::vector<ExpressionType> district_expr_types;
std::vector<Value> district_key_values;
district_expr_types.push_back(
ExpressionType::EXPRESSION_TYPE_COMPARE_EQUAL);
district_expr_types.push_back(
ExpressionType::EXPRESSION_TYPE_COMPARE_EQUAL);
district_key_values.push_back(ValueFactory::GetIntegerValue(district_id));
district_key_values.push_back(ValueFactory::GetIntegerValue(warehouse_id));
auto district_pkey_index = district_table->GetIndexWithOid(
district_table_pkey_index_oid);
planner::IndexScanPlan::IndexScanDesc district_index_scan_desc(
district_pkey_index, district_key_column_ids, district_expr_types,
district_key_values, runtime_keys);
// Create plan node.
planner::IndexScanPlan district_index_scan_node(district_table, predicate,
district_column_ids,
district_index_scan_desc);
executor::IndexScanExecutor district_index_scan_executor(&district_index_scan_node,
context.get());
auto gd_lists_values = ExecuteTest(&district_index_scan_executor);
if(gd_lists_values.empty() == true) {
LOG_ERROR("getDistrict failed");
txn_manager.AbortTransaction();
return;
}
auto d_tax = gd_lists_values[0][0];
LOG_TRACE("D_TAX: %d", d_tax);
auto d_next_o_id = gd_lists_values[0][1];
LOG_TRACE("D_NEXT_O_ID: %d", d_next_o_id);
// incrementNextOrderId
txn_manager.CommitTransaction();
}
bool RunStockLevel(const size_t &thread_id) {
/*
"STOCK_LEVEL": {
"getOId": "SELECT D_NEXT_O_ID FROM DISTRICT WHERE D_W_ID = ? AND D_ID = ?",
"getStockCount": "SELECT COUNT(DISTINCT(OL_I_ID)) FROM ORDER_LINE, STOCK WHERE OL_W_ID = ? AND OL_D_ID = ? AND OL_O_ID < ? AND OL_O_ID >= ? AND S_W_ID = ? AND S_I_ID = OL_I_ID AND S_QUANTITY < ?
}
*/
auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
auto txn = txn_manager.BeginTransaction();
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(txn));
// Prepare random data
int w_id = GenerateWarehouseId(thread_id);
int d_id = GetRandomInteger(0, state.districts_per_warehouse - 1);
int threshold = GetRandomInteger(stock_min_threshold, stock_max_threshold);
LOG_TRACE("getOId: SELECT D_NEXT_O_ID FROM DISTRICT WHERE D_W_ID = ? AND D_ID = ?");
// Construct index scan executor
std::vector<oid_t> district_column_ids = {COL_IDX_D_NEXT_O_ID};
std::vector<oid_t> district_key_column_ids = {COL_IDX_D_W_ID, COL_IDX_D_ID};
std::vector<ExpressionType> district_expr_types;
std::vector<common::Value *> district_key_values;
std::vector<expression::AbstractExpression *> runtime_keys;
district_expr_types.push_back(ExpressionType::EXPRESSION_TYPE_COMPARE_EQUAL);
district_key_values.push_back(common::ValueFactory::GetIntegerValue(w_id).Copy());
district_expr_types.push_back(ExpressionType::EXPRESSION_TYPE_COMPARE_EQUAL);
district_key_values.push_back(common::ValueFactory::GetIntegerValue(d_id).Copy());
auto district_pkey_index = district_table->GetIndexWithOid(district_table_pkey_index_oid);
planner::IndexScanPlan::IndexScanDesc district_index_scan_desc(
district_pkey_index, district_key_column_ids, district_expr_types,
district_key_values, runtime_keys
);
expression::AbstractExpression *predicate = nullptr;
planner::IndexScanPlan district_index_scan_node(
district_table, predicate,
district_column_ids, district_index_scan_desc
);
executor::IndexScanExecutor district_index_scan_executor(&district_index_scan_node, context.get());
auto districts = ExecuteRead(&district_index_scan_executor);
if (txn->GetResult() != Result::RESULT_SUCCESS) {
txn_manager.AbortTransaction(txn);
return false;
}
if (districts.size() != 1) {
LOG_ERROR("incorrect districts size : %lu", districts.size());
PL_ASSERT(false);
}
common::Value * o_id = districts[0][0];
LOG_TRACE("getStockCount: SELECT COUNT(DISTINCT(OL_I_ID)) FROM ORDER_LINE, STOCK WHERE OL_W_ID = ? AND OL_D_ID = ? AND OL_O_ID < ? AND OL_O_ID >= ? AND S_W_ID = ? AND S_I_ID = OL_I_ID AND S_QUANTITY < ?");
int max_o_id = common::ValuePeeker::PeekInteger(o_id);
int min_o_id = max_o_id - 20;
//////////////////////////////////////////////////////////////
std::vector<oid_t> order_line_column_ids = {COL_IDX_OL_I_ID};
std::vector<oid_t> order_line_key_column_ids = {COL_IDX_OL_W_ID, COL_IDX_OL_D_ID, COL_IDX_OL_O_ID};
std::vector<ExpressionType> order_line_expr_types;
order_line_expr_types.push_back(ExpressionType::EXPRESSION_TYPE_COMPARE_EQUAL);
order_line_expr_types.push_back(ExpressionType::EXPRESSION_TYPE_COMPARE_EQUAL);
order_line_expr_types.push_back(ExpressionType::EXPRESSION_TYPE_COMPARE_EQUAL);
auto order_line_skey_index = order_line_table->GetIndexWithOid(order_line_table_skey_index_oid);
//////////////////////////////////////////////////////////////
std::vector<oid_t> stock_column_ids = {COL_IDX_S_QUANTITY};
std::vector<oid_t> stock_key_column_ids = {COL_IDX_S_W_ID, COL_IDX_S_I_ID};
std::vector<ExpressionType> stock_expr_types;
stock_expr_types.push_back(ExpressionType::EXPRESSION_TYPE_COMPARE_EQUAL);
stock_expr_types.push_back(ExpressionType::EXPRESSION_TYPE_COMPARE_EQUAL);
auto stock_pkey_index = stock_table->GetIndexWithOid(stock_table_pkey_index_oid);
//////////////////////////////////////////////////////////////
std::unordered_set<int> distinct_items;
for (int curr_o_id = min_o_id; curr_o_id < max_o_id; ++curr_o_id) {
////////////////////////////////////////////////////////////////
/////////// Construct left table index scan ////////////////////
////////////////////////////////////////////////////////////////
std::vector<common::Value *> order_line_key_values;
order_line_key_values.push_back(common::ValueFactory::GetIntegerValue(w_id).Copy());
order_line_key_values.push_back(common::ValueFactory::GetIntegerValue(d_id).Copy());
order_line_key_values.push_back(common::ValueFactory::GetIntegerValue(curr_o_id).Copy());
planner::IndexScanPlan::IndexScanDesc order_line_index_scan_desc(
order_line_skey_index, order_line_key_column_ids, order_line_expr_types,
order_line_key_values, runtime_keys);
planner::IndexScanPlan order_line_index_scan_node(order_line_table,
nullptr, order_line_column_ids, order_line_index_scan_desc);
executor::IndexScanExecutor order_line_index_scan_executor(&order_line_index_scan_node, context.get());
auto order_line_values = ExecuteRead(&order_line_index_scan_executor);
if (txn->GetResult() != Result::RESULT_SUCCESS) {
LOG_TRACE("abort transaction");
txn_manager.AbortTransaction(txn);
return false;
}
if (order_line_values.size() == 0) {
LOG_TRACE("order line return size incorrect : %lu", order_line_values.size());
continue;
}
auto item_id = order_line_values[0][0];
LOG_TRACE("item_id: %s", item_id.GetInfo().c_str());
//////////////////////////////////////////////////////////////////
///////////// Construct right table index scan ///////////////////
//////////////////////////////////////////////////////////////////
std::vector<common::Value *> stock_key_values;
stock_key_values.push_back(common::ValueFactory::GetIntegerValue(w_id).Copy());
stock_key_values.push_back(item_id);
planner::IndexScanPlan::IndexScanDesc stock_index_scan_desc(
stock_pkey_index, stock_key_column_ids, stock_expr_types,
stock_key_values, runtime_keys);
// Add predicate S_QUANTITY < threshold
planner::IndexScanPlan stock_index_scan_node(stock_table, nullptr,
stock_column_ids,
stock_index_scan_desc);
executor::IndexScanExecutor stock_index_scan_executor(&stock_index_scan_node, context.get());
auto stock_values = ExecuteRead(&stock_index_scan_executor);
if (txn->GetResult() != Result::RESULT_SUCCESS) {
LOG_TRACE("abort transaction");
txn_manager.AbortTransaction(txn);
return false;
}
if (stock_values.size() == 0) {
// LOG_ERROR("stock return size incorrect : %lu", order_line_values.size());
continue;
}
auto quantity = stock_values[0][0];
if (common::ValuePeeker::PeekInteger(quantity) < threshold) {
distinct_items.insert(common::ValuePeeker::PeekInteger(item_id));
}
}
LOG_TRACE("number of distinct items=%lu", distinct_items.size());
PL_ASSERT(txn->GetResult() == Result::RESULT_SUCCESS);
auto result = txn_manager.CommitTransaction(txn);
if (result == Result::RESULT_SUCCESS) {
return true;
} else {
return false;
}
return true;
}
