ModuleDatabasePool Class Reference

#include "ModuleDatabasePool.h"

Inheritance diagram for ModuleDatabasePool:

Public Member Functions
	ModuleDatabasePool ()
virtual	~ModuleDatabasePool ()
void	SetConnectionInfo (std::string_view infoString, uint8 synchThreads)
uint32	Open ()
bool	PrepareStatements ()
void	Close ()
void	Execute (std::string_view sql)
void	DirectExecute (std::string_view sql) override
QueryResult	Query (std::string_view sql) override
MySQLConnectionInfo const *	GetConnectionInfo () const override
template<typename... Args>
void	Execute (std::string_view sql, Args &&... args)
	Format variants, mirroring DatabaseWorkerPool.
template<typename... Args>
void	DirectExecute (std::string_view sql, Args &&... args)
template<typename... Args>
QueryResult	Query (std::string_view sql, Args &&... args)
void	Execute (PreparedStatementBase *stmt)
PreparedQueryResult	Query (PreparedStatementBase *stmt)
uint8	GetPreparedStatementParamCount (uint32 index) const
void	DirectCommitTransaction (std::shared_ptr< TransactionBase > transaction)
	Synchronously commits the transaction on a free connection.
void	KeepAlive ()
	Pings every idle connection to keep them alive.
Public Member Functions inherited from DatabaseUpdatePool
virtual	~DatabaseUpdatePool ()=default

Protected Member Functions
virtual MySQLConnection *	CreateConnection (MySQLConnectionInfo &connInfo)=0

Private Member Functions
MySQLConnection *	GetFreeConnection ()

Private Attributes
MySQLConnectionInfo	_connectionInfo
std::vector< std::unique_ptr< MySQLConnection > >	_connections
std::vector< uint8 >	_preparedStatementSize
uint8	_synchThreads

Detailed Description

Constructor & Destructor Documentation

ModuleDatabasePool()

ModuleDatabasePool::ModuleDatabasePool

(

)

    : _connectionInfo(""), _synchThreads(0)
{
}

~ModuleDatabasePool()

ModuleDatabasePool::~ModuleDatabasePool ( )

virtual

{
    Close();
}

References Close().

Member Function Documentation

Close()

void ModuleDatabasePool::Close

(

)

{
    _connections.clear();
 
    _preparedStatementSize.clear();
}

References _connections, and _preparedStatementSize.

Referenced by Open(), PrepareStatements(), and ~ModuleDatabasePool().

CreateConnection()

virtual MySQLConnection * ModuleDatabasePool::CreateConnection ( MySQLConnectionInfo &  connInfo )

protectedpure virtual

Referenced by Open().

DirectCommitTransaction()

void ModuleDatabasePool::DirectCommitTransaction

(

std::shared_ptr< TransactionBase >

transaction

)

Synchronously commits the transaction on a free connection.

Handle MySQL Errno 1213 without extending deadlock to the core itself

{
    if (_connections.empty())
        return;
 
    MySQLConnection* conn = GetFreeConnection();
    int errorCode = conn->ExecuteTransaction(transaction);
    if (!errorCode)
    {
        conn->Unlock();
        return;
    }
 
    if (errorCode == ER_LOCK_DEADLOCK)
    {
        uint8 constexpr loopBreaker = 5;
        for (uint8 i = 0; i < loopBreaker; ++i)
        {
            if (!conn->ExecuteTransaction(transaction))
                break;
        }
    }
 
    transaction->Cleanup();
    conn->Unlock();
}

References _connections, MySQLConnection::ExecuteTransaction(), GetFreeConnection(), and MySQLConnection::Unlock().

DirectExecute() [1/2]

void ModuleDatabasePool::DirectExecute ( std::string_view  sql )

overridevirtual

Implements DatabaseUpdatePool.

{
    if (sql.empty())
        return;
 
    if (_connections.empty())
        return;
 
    MySQLConnection* conn = GetFreeConnection();
    conn->Execute(sql);
    conn->Unlock();
}

References _connections, MySQLConnection::Execute(), GetFreeConnection(), and MySQLConnection::Unlock().

Referenced by Execute().

DirectExecute() [2/2]

template<typename... Args>

void ModuleDatabasePool::DirectExecute ( std::string_view  sql, Args &&...  args  )

