MySQLConnection Class Reference

#include "MySQLConnection.h"

Inheritance diagram for MySQLConnection:

Public Member Functions
	MySQLConnection (MySQLConnectionInfo &connInfo)
	MySQLConnection (ProducerConsumerQueue< SQLOperation * > *queue, MySQLConnectionInfo &connInfo)
	Constructor for synchronous connections.
virtual	~MySQLConnection ()
	Constructor for asynchronous connections.
virtual uint32	Open ()
void	Close ()
bool	PrepareStatements ()
bool	Execute (std::string_view sql)
bool	Execute (PreparedStatementBase *stmt)
ResultSet *	Query (std::string_view sql)
PreparedResultSet *	Query (PreparedStatementBase *stmt)
bool	_Query (std::string_view 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)
std::size_t	EscapeString (char *to, char const *from, std::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.
uint32	GetServerVersion () const
std::string	GetServerInfo () const
MySQLPreparedStatement *	GetPreparedStatement (uint32 index)
void	PrepareStatement (uint32 index, std::string_view sql, ConnectionFlags flags)
virtual void	DoPrepareStatements ()=0
virtual bool	_HandleMySQLErrno (uint32 errNo, char const *err="", uint8 attempts=5)

Protected Attributes
PreparedStatementContainer	m_stmts
bool	m_reconnecting
	PreparedStatements storage.
bool	m_prepareError
	Are we reconnecting?
bool	m_inTransaction
	Was there any error while preparing statements?
uint32	m_lostTransactionError
	Is a transaction open on this connection?
MySQLHandle *	m_Mysql
	Error that lost the open transaction's connection, 0 if none.

Private Member Functions
int	ExecuteTransactionAttempt (std::shared_ptr< TransactionBase > const &transaction, bool &lostBeforeCommit)
	MySQL Handle.
int	AbortTransaction (std::size_t queryCount, bool &lostBeforeCommit)
	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.
MySQLConnectionInfo &	m_connectionInfo
	Core worker task.
ConnectionFlags	m_connectionFlags
	Connection info (used for logging)
std::mutex	m_Mutex
	Connection flags (for preparing relevant statements)

Friends
template<class T >
class	DatabaseWorkerPool
class	ModuleDatabasePool
class	PingOperation

Detailed Description

Member Typedef Documentation

PreparedStatementContainer

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

protected

Constructor & Destructor Documentation

MySQLConnection() [1/3]

MySQLConnection::MySQLConnection

(

MySQLConnectionInfo &

connInfo

)

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

MySQLConnection() [2/3]

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

Constructor for synchronous connections.

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

References m_queue, and m_worker.

~MySQLConnection()

MySQLConnection::~MySQLConnection ( )

virtual

Constructor for asynchronous connections.

{
    Close();
}

References Close().

MySQLConnection() [3/3]

MySQLConnection::MySQLConnection ( MySQLConnection const &  right )

privatedelete

Member Function Documentation

_HandleMySQLErrno()

bool MySQLConnection::_HandleMySQLErrno ( uint32  errNo, char const *  err = "", uint8  attempts = 5  )

protectedvirtual

{
    std::string str = "";
    switch (errNo)
    {
        case CR_SERVER_GONE_ERROR:
        case CR_SERVER_LOST:
        case CR_SERVER_LOST_EXTENDED:
        {
            if (m_Mysql)
            {
                LOG_ERROR("sql.sql", "Lost the connection to the MySQL server!");
 
                mysql_close(m_Mysql);
                m_Mysql = nullptr;
            }
            [[fallthrough]];
        }
        case CR_CONN_HOST_ERROR:
        {
            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())
                {
                    str = "Could not re-prepare statements!";
                    LOG_FATAL("sql.sql", "{}", str);
                    std::this_thread::sleep_for(10s);
                    ABORT("{}\n\n[{}] {}", str, errNo, err);
                }
 
                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;
 
                // The server rolled back the open transaction, so its next statements must not run in autocommit
                if (m_inTransaction)
                {
                    m_inTransaction = false;
                    m_lostTransactionError = errNo;
                    return false;
                }
 
                return true;
            }
 
            if ((--attempts) == 0)
            {
                // Shut down the server when the mysql server isn't
                // reachable for some time
                str = "Failed to reconnect to the MySQL server, terminating the server to prevent data corruption!";
                LOG_FATAL("sql.sql", "{}", str);
 
                // We could also initiate a shutdown through using std::raise(SIGTERM)
                std::this_thread::sleep_for(10s);
                ABORT("{}\n\n[{}] {}", str, errNo, err);
            }
            else
            {
                // It's possible this attempted reconnect throws 2006 at us.
                // To prevent crazy recursive calls, sleep here.
                std::this_thread::sleep_for(3s); // Sleep 3 seconds
                return _HandleMySQLErrno(lErrno, mysql_error(m_Mysql), attempts); // Call self (recursive)
            }
            [[fallthrough]];
        }
 
        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:
            str = "Your database structure is not up to date. Please make sure you've executed all queries in the sql/updates folders.";
            LOG_FATAL("sql.sql", "{}", str);
            std::this_thread::sleep_for(10s);
            ABORT("{}\n\n[{}] {}", str, errNo, err);
            return false;
        case ER_PARSE_ERROR:
            str = "Error while parsing SQL. Core fix required.";
            LOG_FATAL("sql.sql", "{}", str);
            std::this_thread::sleep_for(10s);
            ABORT("{}\n\n[{}] {}", str, errNo, err);
            return false;
        default:
            LOG_ERROR("sql.sql", "Unhandled MySQL errno {}. Unexpected behaviour possible.", errNo);
            return false;
    }
}

