MySQLConnection Class Reference

#include <MySQLConnection.h>

Public Member Functions
	MySQLConnection (MySQLConnectionInfo &connInfo)
	MySQLConnection (ProducerConsumerQueue< SQLOperation * > *queue, MySQLConnectionInfo &connInfo)
	Constructor for synchronous connections. More...
virtual	~MySQLConnection ()
	Constructor for asynchronous connections. More...
virtual uint32	Open ()
void	Close ()
bool	PrepareStatements ()
bool	Execute (char const *sql)
bool	Execute (PreparedStatementBase *stmt)
ResultSet *	Query (char const *sql)
PreparedResultSet *	Query (PreparedStatementBase *stmt)
bool	_Query (char const *sql, MySQLResult **pResult, MySQLField **pFields, uint64 *pRowCount, uint32 *pFieldCount)
bool	_Query (PreparedStatementBase *stmt, MySQLPreparedStatement **mysqlStmt, MySQLResult **pResult, uint64 *pRowCount, uint32 *pFieldCount)
void	BeginTransaction ()
void	RollbackTransaction ()
void	CommitTransaction ()
int	ExecuteTransaction (std::shared_ptr< TransactionBase > transaction)
size_t	EscapeString (char *to, const char *from, size_t length)
void	Ping ()
uint32	GetLastError ()

Protected Types
typedef std::vector< std::unique_ptr< MySQLPreparedStatement > >	PreparedStatementContainer

Protected Member Functions
bool	LockIfReady ()
void	Unlock ()
	Called by parent databasepool. Will let other threads access this connection. More...
uint32	GetServerVersion () const
MySQLPreparedStatement *	GetPreparedStatement (uint32 index)
void	PrepareStatement (uint32 index, std::string_view sql, ConnectionFlags flags)
virtual void	DoPrepareStatements ()=0

Protected Attributes
PreparedStatementContainer	m_stmts
bool	m_reconnecting
	PreparedStatements storage. More...
bool	m_prepareError
	Are we reconnecting? More...

Private Member Functions
bool	_HandleMySQLErrno (uint32 errNo, uint8 attempts=5)
	Was there any error while preparing statements? More...
	MySQLConnection (MySQLConnection const &right)=delete
MySQLConnection &	operator= (MySQLConnection const &right)=delete

Private Attributes
ProducerConsumerQueue< SQLOperation * > *	m_queue
std::unique_ptr< DatabaseWorker >	m_worker
	Queue shared with other asynchronous connections. More...
MySQLHandle *	m_Mysql
	Core worker task. More...
MySQLConnectionInfo &	m_connectionInfo
	MySQL Handle. More...
ConnectionFlags	m_connectionFlags
	Connection info (used for logging) More...
std::mutex	m_Mutex
	Connection flags (for preparing relevant statements) More...

Friends
template<class T >
class	DatabaseWorkerPool
class	PingOperation

Detailed Description

Definition at line 54 of file MySQLConnection.h.

Member Typedef Documentation

PreparedStatementContainer

typedef std::vector<std::unique_ptr<MySQLPreparedStatement> > MySQLConnection::PreparedStatementContainer

protected

Definition at line 99 of file MySQLConnection.h.

Constructor & Destructor Documentation

MySQLConnection() [1/3]

MySQLConnection::MySQLConnection

(

MySQLConnectionInfo &

connInfo

)

Definition at line 50 of file MySQLConnection.cpp.

 :
m_reconnecting(false),
m_prepareError(false),
m_queue(nullptr),
m_Mysql(nullptr),
m_connectionInfo(connInfo),
m_connectionFlags(CONNECTION_SYNCH) { }

MySQLConnection() [2/3]

MySQLConnection::MySQLConnection	(	ProducerConsumerQueue< SQLOperation * > *	queue,
		MySQLConnectionInfo &	connInfo
	)

Constructor for synchronous connections.

Definition at line 58 of file MySQLConnection.cpp.

 :
m_reconnecting(false),
m_prepareError(false),
m_queue(queue),
m_Mysql(nullptr),
m_connectionInfo(connInfo),
m_connectionFlags(CONNECTION_ASYNC)
{
 m_worker = std::make_unique<DatabaseWorker>(m_queue, this);
}

~MySQLConnection()