inline

    {
        if (sql.empty())
            return;
 
        DirectExecute(std::string_view(Acore::StringFormat(sql, std::forward<Args>(args)...)));
    }

References DatabaseUpdatePool::DirectExecute(), and Acore::StringFormat().

Execute() [1/3]

void ModuleDatabasePool::Execute

(

PreparedStatementBase *

stmt

)

Prepared statements. The index space is defined by the module's connection class (DoPrepareStatements); parameter counts are recorded by PrepareStatements(), so building one before that call yields a zero-parameter statement. Both calls consume (delete) the statement, mirroring DatabaseWorkerPool.

{
    if (_connections.empty())
    {
        delete stmt;
        return;
    }
 
    MySQLConnection* conn = GetFreeConnection();
    conn->Execute(stmt);
    conn->Unlock();
 
    delete stmt;
}

References _connections, MySQLConnection::Execute(), GetFreeConnection(), and MySQLConnection::Unlock().

Execute() [2/3]

void ModuleDatabasePool::Execute

(

std::string_view

sql

)

{
    // Synchronous for now - kept separate from DirectExecute so async execution
    // can be added later without touching callers.
    DirectExecute(sql);
}

References DirectExecute().

Execute() [3/3]

template<typename... Args>

void ModuleDatabasePool::Execute ( std::string_view  sql, Args &&...  args  )

inline

Format variants, mirroring DatabaseWorkerPool.

    {
        if (sql.empty())
            return;
 
        Execute(std::string_view(Acore::StringFormat(sql, std::forward<Args>(args)...)));
    }

References Acore::StringFormat().

GetConnectionInfo()

MySQLConnectionInfo const * ModuleDatabasePool::GetConnectionInfo ( ) const

overridevirtual

Implements DatabaseUpdatePool.

{
    return &_connectionInfo;
}

References _connectionInfo.

GetFreeConnection()

MySQLConnection * ModuleDatabasePool::GetFreeConnection ( )

private

Block forever until a connection is free

Must be matched with connection->Unlock() or you will get deadlocks

{
    uint8 i = 0;
    auto const num_cons = _connections.size();
    MySQLConnection* connection = nullptr;
 
    for (;;)
    {
        connection = _connections[++i % num_cons].get();
        if (connection->LockIfReady())
            break;
 
        if (i % num_cons == 0)
            std::this_thread::yield();
    }
 
    return connection;
}

References _connections, and MySQLConnection::LockIfReady().

Referenced by DirectCommitTransaction(), DirectExecute(), Execute(), Query(), and Query().

GetPreparedStatementParamCount()

uint8 ModuleDatabasePool::GetPreparedStatementParamCount

(

uint32

index

)

const

Parameter count for a prepared statement index, for constructing typed PreparedStatement<T> objects module-side.

{
    return index < _preparedStatementSize.size() ? _preparedStatementSize[index] : 0;
}

References _preparedStatementSize.

KeepAlive()

void ModuleDatabasePool::KeepAlive

(

)

Pings every idle connection to keep them alive.

Ping connections that are not busy; a locked connection is in use and alive.

{
    for (auto const& conn : _connections)
    {
        if (conn->LockIfReady())
        {
            conn->Ping();
            conn->Unlock();
        }
    }
}

References _connections.

Open()

uint32 ModuleDatabasePool::Open

(

)

Opens the configured number of synchronous connections. Returns 0 on success, or the MySQL error code of the first failed connection.

{
    if (!_synchThreads)
    {
        LOG_ERROR("sql.driver", "ModuleDatabasePool: database `{}` was configured with 0 synchronous connections, "
            "at least one is required.", _connectionInfo.database);
        return CR_UNKNOWN_ERROR;
    }
 
    Close();
 
    for (uint8 i = 0; i < _synchThreads; ++i)
    {
        auto conn = std::unique_ptr<MySQLConnection>(CreateConnection(_connectionInfo));
        uint32 result = conn->Open();
        if (result != 0)
        {
            LOG_ERROR("sql.driver", "ModuleDatabasePool: could not open connection {}/{} to database `{}`, error {}",
                i + 1, _synchThreads, _connectionInfo.database, result);
            Close();
            return result;
        }
 
        _connections.push_back(std::move(conn));
    }
 
    return 0;
}

References _connectionInfo, _connections, _synchThreads, Close(), CreateConnection(), MySQLConnectionInfo::database, and LOG_ERROR.