References _HandleMySQLErrno(), ABORT, CONNECTION_ASYNC, MySQLConnectionInfo::database, MySQLConnectionInfo::host, LOG_ERROR, LOG_FATAL, LOG_INFO, m_connectionFlags, m_connectionInfo, m_inTransaction, m_lostTransactionError, m_Mysql, m_reconnecting, Open(), MySQLConnectionInfo::port_or_socket, and PrepareStatements().

Referenced by _HandleMySQLErrno(), _Query(), _Query(), Execute(), and Execute().

_Query() [1/2]

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

{
    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_VERSION_ID >= 80300
    if (mysql_stmt_bind_named_param(msql_STMT, msql_BIND, m_mStmt->GetParameterCount(), nullptr))
#else
    if (mysql_stmt_bind_param(msql_STMT, msql_BIND))
#endif
    {
        uint32 lErrno = mysql_errno(m_Mysql);
        LOG_ERROR("sql.sql", "SQL(p): {}\n [ERROR]: [{}] {}", m_mStmt->getQueryString(), lErrno, mysql_stmt_error(msql_STMT));
 
        if (_HandleMySQLErrno(lErrno, mysql_stmt_error(msql_STMT)))  // 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);
        LOG_ERROR("sql.sql", "SQL(p): {}\n [ERROR]: [{}] {}", m_mStmt->getQueryString(), lErrno, mysql_stmt_error(msql_STMT));
 
        if (_HandleMySQLErrno(lErrno, mysql_stmt_error(msql_STMT)))  // 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;
    }
 
    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_affected_rows(msql_STMT);
    *pFieldCount = mysql_stmt_field_count(msql_STMT);
 
    return true;
}

References _HandleMySQLErrno(), _Query(), ASSERT, MySQLPreparedStatement::BindParameters(), MySQLPreparedStatement::ClearParameters(), MySQLPreparedStatement::GetBind(), PreparedStatementBase::GetIndex(), getMSTime(), getMSTimeDiff(), MySQLPreparedStatement::GetParameterCount(), GetPreparedStatement(), MySQLPreparedStatement::getQueryString(), MySQLPreparedStatement::GetSTMT(), LOG_DEBUG, LOG_ERROR, and m_Mysql.

_Query() [2/2]

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

