From 76dbe0a612722d4177094913c74783258dce052d Mon Sep 17 00:00:00 2001 From: lihongyu <1162914749@qq.com> Date: Thu, 18 Jul 2024 14:49:54 +0800 Subject: [PATCH] Add time interval between SQL executions --- src/dbtest/src/common.h | 1 + src/dbtest/src/sql_cntl.cc | 32 +++++++++++++++++++++------- src/dbtest/src/sql_cntl.h | 5 +++++ src/dbtest/src/sql_cntl_v2.cc | 40 ++++++++++++++++++++++++++++------- src/dbtest/src/sqltest.cc | 4 ++++ src/dbtest/src/sqltest_v2.cc | 4 ++++ 6 files changed, 70 insertions(+), 16 deletions(-) diff --git a/src/dbtest/src/common.h b/src/dbtest/src/common.h index 1fc7b049..f38b630e 100644 --- a/src/dbtest/src/common.h +++ b/src/dbtest/src/common.h @@ -23,6 +23,7 @@ #include #include #include +#include extern std::string dash; extern int blank_base; diff --git a/src/dbtest/src/sql_cntl.cc b/src/dbtest/src/sql_cntl.cc index 16958d24..8fd98463 100644 --- a/src/dbtest/src/sql_cntl.cc +++ b/src/dbtest/src/sql_cntl.cc @@ -221,6 +221,8 @@ bool DBConnector::ExecWriteSql(int sql_id, const std::string& sql, TestResultSet test_process << output_info << std::endl; } } + // sleep for sql_exec_interval_ ms + std::this_thread::sleep_for(std::chrono::milliseconds(sql_exec_interval_)); ret = SQLExecDirect(m_hStatement, (SQLCHAR*)sql.c_str(), SQL_NTS); std::string err_info_sql = DBConnector::SqlExecuteErr(session_id, sql_id, sql, "stmt", m_hStatement, ret, test_process_file); SQLFreeStmt( m_hStatement, SQL_UNBIND); @@ -248,9 +250,10 @@ bool DBConnector::ExecWriteSql(int sql_id, const std::string& sql, TestResultSet if (sql_id != 1024 && sql_id !=0) { std::string blank(blank_base*(session_id - 1), ' '); std::string output_time_info = blank + "Q" + std::to_string(sql_id) + " finished at: " + get_current_time() ; - std::cout << output_time_info << std::endl; + std::string output_exec_interval_info = blank + "Q" + std::to_string(sql_id) + " sql execution interval: " + std::to_string(sql_exec_interval_) + "ms"; + std::cout << output_time_info << std::endl << output_exec_interval_info << std::endl; std::ofstream test_process(test_process_file, std::ios::app); - test_process << output_time_info << std::endl; + test_process << output_time_info << std::endl << output_exec_interval_info << std::endl; } } return true; @@ -298,6 +301,8 @@ bool DBConnector::ExecReadSql2Int(int sql_id, const std::string& sql, TestResult std::ofstream test_process(test_process_file, std::ios::app); test_process << output_info << std::endl; } + // sleep for sql_exec_interval_ ms + std::this_thread::sleep_for(std::chrono::milliseconds(sql_exec_interval_)); // Execute the SQL statement using SQLExecDirect function ret = SQLExecDirect(m_hStatement, (SQLCHAR*)sql.c_str(), SQL_NTS); // parse result @@ -340,9 +345,10 @@ bool DBConnector::ExecReadSql2Int(int sql_id, const std::string& sql, TestResult outputter.PrintAndWriteTxnSqlResult(cur_result_set[sql_id], expected_result_set_list, sql_id, sql, session_id, test_process_file); if (sql_id != 1024 && sql_id !=0) { std::string output_time_info = blank + "Q" + std::to_string(sql_id) + " finished at: " + get_current_time() ; - std::cout << output_time_info << std::endl; + std::string output_exec_interval_info = blank + "Q" + std::to_string(sql_id) + " sql execution interval: " + std::to_string(sql_exec_interval_) + "ms"; + std::cout << output_time_info << std::endl << output_exec_interval_info << std::endl; std::ofstream test_process(test_process_file, std::ios::app); - test_process << output_time_info << std::endl; + test_process << output_time_info << std::endl << output_exec_interval_info << std::endl; } SQLFreeStmt( m_hStatement, SQL_UNBIND); SQLFreeStmt( m_hStatement, SQL_DROP); @@ -410,13 +416,19 @@ bool DBConnector::SQLEndTnx(std::string opt, int session_id, int sql_id, TestRes SQLHDBC m_hDatabaseConnection = DBConnector::conn_pool_[session_id - 1]; // If the operation is "commit," perform a commit. if ("commit" == opt) { + // sleep for sql_exec_interval_ ms + std::this_thread::sleep_for(std::chrono::milliseconds(sql_exec_interval_)); ret = SQLEndTran(SQL_HANDLE_DBC, m_hDatabaseConnection, SQL_COMMIT); // If the operation is "rollback" and the database type is not "crdb," perform a rollback. Otherwise, execute the rollback SQL command specific to "crdb." } else if ("rollback" == opt) { if (db_type != "crdb"){ + // sleep for sql_exec_interval_ ms + std::this_thread::sleep_for(std::chrono::milliseconds(sql_exec_interval_)); ret = SQLEndTran(SQL_HANDLE_DBC, m_hDatabaseConnection, SQL_ROLLBACK); } else { std::string sql = "ROLLBACK TRANSCATION;"; + // sleep for sql_exec_interval_ ms + std::this_thread::sleep_for(std::chrono::milliseconds(sql_exec_interval_)); if (!DBConnector::ExecWriteSql(1024, sql, test_result_set, session_id, test_process_file)) { return false; } @@ -438,9 +450,10 @@ bool DBConnector::SQLEndTnx(std::string opt, int session_id, int sql_id, TestRes if (sql_id != 1024 && sql_id !=0) { std::string blank(blank_base*(session_id - 1), ' '); std::string output_time_info = blank + "Q" + std::to_string(sql_id) + " finished at: " + get_current_time() ; - std::cout << output_time_info << std::endl; + std::string output_exec_interval_info = blank + "Q" + std::to_string(sql_id) + " sql execution interval: " + std::to_string(sql_exec_interval_) + "ms"; + std::cout << output_time_info << std::endl << output_exec_interval_info << std::endl; std::ofstream test_process(test_process_file, std::ios::app); - test_process << output_time_info << std::endl; + test_process << output_time_info << std::endl << output_exec_interval_info << std::endl; } } // Oracle database handling: If db_type is "oracle," directly execute the provided opt SQL command. @@ -464,6 +477,8 @@ bool DBConnector::SQLEndTnx(std::string opt, int session_id, int sql_id, TestRes bool DBConnector::SQLStartTxn(int session_id, int sql_id, std::string test_process_file) { SQLHDBC m_hDatabaseConnection = DBConnector::conn_pool_[session_id - 1]; std::ofstream test_process(test_process_file, std::ios::app); + // sleep for sql_exec_interval_ ms + std::this_thread::sleep_for(std::chrono::milliseconds(sql_exec_interval_)); // To start a transaction, the function calls DBConnector::SetAutoCommit with the value 0, which means it turns off the auto-commit mode for the database connection. Turning off auto-commit mode means that any changes made during the transaction are not committed until explicitly requested. If the function fails to turn off auto-commit mode, it logs an error message and returns false. if(!DBConnector::SetAutoCommit(m_hDatabaseConnection, 0)) { std::string blank(blank_base*(session_id - 1), ' '); @@ -484,8 +499,9 @@ bool DBConnector::SQLStartTxn(int session_id, int sql_id, std::string test_proce // } if (sql_id != 1024 && sql_id !=0) { std::string output_time_info = blank + "Q" + std::to_string(sql_id) + " finished at: " + get_current_time() ; - std::cout << output_time_info << std::endl; - test_process << output_time_info << std::endl; + std::string output_exec_interval_info = blank + "Q" + std::to_string(sql_id) + " sql execution interval: " + std::to_string(sql_exec_interval_) + "ms"; + std::cout << output_time_info << std::endl << output_exec_interval_info << std::endl; + test_process << output_time_info << std::endl << output_exec_interval_info << std::endl; } return true; } diff --git a/src/dbtest/src/sql_cntl.h b/src/dbtest/src/sql_cntl.h index 153cc989..ad1334c4 100644 --- a/src/dbtest/src/sql_cntl.h +++ b/src/dbtest/src/sql_cntl.h @@ -18,6 +18,9 @@ class DBConnector { private: // Each SQLHDBC is a handle for a single database connection. std::vector conn_pool_; + + // Time interval between two sql executions + int sql_exec_interval_ = 0; public: // Initializes the database connector, stablishes a specified number of database connections and adds them to the connection pool. bool InitDBConnector(std::string& user, std::string& passwd, std::string& db_type, int conn_pool_size) { @@ -73,6 +76,8 @@ class DBConnector { bool SetAutoCommit(SQLHDBC m_hDatabaseConnection, int opt); // Set a timeout for a specific database connection. bool SetTimeout(int conn_id, std::string timeout, const std::string& db_type); + // Set the time interval between two SQL executions. + void SetSqlExecInterval(int sql_exec_interval) {sql_exec_interval_ = sql_exec_interval;}; // Execute an SQL statement for reading and store the result as an integer. bool ExecReadSql2Int(int sql_id, const std::string& sql, TestResultSet& test_result_set, std::unordered_map>& cur_result_set, int conn_id, int param_num, std::string test_process_file=""); diff --git a/src/dbtest/src/sql_cntl_v2.cc b/src/dbtest/src/sql_cntl_v2.cc index 73236cbb..8fc938e2 100644 --- a/src/dbtest/src/sql_cntl_v2.cc +++ b/src/dbtest/src/sql_cntl_v2.cc @@ -244,6 +244,8 @@ bool DBConnector::ExecWriteSql(int sql_id, const std::string& sql, TestResultSet } } SQLLEN row_count=-1; + // sleep for sql_exec_interval_ ms + std::this_thread::sleep_for(std::chrono::milliseconds(sql_exec_interval_)); ret = SQLExecDirect(m_hStatement, (SQLCHAR*)sql.c_str(), SQL_NTS); SQLRowCount(m_hStatement,&row_count); // std::cout << "row_count" << row_count << std::endl; @@ -280,9 +282,12 @@ bool DBConnector::ExecWriteSql(int sql_id, const std::string& sql, TestResultSet if (sql_id != 1024 && sql_id !=0) { std::string blank(blank_base*(session_id - 1), ' '); std::string output_time_info = blank + "Q" + std::to_string(sql_id) + "-T" + std::to_string(session_id) + " finished at: " + get_current_time() ; - std::cout << output_time_info << std::endl; + std::string output_exec_interval_info = blank + "Q" + std::to_string(sql_id) + + "-T" + std::to_string(session_id) + + " sql execution interval: " + std::to_string(sql_exec_interval_) + "ms"; + std::cout << output_time_info << std::endl << output_exec_interval_info << std::endl; std::ofstream test_process(test_process_file, std::ios::app); - test_process << output_time_info << std::endl; + test_process << output_time_info << std::endl << output_exec_interval_info << std::endl; } } @@ -333,6 +338,8 @@ bool DBConnector::ExecReadSql2Int(int sql_id, const std::string& sql, TestResult std::ofstream test_process(test_process_file, std::ios::app); test_process << output_info << std::endl; } + // sleep for sql_exec_interval_ ms + std::this_thread::sleep_for(std::chrono::milliseconds(sql_exec_interval_)); // Execute the SQL statement using SQLExecDirect function ret = SQLExecDirect(m_hStatement, (SQLCHAR*)sql.c_str(), SQL_NTS); // parse result @@ -375,9 +382,12 @@ bool DBConnector::ExecReadSql2Int(int sql_id, const std::string& sql, TestResult outputter.PrintAndWriteTxnSqlResult(cur_result_set[sql_id], expected_result_set_list, sql_id, sql, session_id, test_process_file); if (sql_id != 1024 && sql_id !=0) { std::string output_time_info = blank + "Q" + std::to_string(sql_id) + "-T" + std::to_string(session_id) + " finished at: " + get_current_time() ; - std::cout << output_time_info << std::endl; + std::string output_exec_interval_info = blank + "Q" + std::to_string(sql_id) + + "-T" + std::to_string(session_id) + + " sql execution interval: " + std::to_string(sql_exec_interval_) + "ms"; + std::cout << output_time_info << std::endl << output_exec_interval_info << std::endl; std::ofstream test_process(test_process_file, std::ios::app); - test_process << output_time_info << std::endl; + test_process << output_time_info << std::endl << output_exec_interval_info << std::endl; } SQLFreeStmt( m_hStatement, SQL_UNBIND); SQLFreeStmt( m_hStatement, SQL_DROP); @@ -447,13 +457,19 @@ bool DBConnector::SQLEndTnx(std::string opt, int session_id, int sql_id, TestRes SQLRETURN ret; SQLHDBC m_hDatabaseConnection = DBConnector::conn_pool_[session_id - 1]; if ("commit" == opt) { + // sleep for sql_exec_interval_ ms + std::this_thread::sleep_for(std::chrono::milliseconds(sql_exec_interval_)); ret = SQLEndTran(SQL_HANDLE_DBC, m_hDatabaseConnection, SQL_COMMIT); } else if ("rollback" == opt) { if (db_type != "crdb"){ + // sleep for sql_exec_interval_ ms + std::this_thread::sleep_for(std::chrono::milliseconds(sql_exec_interval_)); ret = SQLEndTran(SQL_HANDLE_DBC, m_hDatabaseConnection, SQL_ROLLBACK); } else { std::string sql = "ROLLBACK TRANSCATION;"; // std::cout << sql << std::endl; + // sleep for sql_exec_interval_ ms + std::this_thread::sleep_for(std::chrono::milliseconds(sql_exec_interval_)); if (!DBConnector::ExecWriteSql(1024, sql, test_result_set, session_id, test_process_file)) { return false; } @@ -474,9 +490,12 @@ bool DBConnector::SQLEndTnx(std::string opt, int session_id, int sql_id, TestRes if (sql_id != 1024 && sql_id !=0) { std::string blank(blank_base*(session_id - 1), ' '); std::string output_time_info = blank + "Q" + std::to_string(sql_id) + "-T" + std::to_string(session_id) + " finished at: " + get_current_time() ; - std::cout << output_time_info << std::endl; + std::string output_exec_interval_info = blank + "Q" + std::to_string(sql_id) + + "-T" + std::to_string(session_id) + + " sql execution interval: " + std::to_string(sql_exec_interval_) + "ms"; + std::cout << output_time_info << std::endl << output_exec_interval_info << std::endl; std::ofstream test_process(test_process_file, std::ios::app); - test_process << output_time_info << std::endl; + test_process << output_time_info << std::endl << output_exec_interval_info << std::endl; } } } else { @@ -515,6 +534,8 @@ bool DBConnector::SQLEndTnx(std::string opt, int session_id, int sql_id, TestRes bool DBConnector::SQLStartTxn(int session_id, int sql_id, std::string test_process_file) { SQLHDBC m_hDatabaseConnection = DBConnector::conn_pool_[session_id - 1]; std::ofstream test_process(test_process_file, std::ios::app); + // sleep for sql_exec_interval_ ms + std::this_thread::sleep_for(std::chrono::milliseconds(sql_exec_interval_)); if(!DBConnector::SetAutoCommit(m_hDatabaseConnection, 0)) { std::string blank(blank_base*(session_id - 1), ' '); std::string output_info = blank + "Q" + std::to_string(sql_id) + "-T" + std::to_string(session_id) + " begin failed"; @@ -533,8 +554,11 @@ bool DBConnector::SQLStartTxn(int session_id, int sql_id, std::string test_proce // } if (sql_id != 1024 && sql_id !=0) { std::string output_time_info = blank + "Q" + std::to_string(sql_id) + "-T" + std::to_string(session_id) + " finished at: " + get_current_time() ; - std::cout << output_time_info << std::endl; - test_process << output_time_info << std::endl; + std::string output_exec_interval_info = blank + "Q" + std::to_string(sql_id) + + "-T" + std::to_string(session_id) + + " sql execution interval: " + std::to_string(sql_exec_interval_) + "ms"; + std::cout << output_time_info << std::endl << output_exec_interval_info << std::endl; + test_process << output_time_info << std::endl << output_exec_interval_info << std::endl; } return true; } diff --git a/src/dbtest/src/sqltest.cc b/src/dbtest/src/sqltest.cc index 30d7a110..54b4f2e1 100644 --- a/src/dbtest/src/sqltest.cc +++ b/src/dbtest/src/sqltest.cc @@ -24,6 +24,7 @@ DEFINE_int32(conn_pool_size, 6, "db_conn pool size"); DEFINE_string(isolation, "serializable", "transation isolation level: read-uncommitted read-committed repeatable-read serializable"); DEFINE_string(case_dir, "mysql", "test case dir name"); DEFINE_string(timeout, "20", "timeout"); +DEFINE_int32(sql_interval, 0, "interval time between sql executions"); // std::vector mutex_txn(5); // same as conn_pool_size std::vector mutex_txn(FLAGS_conn_pool_size); // same as conn_pool_size @@ -416,6 +417,7 @@ int main(int argc, char* argv[]) { std::cout << " user: " + FLAGS_user << std::endl; std::cout << " passwd: " + FLAGS_passwd << std::endl; std::cout << " isolation: " + FLAGS_isolation << std::endl; + std::cout << " sql interval: " + std::to_string(FLAGS_sql_interval) << std::endl; // mutex for txn for(int i=0;i mutex_txn(FLAGS_conn_pool_size); // same as conn_pool_size @@ -373,6 +374,7 @@ int main(int argc, char* argv[]) { std::cout << " user: " + FLAGS_user << std::endl; std::cout << " passwd: " + FLAGS_passwd << std::endl; std::cout << " isolation: " + FLAGS_isolation << std::endl; + std::cout << " sql interval: " + std::to_string(FLAGS_sql_interval) << std::endl; // mutex for txn for(int i=0;i