PrepareStatements()

bool ModuleDatabasePool::PrepareStatements

(

)

Prepares the connection statements. Call after the schema exists (post create/populate/update), mirroring DatabaseLoader's ordering.

{
    for (auto const& conn : _connections)
    {
        conn->LockIfReady();
        if (!conn->PrepareStatements())
        {
            conn->Unlock();
            Close();
            return false;
        }
 
        conn->Unlock();
    }
 
    if (!_connections.empty())
    {
        MySQLConnection const* conn = _connections.front().get();
        _preparedStatementSize.assign(conn->m_stmts.size(), 0);
        for (std::size_t i = 0; i < conn->m_stmts.size(); ++i)
        {
            if (MySQLPreparedStatement* stmt = conn->m_stmts[i].get())
            {
                uint32 const paramCount = stmt->GetParameterCount();
                ASSERT(paramCount < std::numeric_limits<uint8>::max());
                _preparedStatementSize[i] = static_cast<uint8>(paramCount);
            }
        }
    }
 
    return true;
}

References _connections, _preparedStatementSize, ASSERT, Close(), and MySQLConnection::m_stmts.

Query() [1/3]

PreparedQueryResult ModuleDatabasePool::Query

(

PreparedStatementBase *

stmt

)

Delete proxy-class. Not needed anymore

{
    if (_connections.empty())
    {
        delete stmt;
        return PreparedQueryResult(nullptr);
    }
 
    MySQLConnection* conn = GetFreeConnection();
    PreparedResultSet* result = conn->Query(stmt);
    conn->Unlock();
 
    delete stmt;
 
    if (!result || !result->GetRowCount())
    {
        delete result;
        return PreparedQueryResult(nullptr);
    }
 
    return PreparedQueryResult(result);
}

References _connections, GetFreeConnection(), PreparedResultSet::GetRowCount(), MySQLConnection::Query(), and MySQLConnection::Unlock().

Query() [2/3]

QueryResult ModuleDatabasePool::Query ( std::string_view  sql )

overridevirtual

Implements DatabaseUpdatePool.

{
    if (_connections.empty())
        return QueryResult(nullptr);
 
    MySQLConnection* conn = GetFreeConnection();
    ResultSet* result = conn->Query(sql);
    conn->Unlock();
 
    // Mirror DatabaseWorkerPool<T>::Query semantics: nullptr for empty results,
    // and the first row loaded before the result is handed out.
    if (!result || !result->GetRowCount() || !result->NextRow())
    {
        delete result;
        return QueryResult(nullptr);
    }
 
    return QueryResult(result);
}

References _connections, GetFreeConnection(), ResultSet::GetRowCount(), ResultSet::NextRow(), MySQLConnection::Query(), and MySQLConnection::Unlock().

Query() [3/3]

template<typename... Args>

QueryResult ModuleDatabasePool::Query ( std::string_view  sql, Args &&...  args  )

inline

    {
        if (sql.empty())
            return QueryResult(nullptr);
 
        return Query(std::string_view(Acore::StringFormat(sql, std::forward<Args>(args)...)));
    }

References DatabaseUpdatePool::Query(), and Acore::StringFormat().

SetConnectionInfo()

void ModuleDatabasePool::SetConnectionInfo	(	std::string_view	infoString,
		uint8	synchThreads
	)

{
    _connectionInfo = MySQLConnectionInfo(infoString);
    _synchThreads = synchThreads;
}

References _connectionInfo, and _synchThreads.

Member Data Documentation

_connectionInfo

MySQLConnectionInfo ModuleDatabasePool::_connectionInfo

private

Referenced by GetConnectionInfo(), Open(), and SetConnectionInfo().

_connections

std::vector<std::unique_ptr<MySQLConnection> > ModuleDatabasePool::_connections

private

Referenced by Close(), DirectCommitTransaction(), DirectExecute(), Execute(), GetFreeConnection(), KeepAlive(), Open(), PrepareStatements(), Query(), and Query().

_preparedStatementSize

std::vector<uint8> ModuleDatabasePool::_preparedStatementSize

private

Referenced by Close(), GetPreparedStatementParamCount(), and PrepareStatements().

_synchThreads

uint8 ModuleDatabasePool::_synchThreads

private

Referenced by Open(), and SetConnectionInfo().

---

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

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