{
    if (!m_Mysql)
        return false;
 
    {
        uint32 _s = getMSTime();
 
        if (mysql_query(m_Mysql, std::string(sql).c_str()))
        {
            uint32 lErrno = mysql_errno(m_Mysql);
            LOG_INFO("sql.sql", "SQL: {}", sql);
            LOG_ERROR("sql.sql", "[{}] {}", lErrno, mysql_error(m_Mysql));
 
            if (_HandleMySQLErrno(lErrno, mysql_error(m_Mysql))) // 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
            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;
}

References _HandleMySQLErrno(), _Query(), getMSTime(), getMSTimeDiff(), LOG_DEBUG, LOG_ERROR, LOG_INFO, and m_Mysql.

Referenced by _Query(), _Query(), Query(), and Query().

AbortTransaction()

int MySQLConnection::AbortTransaction ( std::size_t  queryCount, bool &  lostBeforeCommit  )

private

{
    // The server already rolled the transaction back when the connection was lost
    if (m_lostTransactionError)
    {
        lostBeforeCommit = true;
        return std::exchange(m_lostTransactionError, 0);
    }
 
    LOG_WARN("sql.sql", "Transaction aborted. {} queries not executed.", queryCount);
    int errorCode = GetLastError();
    m_inTransaction = false;
    RollbackTransaction();
    return errorCode;
}

References GetLastError(), LOG_WARN, m_inTransaction, m_lostTransactionError, and RollbackTransaction().

Referenced by ExecuteTransactionAttempt().

BeginTransaction()

void MySQLConnection::BeginTransaction

(

)

{
    Execute("START TRANSACTION");
}

References Execute().

Referenced by ExecuteTransactionAttempt().

Close()

void MySQLConnection::Close

(

)

{
    // 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;
    }
}

References m_Mysql, m_stmts, and m_worker.

Referenced by ~MySQLConnection().

CommitTransaction()

void MySQLConnection::CommitTransaction

(

)

{
    Execute("COMMIT");
}

References Execute().

Referenced by ExecuteTransactionAttempt().

DoPrepareStatements()

virtual void MySQLConnection::DoPrepareStatements ( )

protectedpure virtual

Implemented in CharacterDatabaseConnection, LoginDatabaseConnection, and WorldDatabaseConnection.

Referenced by PrepareStatements().

EscapeString()

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

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

References m_Mysql.

Execute() [1/2]

bool MySQLConnection::Execute

(

PreparedStatementBase *

stmt

)

{
    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_VERSION_ID >= 80300
    if (mysql_stmt_bind_named_param(msql_STMT, msql_BIND, m_mStmt->GetParameterCount(), nullptr))
#else
    if (mysql_stmt_bind_param(msql_STMT, msql_BIND))
#endif
    {
        uint32 lErrno = mysql_errno(m_Mysql);
        LOG_ERROR("sql.sql", "SQL(p): {}\n [ERROR]: [{}] {}", m_mStmt->getQueryString(), lErrno, mysql_stmt_error(msql_STMT));
 
        if (_HandleMySQLErrno(lErrno, mysql_stmt_error(msql_STMT)))  // If it returns true, an error was handled successfully (i.e. reconnection)
            return Execute(stmt);       // Try again
 
        // Reconnected inside a transaction: m_mStmt was replaced by the new connection's statements
        if (m_lostTransactionError)
            return false;
 
        m_mStmt->ClearParameters();
        return false;
    }
 
    if (mysql_stmt_execute(msql_STMT))
    {
        uint32 lErrno = mysql_errno(m_Mysql);
        LOG_ERROR("sql.sql", "SQL(p): {}\n [ERROR]: [{}] {}", m_mStmt->getQueryString(), lErrno, mysql_stmt_error(msql_STMT));
 
        if (_HandleMySQLErrno(lErrno, mysql_stmt_error(msql_STMT)))  // If it returns true, an error was handled successfully (i.e. reconnection)
            return Execute(stmt);       // Try again
 
        // Reconnected inside a transaction: m_mStmt was replaced by the new connection's statements
        if (m_lostTransactionError)
            return false;
 
        m_mStmt->ClearParameters();
        return false;
    }
 
    LOG_DEBUG("sql.sql", "[{} ms] SQL(p): {}", getMSTimeDiff(_s, getMSTime()), m_mStmt->getQueryString());
 
    m_mStmt->ClearParameters();
    return true;
}

References _HandleMySQLErrno(), ASSERT, MySQLPreparedStatement::BindParameters(), MySQLPreparedStatement::ClearParameters(), Execute(), MySQLPreparedStatement::GetBind(), PreparedStatementBase::GetIndex(), getMSTime(), getMSTimeDiff(), MySQLPreparedStatement::GetParameterCount(), GetPreparedStatement(), MySQLPreparedStatement::getQueryString(), MySQLPreparedStatement::GetSTMT(), LOG_DEBUG, LOG_ERROR, m_lostTransactionError, and m_Mysql.

Execute() [2/2]

bool MySQLConnection::Execute

(

std::string_view

sql

)

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

References _HandleMySQLErrno(), Execute(), getMSTime(), getMSTimeDiff(), LOG_DEBUG, LOG_ERROR, LOG_INFO, and m_Mysql.

Referenced by BeginTransaction(), CommitTransaction(), ModuleDatabasePool::DirectExecute(), ModuleDatabasePool::DirectExecute(), BasicStatementTask::Execute(), PreparedStatementTask::Execute(), Execute(), Execute(), ExecuteTransactionAttempt(), and RollbackTransaction().

ExecuteTransaction()

int MySQLConnection::ExecuteTransaction

(

std::shared_ptr< TransactionBase >

transaction

)

{
    if (transaction->m_queries.empty())
        return -1;
 
    // The server rolls back a transaction whose connection is lost, so one lost before COMMIT can run again
    static constexpr uint8 MAX_TRANSACTION_ATTEMPTS = 3;
 
    for (uint8 attempt = 1; ; ++attempt)
    {
        bool lostBeforeCommit = false;
        int errorCode = ExecuteTransactionAttempt(transaction, lostBeforeCommit);
 
        if (!lostBeforeCommit)
            return errorCode;
 
        if (attempt == MAX_TRANSACTION_ATTEMPTS)
        {
            LOG_ERROR("sql.sql", "Transaction lost its connection {} times. {} queries not executed.",
                attempt, transaction->m_queries.size());
            return errorCode;
        }
 
        LOG_WARN("sql.sql", "Transaction lost its connection before COMMIT, running it again.");
    }
}

References ExecuteTransactionAttempt(), LOG_ERROR, and LOG_WARN.

Referenced by ModuleDatabasePool::TryDirectCommitTransaction(), and TransactionTask::TryExecute().

ExecuteTransactionAttempt()

int MySQLConnection::ExecuteTransactionAttempt ( std::shared_ptr< TransactionBase > const &  transaction, bool &  lostBeforeCommit  )

private

MySQL Handle.

{
    std::vector<SQLElementData> const& queries = transaction->m_queries;
 
    BeginTransaction();
    m_inTransaction = true;
 
    for (auto const& data : queries)
    {
        switch (data.type)
        {
            case SQL_ELEMENT_PREPARED:
            {
                PreparedStatementBase* stmt = nullptr;
 
                try
                {
                    stmt = std::get<PreparedStatementBase*>(data.element);
                }
                catch (std::bad_variant_access const& ex)
                {
                    LOG_FATAL("sql.sql", "> PreparedStatementBase not found in SQLElementData. {}", ex.what());
                    ABORT();
                }
 
                ASSERT(stmt);
 
                if (!Execute(stmt))
                    return AbortTransaction(queries.size(), lostBeforeCommit);
            }
            break;
            case SQL_ELEMENT_RAW:
            {
                std::string sql{};
 
                try
                {
                    sql = std::get<std::string>(data.element);
                }
                catch (std::bad_variant_access const& ex)
                {
                    LOG_FATAL("sql.sql", "> std::string not found in SQLElementData. {}", ex.what());
                    ABORT();
                }
 
                ASSERT(!sql.empty());
 
                if (!Execute(sql))
                    return AbortTransaction(queries.size(), lostBeforeCommit);
            }
            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();
    m_inTransaction = false;
 
    if (m_lostTransactionError)
    {
        LOG_ERROR("sql.sql", "Lost the connection during COMMIT. The transaction may or may not have been written, "
            "so it is not run again.");
        return std::exchange(m_lostTransactionError, 0);
    }
 
    return 0;
}

References ABORT, AbortTransaction(), ASSERT, BeginTransaction(), CommitTransaction(), Execute(), LOG_ERROR, LOG_FATAL, m_inTransaction, m_lostTransactionError, SQL_ELEMENT_PREPARED, and SQL_ELEMENT_RAW.

Referenced by ExecuteTransaction().

GetLastError()

uint32 MySQLConnection::GetLastError

(

)

{
    return mysql_errno(m_Mysql);
}

References m_Mysql.

Referenced by AbortTransaction().

GetPreparedStatement()

MySQLPreparedStatement * MySQLConnection::GetPreparedStatement ( uint32  index )

protected

{
    ASSERT(index < m_stmts.size(), "Tried to access invalid prepared statement index {} (max index {}) on database `{}`, connection type: {}",
        index, m_stmts.size(), m_connectionInfo.database, (m_connectionFlags & CONNECTION_ASYNC) ? "asynchronous" : "synchronous");
 
    MySQLPreparedStatement* ret = m_stmts[index].get();
 
    if (!ret)
        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;
}

References ASSERT, CONNECTION_ASYNC, MySQLConnectionInfo::database, LOG_ERROR, m_connectionFlags, m_connectionInfo, and m_stmts.

Referenced by _Query(), and Execute().

GetServerInfo()

std::string MySQLConnection::GetServerInfo ( ) const

protected

{
    return mysql_get_server_info(m_Mysql);
}

References m_Mysql.

GetServerVersion()

uint32 MySQLConnection::GetServerVersion ( ) const

protected

{
    return mysql_get_server_version(m_Mysql);
}

References 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

{
    return m_Mutex.try_lock();
}

References m_Mutex.

Referenced by ModuleDatabasePool::GetFreeConnection().

Open()

uint32 MySQLConnection::Open ( )

virtual

{
    MYSQL* mysqlInit = mysql_init(nullptr);
    if (!mysqlInit)
    {
        LOG_ERROR("sql.driver", "Could not initialize Mysql connection to database `{}`", m_connectionInfo.database);
        return CR_UNKNOWN_ERROR;
    }
 
    uint32 port;
    char const* unix_socket;
    char const* host = m_connectionInfo.host.c_str();
 
    mysql_options(mysqlInit, MYSQL_SET_CHARSET_NAME, "utf8");
 
#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 = 0;
    }
    else                                                    // generic case
    {
        port = *Acore::StringTo<uint32>(m_connectionInfo.port_or_socket);
        unix_socket = 0;
    }
#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);
        host = "localhost";
        port = 0;
        unix_socket = m_connectionInfo.port_or_socket.c_str();
    }
    else                                                    // generic case
    {
        port = *Acore::StringTo<uint32>(m_connectionInfo.port_or_socket);
        unix_socket = nullptr;
    }
#endif
 
    if (m_connectionInfo.ssl != "")
    {
        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);
    }
 
    m_Mysql = reinterpret_cast<MySQLHandle*>(mysql_real_connect(mysqlInit, host, 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)
        {
            LOG_INFO("sql.sql", "MySQL client library: {}", mysql_get_client_info());
            LOG_INFO("sql.sql", "MySQL server ver: {} ", mysql_get_server_info(m_Mysql));
        }
 
        LOG_INFO("sql.sql", "Connected to MySQL database at {}", 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
    {
        LOG_ERROR("sql.driver", "Could not connect to MySQL database at {}: {}", host, mysql_error(mysqlInit));
        uint32 errorCode = mysql_errno(mysqlInit);
        mysql_close(mysqlInit);
        return errorCode;
    }
}

References MySQLConnectionInfo::database, MySQLConnectionInfo::host, LOG_ERROR, LOG_INFO, m_connectionInfo, m_Mysql, m_reconnecting, MySQLConnectionInfo::password, MySQLConnectionInfo::port_or_socket, MySQLConnectionInfo::ssl, and MySQLConnectionInfo::user.

Referenced by _HandleMySQLErrno().

operator=()

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

privatedelete

Ping()

void MySQLConnection::Ping

(

)

{
    mysql_ping(m_Mysql);
}

References m_Mysql.

Referenced by PingOperation::Execute().

PrepareStatement()

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

protected

{
    // 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)
    {
        LOG_ERROR("sql.sql", "In mysql_stmt_init() id: {}, sql: \"{}\"", index, sql);
        LOG_ERROR("sql.sql", "{}", mysql_error(m_Mysql));
        m_prepareError = true;
    }
    else
    {
        if (mysql_stmt_prepare(stmt, std::string(sql).c_str(), static_cast<unsigned long>(sql.size())))
        {
            LOG_ERROR("sql.sql", "In mysql_stmt_prepare() id: {}, sql: \"{}\"", index, sql);
            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), sql);
    }
}

References LOG_ERROR, m_connectionFlags, m_Mysql, m_prepareError, and m_stmts.

Referenced by CharacterDatabaseConnection::DoPrepareStatements(), LoginDatabaseConnection::DoPrepareStatements(), and WorldDatabaseConnection::DoPrepareStatements().

PrepareStatements()

bool MySQLConnection::PrepareStatements

(

)

{
    DoPrepareStatements();
    return !m_prepareError;
}

References DoPrepareStatements(), and m_prepareError.

Referenced by _HandleMySQLErrno().

Query() [1/2]

PreparedResultSet * MySQLConnection::Query

(

PreparedStatementBase *

stmt

)

{
    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);
}