MySQLConnection::~MySQLConnection ( )

virtual

Constructor for asynchronous connections.

Definition at line 69 of file MySQLConnection.cpp.

{
 Close();
}

Here is the call graph for this function:

MySQLConnection() [3/3]

MySQLConnection::MySQLConnection ( MySQLConnection const &  right )

privatedelete

Member Function Documentation

_HandleMySQLErrno()

bool MySQLConnection::_HandleMySQLErrno ( uint32  errNo, uint8  attempts = 5  )

private

Was there any error while preparing statements?

Definition at line 531 of file MySQLConnection.cpp.

{
 switch (errNo)
 {
 case CR_SERVER_GONE_ERROR:
 case CR_SERVER_LOST:
 case CR_SERVER_LOST_EXTENDED:
 {
 if (m_Mysql)
 {
 TC_LOG_ERROR("sql.sql", "Lost the connection to the MySQL server!");
 
 mysql_close(m_Mysql);
 m_Mysql = nullptr;
 }
 [[fallthrough]];
 }
 case CR_CONN_HOST_ERROR:
 {
 TC_LOG_INFO("sql.sql", "Attempting to reconnect to the MySQL server...");
 
 m_reconnecting = true;
 
 uint32 const lErrno = Open();
 if (!lErrno)
 {
 // Don't remove 'this' pointer unless you want to skip loading all prepared statements...
 if (!this->PrepareStatements())
 {
 TC_LOG_FATAL("sql.sql", "Could not re-prepare statements!");
 std::this_thread::sleep_for(std::chrono::seconds(10));
 std::abort();
 }
 
 TC_LOG_INFO("sql.sql", "Successfully reconnected to {} @{}:{} ({}).",
 m_connectionInfo.database, m_connectionInfo.host, m_connectionInfo.port_or_socket,
 (m_connectionFlags & CONNECTION_ASYNC) ? "asynchronous" : "synchronous");
 
 m_reconnecting = false;
 return true;
 }
 
 if ((--attempts) == 0)
 {
 // Shut down the server when the mysql server isn't
 // reachable for some time
 TC_LOG_FATAL("sql.sql", "Failed to reconnect to the MySQL server, "
 "terminating the server to prevent data corruption!");
 
 // We could also initiate a shutdown through using std::raise(SIGTERM)
 std::this_thread::sleep_for(std::chrono::seconds(10));
 std::abort();
 }
 else
 {
 // It's possible this attempted reconnect throws 2006 at us.
 // To prevent crazy recursive calls, sleep here.
 std::this_thread::sleep_for(std::chrono::seconds(3)); // Sleep 3 seconds
 return _HandleMySQLErrno(lErrno, attempts); // Call self (recursive)
 }
 }
 
 case ER_LOCK_DEADLOCK:
 return false; // Implemented in TransactionTask::Execute and DatabaseWorkerPool<T>::DirectCommitTransaction
 // Query related errors - skip query
 case ER_WRONG_VALUE_COUNT:
 case ER_DUP_ENTRY:
 return false;
 
 // Outdated table or database structure - terminate core
 case ER_BAD_FIELD_ERROR:
 case ER_NO_SUCH_TABLE:
 TC_LOG_ERROR("sql.sql", "Your database structure is not up to date. Please make sure you've executed all queries in the sql/updates folders.");
 std::this_thread::sleep_for(std::chrono::seconds(10));
 std::abort();
 return false;
 case ER_PARSE_ERROR:
 TC_LOG_ERROR("sql.sql", "Error while parsing SQL. Core fix required.");
 std::this_thread::sleep_for(std::chrono::seconds(10));
 std::abort();
 return false;
 default:
 TC_LOG_ERROR("sql.sql", "Unhandled MySQL errno {}. Unexpected behaviour possible.", errNo);
 return false;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Query() [1/2]

bool MySQLConnection::_Query	(	char const *	sql,
		MySQLResult **	pResult,
		MySQLField **	pFields,
		uint64 *	pRowCount,
		uint32 *	pFieldCount
	)

Definition at line 333 of file MySQLConnection.cpp.

{
 if (!m_Mysql)
 return false;
 
 {
 uint32 _s = getMSTime();
 
 if (mysql_query(m_Mysql, sql))
 {
 uint32 lErrno = mysql_errno(m_Mysql);
 TC_LOG_INFO("sql.sql", "SQL: {}", sql);
 TC_LOG_ERROR("sql.sql", "[{}] {}", lErrno, mysql_error(m_Mysql));
 
 if (_HandleMySQLErrno(lErrno)) // If it returns true, an error was handled successfully (i.e. reconnection)
 return _Query(sql, pResult, pFields, pRowCount, pFieldCount); // We try again
 
 return false;
 }
 else
 TC_LOG_DEBUG("sql.sql", "[{} ms] SQL: {}", getMSTimeDiff(_s, getMSTime()), sql);
 
 *pResult = reinterpret_cast<MySQLResult*>(mysql_store_result(m_Mysql));
 *pRowCount = mysql_affected_rows(m_Mysql);
 *pFieldCount = mysql_field_count(m_Mysql);
 }
 
 if (!*pResult )
 return false;
 
 if (!*pRowCount)
 {
 mysql_free_result(*pResult);
 return false;
 }
 
 *pFields = reinterpret_cast<MySQLField*>(mysql_fetch_fields(*pResult));
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_Query() [2/2]

bool MySQLConnection::_Query	(	PreparedStatementBase *	stmt,
		MySQLPreparedStatement **	mysqlStmt,
		MySQLResult **	pResult,
		uint64 *	pRowCount,
		uint32 *	pFieldCount
	)

Definition at line 263 of file MySQLConnection.cpp.

{
 if (!m_Mysql)
 return false;
 
 uint32 index = stmt->GetIndex();
 
 MySQLPreparedStatement* m_mStmt = GetPreparedStatement(index);
 ASSERT(m_mStmt); // Can only be null if preparation failed, server side error or bad query
 
 m_mStmt->BindParameters(stmt);
 *mysqlStmt = m_mStmt;
 
 MYSQL_STMT* msql_STMT = m_mStmt->GetSTMT();
 MYSQL_BIND* msql_BIND = m_mStmt->GetBind();
 
 uint32 _s = getMSTime();
 
 if (mysql_stmt_bind_param(msql_STMT, msql_BIND))
 {
 uint32 lErrno = mysql_errno(m_Mysql);
 TC_LOG_ERROR("sql.sql", "SQL(p): {}\n [ERROR]: [{}] {}", m_mStmt->getQueryString(), lErrno, mysql_stmt_error(msql_STMT));
 
 if (_HandleMySQLErrno(lErrno)) // If it returns true, an error was handled successfully (i.e. reconnection)
 return _Query(stmt, mysqlStmt, pResult, pRowCount, pFieldCount); // Try again
 
 m_mStmt->ClearParameters();
 return false;
 }
 
 if (mysql_stmt_execute(msql_STMT))
 {
 uint32 lErrno = mysql_errno(m_Mysql);
 TC_LOG_ERROR("sql.sql", "SQL(p): {}\n [ERROR]: [{}] {}",
 m_mStmt->getQueryString(), lErrno, mysql_stmt_error(msql_STMT));
 
 if (_HandleMySQLErrno(lErrno)) // If it returns true, an error was handled successfully (i.e. reconnection)
 return _Query(stmt, mysqlStmt, pResult, pRowCount, pFieldCount); // Try again
 
 m_mStmt->ClearParameters();
 return false;
 }
 
 TC_LOG_DEBUG("sql.sql", "[{} ms] SQL(p): {}", getMSTimeDiff(_s, getMSTime()), m_mStmt->getQueryString());
 
 m_mStmt->ClearParameters();
 
 *pResult = reinterpret_cast<MySQLResult*>(mysql_stmt_result_metadata(msql_STMT));
 *pRowCount = mysql_stmt_num_rows(msql_STMT);
 *pFieldCount = mysql_stmt_field_count(msql_STMT);
 
 return true;
}

Here is the call graph for this function:

BeginTransaction()

void MySQLConnection::BeginTransaction

(

)

Definition at line 374 of file MySQLConnection.cpp.

{
 Execute("START TRANSACTION");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Close()

void MySQLConnection::Close

(

)

Definition at line 74 of file MySQLConnection.cpp.

{
 // Stop the worker thread before the statements are cleared
 m_worker.reset();
 
 m_stmts.clear();
 
 if (m_Mysql)
 {
 mysql_close(m_Mysql);
 m_Mysql = nullptr;
 }
}

Here is the caller graph for this function:

CommitTransaction()

void MySQLConnection::CommitTransaction

(

)

Definition at line 384 of file MySQLConnection.cpp.

{
 Execute("COMMIT");
}

Here is the call graph for this function:

Here is the caller graph for this function:

DoPrepareStatements()

virtual void MySQLConnection::DoPrepareStatements ( )

protectedpure virtual

Implemented in CharacterDatabaseConnection, HotfixDatabaseConnection, LoginDatabaseConnection, and WorldDatabaseConnection.

Here is the caller graph for this function:

EscapeString()

size_t MySQLConnection::EscapeString	(	char *	to,
		const char *	from,
		size_t	length
	)

Definition at line 440 of file MySQLConnection.cpp.

{
 return mysql_real_escape_string(m_Mysql, to, from, length);
}

Execute() [1/2]

bool MySQLConnection::Execute

(

char const *

sql

)

Definition at line 189 of file MySQLConnection.cpp.

{
 if (!m_Mysql)
 return false;
 
 {
 uint32 _s = getMSTime();
 
 if (mysql_query(m_Mysql, sql))
 {
 uint32 lErrno = mysql_errno(m_Mysql);
 
 TC_LOG_INFO("sql.sql", "SQL: {}", sql);
 TC_LOG_ERROR("sql.sql", "[{}] {}", lErrno, mysql_error(m_Mysql));
 
 if (_HandleMySQLErrno(lErrno)) // If it returns true, an error was handled successfully (i.e. reconnection)
 return Execute(sql); // Try again
 
 return false;
 }
 else
 TC_LOG_DEBUG("sql.sql", "[{} ms] SQL: {}", getMSTimeDiff(_s, getMSTime()), sql);
 }
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Execute() [2/2]

bool MySQLConnection::Execute

(

PreparedStatementBase *

stmt

)

Definition at line 216 of file MySQLConnection.cpp.

{
 if (!m_Mysql)
 return false;
 
 uint32 index = stmt->GetIndex();
 
 MySQLPreparedStatement* m_mStmt = GetPreparedStatement(index);
 ASSERT(m_mStmt); // Can only be null if preparation failed, server side error or bad query
 
 m_mStmt->BindParameters(stmt);
 
 MYSQL_STMT* msql_STMT = m_mStmt->GetSTMT();
 MYSQL_BIND* msql_BIND = m_mStmt->GetBind();
 
 uint32 _s = getMSTime();
 
 if (mysql_stmt_bind_param(msql_STMT, msql_BIND))
 {
 uint32 lErrno = mysql_errno(m_Mysql);
 TC_LOG_ERROR("sql.sql", "SQL(p): {}\n [ERROR]: [{}] {}", m_mStmt->getQueryString(), lErrno, mysql_stmt_error(msql_STMT));
 
 if (_HandleMySQLErrno(lErrno)) // If it returns true, an error was handled successfully (i.e. reconnection)
 return Execute(stmt); // Try again
 
 m_mStmt->ClearParameters();
 return false;
 }
 
 if (mysql_stmt_execute(msql_STMT))
 {
 uint32 lErrno = mysql_errno(m_Mysql);
 TC_LOG_ERROR("sql.sql", "SQL(p): {}\n [ERROR]: [{}] {}", m_mStmt->getQueryString(), lErrno, mysql_stmt_error(msql_STMT));
 
 if (_HandleMySQLErrno(lErrno)) // If it returns true, an error was handled successfully (i.e. reconnection)
 return Execute(stmt); // Try again
 
 m_mStmt->ClearParameters();
 return false;
 }
 
 TC_LOG_DEBUG("sql.sql", "[{} ms] SQL(p): {}", getMSTimeDiff(_s, getMSTime()), m_mStmt->getQueryString());
 
 m_mStmt->ClearParameters();
 return true;
}

Here is the call graph for this function:

ExecuteTransaction()

int MySQLConnection::ExecuteTransaction

(

std::shared_ptr< TransactionBase >

transaction

)

Definition at line 389 of file MySQLConnection.cpp.

{
 std::vector<SQLElementData> const& queries = transaction->m_queries;
 if (queries.empty())
 return -1;
 
 BeginTransaction();
 
 for (auto itr = queries.begin(); itr != queries.end(); ++itr)
 {
 SQLElementData const& data = *itr;
 switch (itr->type)
 {
 case SQL_ELEMENT_PREPARED:
 {
 PreparedStatementBase* stmt = data.element.stmt;
 ASSERT(stmt);
 if (!Execute(stmt))
 {
 TC_LOG_WARN("sql.sql", "Transaction aborted. {} queries not executed.", (uint32)queries.size());
 int errorCode = GetLastError();
 RollbackTransaction();
 return errorCode;
 }
 }
 break;
 case SQL_ELEMENT_RAW:
 {
 char const* sql = data.element.query;
 ASSERT(sql);
 if (!Execute(sql))
 {
 TC_LOG_WARN("sql.sql", "Transaction aborted. {} queries not executed.", (uint32)queries.size());
 int errorCode = GetLastError();
 RollbackTransaction();
 return errorCode;
 }
 }
 break;
 }
 }
 
 // we might encounter errors during certain queries, and depending on the kind of error
 // we might want to restart the transaction. So to prevent data loss, we only clean up when it's all done.
 // This is done in calling functions DatabaseWorkerPool<T>::DirectCommitTransaction and TransactionTask::Execute,
 // and not while iterating over every element.
 
 CommitTransaction();
 return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetLastError()

uint32 MySQLConnection::GetLastError

(

)

Definition at line 450 of file MySQLConnection.cpp.

{
 return mysql_errno(m_Mysql);
}

Here is the caller graph for this function:

GetPreparedStatement()

MySQLPreparedStatement * MySQLConnection::GetPreparedStatement ( uint32  index )

protected

Definition at line 470 of file MySQLConnection.cpp.

{
 ASSERT(index < m_stmts.size(), "Tried to access invalid prepared statement index %u (max index " SZFMTD ") on database `%s`, connection type: %s",
 index, m_stmts.size(), m_connectionInfo.database.c_str(), (m_connectionFlags & CONNECTION_ASYNC) ? "asynchronous" : "synchronous");
 MySQLPreparedStatement* ret = m_stmts[index].get();
 if (!ret)
 TC_LOG_ERROR("sql.sql", "Could not fetch prepared statement {} on database `{}`, connection type: {}.",
 index, m_connectionInfo.database, (m_connectionFlags & CONNECTION_ASYNC) ? "asynchronous" : "synchronous");
 
 return ret;
}

Here is the caller graph for this function:

GetServerVersion()

uint32 MySQLConnection::GetServerVersion ( ) const

protected

Definition at line 465 of file MySQLConnection.cpp.

{
 return mysql_get_server_version(m_Mysql);
}

LockIfReady()

bool MySQLConnection::LockIfReady ( )

protected

Tries to acquire lock. If lock is acquired by another thread the calling parent will just try another connection

Definition at line 455 of file MySQLConnection.cpp.

{
 return m_Mutex.try_lock();
}

Open()

uint32 MySQLConnection::Open ( )

virtual

Definition at line 88 of file MySQLConnection.cpp.

{
 MYSQL *mysqlInit;
 mysqlInit = mysql_init(nullptr);
 if (!mysqlInit)
 {
 TC_LOG_ERROR("sql.sql", "Could not initialize Mysql connection to database `{}`", m_connectionInfo.database);
 return CR_UNKNOWN_ERROR;
 }
 
 int port;
 char const* unix_socket;
 //unsigned int timeout = 10;
 
 mysql_options(mysqlInit, MYSQL_SET_CHARSET_NAME, "utf8mb4");
 //mysql_options(mysqlInit, MYSQL_OPT_READ_TIMEOUT, (char const*)&timeout);
 #ifdef _WIN32
 if (m_connectionInfo.host == ".") // named pipe use option (Windows)
 {
 unsigned int opt = MYSQL_PROTOCOL_PIPE;
 mysql_options(mysqlInit, MYSQL_OPT_PROTOCOL, (char const*)&opt);
 port = 0;
 unix_socket = nullptr;
 }
 else // generic case
 {
 port = atoi(m_connectionInfo.port_or_socket.c_str());
 unix_socket = nullptr;
 }
 #else
 if (m_connectionInfo.host == ".") // socket use option (Unix/Linux)
 {
 unsigned int opt = MYSQL_PROTOCOL_SOCKET;
 mysql_options(mysqlInit, MYSQL_OPT_PROTOCOL, (char const*)&opt);
 m_connectionInfo.host = "localhost";
 port = 0;
 unix_socket = m_connectionInfo.port_or_socket.c_str();
 }
 else // generic case
 {
 port = atoi(m_connectionInfo.port_or_socket.c_str());
 unix_socket = nullptr;
 }
 #endif
 
 if (m_connectionInfo.ssl != "")
 {
#if !defined(MARIADB_VERSION_ID) && MYSQL_VERSION_ID >= 80000
 mysql_ssl_mode opt_use_ssl = SSL_MODE_DISABLED;
 if (m_connectionInfo.ssl == "ssl")
 {
 opt_use_ssl = SSL_MODE_REQUIRED;
 }
 mysql_options(mysqlInit, MYSQL_OPT_SSL_MODE, (char const*)&opt_use_ssl);
#else
 MySQLBool opt_use_ssl = MySQLBool(0);
 if (m_connectionInfo.ssl == "ssl")
 {
 opt_use_ssl = MySQLBool(1);
 }
 mysql_options(mysqlInit, MYSQL_OPT_SSL_ENFORCE, (char const*)&opt_use_ssl);
#endif
 }
 
 m_Mysql = reinterpret_cast<MySQLHandle*>(mysql_real_connect(mysqlInit, m_connectionInfo.host.c_str(), m_connectionInfo.user.c_str(),
 m_connectionInfo.password.c_str(), m_connectionInfo.database.c_str(), port, unix_socket, 0));
 
 if (m_Mysql)
 {
 if (!m_reconnecting)
 {
 TC_LOG_INFO("sql.sql", "MySQL client library: {}", mysql_get_client_info());
 TC_LOG_INFO("sql.sql", "MySQL server ver: {} ", mysql_get_server_info(m_Mysql));
 // MySQL version above 5.1 IS required in both client and server and there is no known issue with different versions above 5.1
 // if (mysql_get_server_version(m_Mysql) != mysql_get_client_version())
 // TC_LOG_INFO("sql.sql", "[WARNING] MySQL client/server version mismatch; may conflict with behaviour of prepared statements.");
 }
 
 TC_LOG_INFO("sql.sql", "Connected to MySQL database at {}", m_connectionInfo.host);
 mysql_autocommit(m_Mysql, 1);
 
 // set connection properties to UTF8 to properly handle locales for different
 // server configs - core sends data in UTF8, so MySQL must expect UTF8 too
 mysql_set_character_set(m_Mysql, "utf8mb4");
 return 0;
 }
 else
 {
 TC_LOG_ERROR("sql.sql", "Could not connect to MySQL database at {}: {}", m_connectionInfo.host, mysql_error(mysqlInit));
 uint32 errorCode = mysql_errno(mysqlInit);
 mysql_close(mysqlInit);
 return errorCode;
 }
}

Here is the caller graph for this function:

operator=()

MySQLConnection & MySQLConnection::operator= ( MySQLConnection const &  right )

privatedelete

Ping()

void MySQLConnection::Ping

(

)

Definition at line 445 of file MySQLConnection.cpp.

{
 mysql_ping(m_Mysql);
}

Here is the caller graph for this function:

PrepareStatement()

void MySQLConnection::PrepareStatement ( uint32  index, std::string_view  sql, ConnectionFlags  flags  )

protected

Definition at line 482 of file MySQLConnection.cpp.

{
 // Check if specified query should be prepared on this connection
 // i.e. don't prepare async statements on synchronous connections
 // to save memory that will not be used.
 if (!(m_connectionFlags & flags))
 {
 m_stmts[index].reset();
 return;
 }
 
 MYSQL_STMT* stmt = mysql_stmt_init(m_Mysql);
 if (!stmt)
 {
 TC_LOG_ERROR("sql.sql", "In mysql_stmt_init() id: {}, sql: \"{}\"", index, sql);
 TC_LOG_ERROR("sql.sql", "{}", mysql_error(m_Mysql));
 m_prepareError = true;
 }
 else
 {
 if (mysql_stmt_prepare(stmt, sql.data(), static_cast<unsigned long>(sql.size())))
 {
 TC_LOG_ERROR("sql.sql", "In mysql_stmt_prepare() id: {}, sql: \"{}\"", index, sql);
 TC_LOG_ERROR("sql.sql", "{}", mysql_stmt_error(stmt));
 mysql_stmt_close(stmt);
 m_prepareError = true;
 }
 else
 m_stmts[index] = std::make_unique<MySQLPreparedStatement>(reinterpret_cast<MySQLStmt*>(stmt), std::string(sql));
 }
}

Here is the caller graph for this function:

PrepareStatements()

bool MySQLConnection::PrepareStatements

(

)

Definition at line 183 of file MySQLConnection.cpp.

{
 DoPrepareStatements();
 return !m_prepareError;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Query() [1/2]

ResultSet * MySQLConnection::Query

(

char const *

sql

)

Definition at line 317 of file MySQLConnection.cpp.

{
 if (!sql)
 return nullptr;
 
 MySQLResult* result = nullptr;
 MySQLField* fields = nullptr;
 uint64 rowCount = 0;
 uint32 fieldCount = 0;
 
 if (!_Query(sql, &result, &fields, &rowCount, &fieldCount))
 return nullptr;
 
 return new ResultSet(result, fields, rowCount, fieldCount);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Query() [2/2]

PreparedResultSet * MySQLConnection::Query

(

PreparedStatementBase *

stmt

)

Definition at line 514 of file MySQLConnection.cpp.

{
 MySQLPreparedStatement* mysqlStmt = nullptr;
 MySQLResult* result = nullptr;
 uint64 rowCount = 0;
 uint32 fieldCount = 0;
 
 if (!_Query(stmt, &mysqlStmt, &result, &rowCount, &fieldCount))
 return nullptr;
 
 if (mysql_more_results(m_Mysql))
 {
 mysql_next_result(m_Mysql);
 }
 return new PreparedResultSet(mysqlStmt->GetSTMT(), result, rowCount, fieldCount);
}

Here is the call graph for this function:

RollbackTransaction()

void MySQLConnection::RollbackTransaction

(

)

Definition at line 379 of file MySQLConnection.cpp.

{
 Execute("ROLLBACK");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Unlock()

void MySQLConnection::Unlock ( )

protected

Called by parent databasepool. Will let other threads access this connection.

Definition at line 460 of file MySQLConnection.cpp.

{
 m_Mutex.unlock();
}

Friends And Related Function Documentation

DatabaseWorkerPool

template<class T >

friend class DatabaseWorkerPool

friend

Definition at line 56 of file MySQLConnection.h.

PingOperation

friend class PingOperation

friend

Definition at line 57 of file MySQLConnection.h.

Member Data Documentation

m_connectionFlags

ConnectionFlags MySQLConnection::m_connectionFlags

private

Connection info (used for logging)

Definition at line 112 of file MySQLConnection.h.

m_connectionInfo

MySQLConnectionInfo& MySQLConnection::m_connectionInfo

private

MySQL Handle.

Definition at line 111 of file MySQLConnection.h.

m_Mutex

std::mutex MySQLConnection::m_Mutex

private

Connection flags (for preparing relevant statements)

Definition at line 113 of file MySQLConnection.h.

m_Mysql

MySQLHandle* MySQLConnection::m_Mysql

private

Core worker task.

Definition at line 110 of file MySQLConnection.h.

m_prepareError

bool MySQLConnection::m_prepareError

protected

Are we reconnecting?

Definition at line 103 of file MySQLConnection.h.

m_queue

ProducerConsumerQueue<SQLOperation*>* MySQLConnection::m_queue

private

Definition at line 108 of file MySQLConnection.h.

m_reconnecting

bool MySQLConnection::m_reconnecting

protected

PreparedStatements storage.

Definition at line 102 of file MySQLConnection.h.

m_stmts

PreparedStatementContainer MySQLConnection::m_stmts

protected

Definition at line 101 of file MySQLConnection.h.

m_worker

std::unique_ptr<DatabaseWorker> MySQLConnection::m_worker

private

Queue shared with other asynchronous connections.

Definition at line 109 of file MySQLConnection.h.

---

The documentation for this class was generated from the following files:

• src/server/database/Database/MySQLConnection.h
• src/server/database/Database/MySQLConnection.cpp