References _Query(), MySQLPreparedStatement::GetSTMT(), and m_Mysql.

Query() [2/2]

ResultSet * MySQLConnection::Query

(

std::string_view

sql

)

{
    if (sql.empty())
        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);
}

References _Query().

Referenced by BasicStatementTask::Execute(), PreparedStatementTask::Execute(), SQLQueryHolderTask::Execute(), ModuleDatabasePool::Query(), and ModuleDatabasePool::Query().

RollbackTransaction()

void MySQLConnection::RollbackTransaction

(

)

{
    Execute("ROLLBACK");
}

References Execute().

Referenced by AbortTransaction().

Unlock()

void MySQLConnection::Unlock ( )

protected

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

{
    m_Mutex.unlock();
}

References m_Mutex.

Referenced by ModuleDatabasePool::DelayQueryHolder(), ModuleDatabasePool::DirectExecute(), ModuleDatabasePool::DirectExecute(), ModuleDatabasePool::Query(), ModuleDatabasePool::Query(), and ModuleDatabasePool::TryDirectCommitTransaction().

Friends And Related Symbol Documentation

DatabaseWorkerPool

template<class T >

friend class DatabaseWorkerPool

friend

ModuleDatabasePool

friend class ModuleDatabasePool

friend

PingOperation

friend class PingOperation

friend

Member Data Documentation

m_connectionFlags

ConnectionFlags MySQLConnection::m_connectionFlags

private

Connection info (used for logging)

Referenced by _HandleMySQLErrno(), GetPreparedStatement(), and PrepareStatement().

m_connectionInfo

MySQLConnectionInfo& MySQLConnection::m_connectionInfo

private

Core worker task.

Referenced by _HandleMySQLErrno(), GetPreparedStatement(), and Open().

m_inTransaction

bool MySQLConnection::m_inTransaction

protected

Was there any error while preparing statements?

Referenced by _HandleMySQLErrno(), AbortTransaction(), and ExecuteTransactionAttempt().

m_lostTransactionError

uint32 MySQLConnection::m_lostTransactionError

protected

Is a transaction open on this connection?

Referenced by _HandleMySQLErrno(), AbortTransaction(), Execute(), and ExecuteTransactionAttempt().

m_Mutex

std::mutex MySQLConnection::m_Mutex

private

Connection flags (for preparing relevant statements)

Referenced by LockIfReady(), and Unlock().

m_Mysql

MySQLHandle* MySQLConnection::m_Mysql

protected

Error that lost the open transaction's connection, 0 if none.

Referenced by _HandleMySQLErrno(), _Query(), _Query(), Close(), EscapeString(), Execute(), Execute(), GetLastError(), GetServerInfo(), GetServerVersion(), Open(), Ping(), PrepareStatement(), and Query().

m_prepareError

bool MySQLConnection::m_prepareError

protected

Are we reconnecting?

Referenced by PrepareStatement(), and PrepareStatements().

m_queue

ProducerConsumerQueue<SQLOperation*>* MySQLConnection::m_queue

private

Referenced by MySQLConnection().

m_reconnecting

bool MySQLConnection::m_reconnecting

protected

PreparedStatements storage.

Referenced by _HandleMySQLErrno(), CharacterDatabaseConnection::DoPrepareStatements(), LoginDatabaseConnection::DoPrepareStatements(), WorldDatabaseConnection::DoPrepareStatements(), and Open().

m_stmts

PreparedStatementContainer MySQLConnection::m_stmts

protected

Referenced by Close(), CharacterDatabaseConnection::DoPrepareStatements(), LoginDatabaseConnection::DoPrepareStatements(), WorldDatabaseConnection::DoPrepareStatements(), GetPreparedStatement(), PrepareStatement(), and ModuleDatabasePool::PrepareStatements().

m_worker

std::unique_ptr<DatabaseWorker> MySQLConnection::m_worker

private

Queue shared with other asynchronous connections.

Referenced by Close(), and MySQLConnection().

---

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

• azerothcore-wotlk/src/server/database/Database/MySQLConnection.h
• azerothcore-wotlk/src/server/database/Database/MySQLConnection.cpp