ModuleDatabasePool Class Reference

#include "ModuleDatabasePool.h"

Inheritance diagram for ModuleDatabasePool:

Public Member Functions
	ModuleDatabasePool ()
virtual	~ModuleDatabasePool ()
void	SetConnectionInfo (std::string_view infoString, uint8 synchThreads)
void	SetConnectionInfo (std::string_view infoString, uint8 asyncThreads, uint8 synchThreads)
uint32	Open ()
bool	PrepareStatements ()
	Call once the schema is up to date.
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)
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)
	These take ownership of the statement and delete it.
void	DirectExecute (PreparedStatementBase *stmt)
PreparedQueryResult	Query (PreparedStatementBase *stmt)
QueryCallback	AsyncQuery (PreparedStatementBase *stmt)
QueryCallback	AsyncQuery (std::string_view sql)
SQLQueryHolderCallback	DelayQueryHolder (std::shared_ptr< SQLQueryHolderBase > holder)
uint8	GetPreparedStatementParamCount (uint32 index) const
	Returns 0 until PrepareStatements() has run.
void	CommitTransaction (std::shared_ptr< TransactionBase > transaction)
TransactionCallback	AsyncCommitTransaction (std::shared_ptr< TransactionBase > transaction)
void	DirectCommitTransaction (std::shared_ptr< TransactionBase > transaction)
void	KeepAlive ()
std::size_t	QueueSize () const
void	WarnAboutSyncQueries (bool warn)
Public Member Functions inherited from DatabaseUpdatePool
virtual	~DatabaseUpdatePool ()=default

Protected Member Functions
virtual MySQLConnection *	CreateConnection (MySQLConnectionInfo &connInfo)=0
virtual MySQLConnection *	CreateAsyncConnection (ProducerConsumerQueue< SQLOperation * > *queue, MySQLConnectionInfo &connInfo)

Private Types
enum	InternalIndex {   IDX_ASYNC ,   IDX_SYNCH ,   IDX_SIZE }

Private Member Functions
uint32	OpenConnections (InternalIndex type, uint8 numConnections)
void	Enqueue (SQLOperation *op)
bool	TryDirectCommitTransaction (std::shared_ptr< TransactionBase > transaction)
MySQLConnection *	GetFreeConnection ()

Private Attributes
MySQLConnectionInfo	_connectionInfo
std::unique_ptr< ProducerConsumerQueue< SQLOperation * > >	_queue
std::array< std::vector< std::unique_ptr< MySQLConnection > >, IDX_SIZE >	_connections
std::vector< uint8 >	_preparedStatementSize
uint8	_asyncThreads
uint8	_synchThreads

Detailed Description

Member Enumeration Documentation

InternalIndex

enum ModuleDatabasePool::InternalIndex

private

Enumerator
IDX_ASYNC
IDX_SYNCH
IDX_SIZE

    {
        IDX_ASYNC,
        IDX_SYNCH,
        IDX_SIZE
    };

Constructor & Destructor Documentation

ModuleDatabasePool()

ModuleDatabasePool::ModuleDatabasePool

(

)

                                       :
    _connectionInfo(""),
    _queue(std::make_unique<ProducerConsumerQueue<SQLOperation*>>()),
    _asyncThreads(0),
    _synchThreads(0)
{
}

~ModuleDatabasePool()

ModuleDatabasePool::~ModuleDatabasePool ( )

virtual

{
    Close();
 
    _queue->Cancel();
}

References _queue, and Close().

Member Function Documentation

AsyncCommitTransaction()

TransactionCallback ModuleDatabasePool::AsyncCommitTransaction

(

std::shared_ptr< TransactionBase >

transaction

)

{
#ifdef ACORE_DEBUG
    switch (transaction->GetSize())
    {
    case 0:
        LOG_DEBUG("sql.driver", "Transaction contains 0 queries. Not executing.");
        break;
    case 1:
        LOG_DEBUG("sql.driver",
            "Warning: Transaction only holds 1 query, consider removing Transaction context in code.");
        break;
    default:
        break;
    }
#endif
 
    if (_connections[IDX_ASYNC].empty())
    {
        TransactionPromise result;
        result.set_value(TryDirectCommitTransaction(transaction));
        return TransactionCallback(result.get_future());
    }
 
    TransactionWithResultTask* task = new TransactionWithResultTask(transaction);
    TransactionFuture result = task->GetFuture();
    Enqueue(task);
    return TransactionCallback(std::move(result));
}

References _connections, Enqueue(), TransactionWithResultTask::GetFuture(), IDX_ASYNC, LOG_DEBUG, and TryDirectCommitTransaction().

AsyncQuery() [1/2]

QueryCallback ModuleDatabasePool::AsyncQuery

(

PreparedStatementBase *

stmt

)

{
    if (_connections[IDX_ASYNC].empty())
    {
        PreparedQueryResultPromise result;
        result.set_value(Query(stmt));
        return QueryCallback(result.get_future());
    }
 
    PreparedStatementTask* task = new PreparedStatementTask(stmt, true);
    PreparedQueryResultFuture result = task->GetFuture();
    Enqueue(task);
    return QueryCallback(std::move(result));
}

References _connections, Enqueue(), PreparedStatementTask::GetFuture(), IDX_ASYNC, and Query().

AsyncQuery() [2/2]

QueryCallback ModuleDatabasePool::AsyncQuery

(

std::string_view

sql

)

{
    if (_connections[IDX_ASYNC].empty())
    {
        QueryResultPromise result;
        result.set_value(Query(sql));
        return QueryCallback(result.get_future());
    }
 
    BasicStatementTask* task = new BasicStatementTask(sql, true);
    QueryResultFuture result = task->GetFuture();
    Enqueue(task);
    return QueryCallback(std::move(result));
}

References _connections, Enqueue(), BasicStatementTask::GetFuture(), IDX_ASYNC, and Query().

Close()

void ModuleDatabasePool::Close

(

)

{
    _queue->Shutdown();
 
    _connections[IDX_ASYNC].clear();
    _connections[IDX_SYNCH].clear();
 
    _preparedStatementSize.clear();
}

References _connections, _preparedStatementSize, _queue, IDX_ASYNC, and IDX_SYNCH.

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

CommitTransaction()

void ModuleDatabasePool::CommitTransaction

(

std::shared_ptr< TransactionBase >

transaction

)

{
#ifdef ACORE_DEBUG
    switch (transaction->GetSize())
    {
    case 0:
        LOG_DEBUG("sql.driver", "Transaction contains 0 queries. Not executing.");
        return;
    case 1:
        LOG_DEBUG("sql.driver",
            "Warning: Transaction only holds 1 query, consider removing Transaction context in code.");
        break;
    default:
        break;
    }
#endif
    if (_connections[IDX_ASYNC].empty())
    {
        DirectCommitTransaction(transaction);
        return;
    }
 
    Enqueue(new TransactionTask(transaction));
}

References _connections, DirectCommitTransaction(), Enqueue(), IDX_ASYNC, and LOG_DEBUG.

CreateAsyncConnection()

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

protectedvirtual

{
    return nullptr;
}

Referenced by OpenConnections().

CreateConnection()

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

protectedpure virtual

Referenced by OpenConnections().

DelayQueryHolder()

SQLQueryHolderCallback ModuleDatabasePool::DelayQueryHolder

(

std::shared_ptr< SQLQueryHolderBase >

holder

)

{
    if (!_connections[IDX_ASYNC].empty())
    {
        SQLQueryHolderTask* task = new SQLQueryHolderTask(holder);
        QueryResultHolderFuture result = task->GetFuture();
        Enqueue(task);
        return { std::move(holder), std::move(result) };
    }
 
    if (!_connections[IDX_SYNCH].empty())
    {
        SQLQueryHolderTask task(holder);
        QueryResultHolderFuture result = task.GetFuture();
 
        MySQLConnection* conn = GetFreeConnection();
        task.SetConnection(conn);
        task.Execute();
        conn->Unlock();
 
        return { std::move(holder), std::move(result) };
    }
 
    QueryResultHolderPromise result;
    result.set_value();
    return { std::move(holder), result.get_future() };
}

References _connections, Enqueue(), SQLQueryHolderTask::Execute(), GetFreeConnection(), SQLQueryHolderTask::GetFuture(), IDX_ASYNC, IDX_SYNCH, SQLOperation::SetConnection(), and MySQLConnection::Unlock().

DirectCommitTransaction()

void ModuleDatabasePool::DirectCommitTransaction

(

std::shared_ptr< TransactionBase >

transaction

)

{
    TryDirectCommitTransaction(transaction);
}

References TryDirectCommitTransaction().

Referenced by CommitTransaction().

DirectExecute() [1/3]

void ModuleDatabasePool::DirectExecute

(

PreparedStatementBase *

stmt

)

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

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

DirectExecute() [2/3]

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

overridevirtual

Implements DatabaseUpdatePool.

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

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

Referenced by Execute(), and Execute().

DirectExecute() [3/3]

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().

Enqueue()

void ModuleDatabasePool::Enqueue ( SQLOperation *  op )

private

{
    _queue->Push(op);
}

References _queue.

Referenced by AsyncCommitTransaction(), AsyncQuery(), AsyncQuery(), CommitTransaction(), DelayQueryHolder(), Execute(), Execute(), and KeepAlive().

Execute() [1/3]

void ModuleDatabasePool::Execute

(

PreparedStatementBase *

stmt

)

These take ownership of the statement and delete it.

{
    if (_connections[IDX_ASYNC].empty())
    {
        DirectExecute(stmt);
        return;
    }
 
    Enqueue(new PreparedStatementTask(stmt));
}

References _connections, DirectExecute(), Enqueue(), and IDX_ASYNC.

Execute() [2/3]

void ModuleDatabasePool::Execute

(

std::string_view

sql

)

{
    if (sql.empty())
        return;
 
    if (_connections[IDX_ASYNC].empty())
    {
        DirectExecute(sql);
        return;
    }
 
    Enqueue(new BasicStatementTask(sql));
}

References _connections, DirectExecute(), Enqueue(), and IDX_ASYNC.

Execute() [3/3]

template<typename... Args>

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

inline

    {
        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

{
#ifdef ACORE_DEBUG
    if (_warnSyncQueries)
    {
        std::ostringstream ss;
        ss << boost::stacktrace::stacktrace();
        LOG_WARN("sql.performances", "Sync query at:\n{}", ss.str());
    }
#endif
 
    uint8 i = 0;
    auto const num_cons = _connections[IDX_SYNCH].size();
    MySQLConnection* connection = nullptr;
 
    for (;;)
    {
        connection = _connections[IDX_SYNCH][++i % num_cons].get();
        if (connection->LockIfReady())
            break;
 
        if (i % num_cons == 0)
            std::this_thread::yield();
    }
 
    return connection;
}

References _connections, IDX_SYNCH, MySQLConnection::LockIfReady(), and LOG_WARN.

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

GetPreparedStatementParamCount()

uint8 ModuleDatabasePool::GetPreparedStatementParamCount

(

uint32

index

)

const

Returns 0 until PrepareStatements() has run.

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

References _preparedStatementSize.

KeepAlive()

void ModuleDatabasePool::KeepAlive

(

)

{
    for (auto const& conn : _connections[IDX_SYNCH])
    {
        if (conn->LockIfReady())
        {
            conn->Ping();
            conn->Unlock();
        }
    }
 
    auto const count = _connections[IDX_ASYNC].size();
 
    for (std::size_t i = 0; i < count; ++i)
        Enqueue(new PingOperation);
}

References _connections, Enqueue(), IDX_ASYNC, and IDX_SYNCH.

Open()

uint32 ModuleDatabasePool::Open

(

)

{
    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;
    }
 
    LOG_INFO("sql.driver", "Opening DatabasePool '{}'. Asynchronous connections: {}, synchronous connections: {}.",
        _connectionInfo.database, _asyncThreads, _synchThreads);
 
    _queue->Cancel();
    _connections[IDX_ASYNC].clear();
    _connections[IDX_SYNCH].clear();
    _preparedStatementSize.clear();
    _queue->Reset();
 
    if (uint32 error = OpenConnections(IDX_ASYNC, _asyncThreads))
    {
        Close();
        return error;
    }
 
    if (uint32 error = OpenConnections(IDX_SYNCH, _synchThreads))
    {
        Close();
        return error;
    }
 
    return 0;
}

References _asyncThreads, _connectionInfo, _connections, _preparedStatementSize, _queue, _synchThreads, Close(), MySQLConnectionInfo::database, IDX_ASYNC, IDX_SYNCH, LOG_ERROR, LOG_INFO, and OpenConnections().

OpenConnections()

uint32 ModuleDatabasePool::OpenConnections ( InternalIndex  type, uint8  numConnections  )

private

{
    for (uint8 i = 0; i < numConnections; ++i)
    {
        std::unique_ptr<MySQLConnection> conn(type == IDX_ASYNC ? CreateAsyncConnection(_queue.get(), _connectionInfo)
            : CreateConnection(_connectionInfo));
 
        if (!conn)
        {
            if (type == IDX_ASYNC)
            {
                LOG_ERROR("sql.driver", "ModuleDatabasePool: database `{}` was configured with {} asynchronous "
                    "connections, but the module does not override CreateAsyncConnection(queue, connInfo).",
                    _connectionInfo.database, numConnections);
            }
            else
            {
                LOG_ERROR("sql.driver", "ModuleDatabasePool: CreateConnection returned no synchronous connection "
                    "for database `{}`.", _connectionInfo.database);
            }
 
            _queue->Cancel();
            _connections[type].clear();
            return CR_UNKNOWN_ERROR;
        }
 
        if (type == IDX_ASYNC && conn->m_queue != _queue.get())
        {
            LOG_ERROR("sql.driver", "ModuleDatabasePool: async queries for database `{}` cannot run. No queue was "
                "set on the asynchronous connection: pass `queue` to the connection's constructor in the module's "
                "CreateAsyncConnection(queue, connInfo) override.", _connectionInfo.database);
 
            _queue->Cancel();
            _connections[type].clear();
            return CR_UNKNOWN_ERROR;
        }
 
        uint32 result = conn->Open();
        if (result != 0)
        {
            LOG_ERROR("sql.driver", "ModuleDatabasePool: could not open {} connection {}/{} to database `{}`, error {}",
                type == IDX_ASYNC ? "asynchronous" : "synchronous", i + 1, numConnections,
                _connectionInfo.database, result);
 
            _queue->Cancel();
            _connections[type].clear();
            return result;
        }
 
        _connections[type].push_back(std::move(conn));
    }
 
    return 0;
}

References _connectionInfo, _connections, _queue, CreateAsyncConnection(), CreateConnection(), MySQLConnectionInfo::database, IDX_ASYNC, and LOG_ERROR.

Referenced by Open().

PrepareStatements()

bool ModuleDatabasePool::PrepareStatements

(

)

Call once the schema is up to date.

Without async connections every statement runs on a synchronous one, so CONNECTION_ASYNC-only ones fail.

{
    for (auto const& connections : _connections)
    {
        for (auto const& conn : connections)
        {
            conn->LockIfReady();
            if (!conn->PrepareStatements())
            {
                conn->Unlock();
                Close();
                return false;
            }
 
            conn->Unlock();
 
            std::size_t const preparedSize = conn->m_stmts.size();
            if (_preparedStatementSize.size() < preparedSize)
                _preparedStatementSize.resize(preparedSize);
 
            for (std::size_t i = 0; i < preparedSize; ++i)
            {
                if (_preparedStatementSize[i] > 0)
                    continue;
 
                if (MySQLPreparedStatement* stmt = conn->m_stmts[i].get())
                {
                    uint32 const paramCount = stmt->GetParameterCount();
 
                    // Only uint8 indices are supported.
                    ASSERT(paramCount < std::numeric_limits<uint8>::max());
 
                    _preparedStatementSize[i] = static_cast<uint8>(paramCount);
                }
            }
        }
    }
 
    if (_connections[IDX_ASYNC].empty() && !_connections[IDX_SYNCH].empty())
    {
        MySQLConnection const* conn = _connections[IDX_SYNCH].front().get();
        std::string missing;
 
        for (std::size_t i = 0; i < conn->m_stmts.size(); ++i)
        {
            if (conn->m_stmts[i])
                continue;
 
            if (!missing.empty())
                missing += ", ";
 
            missing += std::to_string(i);
        }
 
        if (!missing.empty())
        {
            LOG_ERROR("sql.driver", "DatabasePool '{}' has no asynchronous connections, statements [{}] are not "
                "prepared on the synchronous ones. Flag them CONNECTION_BOTH.", _connectionInfo.database, missing);
        }
    }
 
    return true;
}

References _connectionInfo, _connections, _preparedStatementSize, ASSERT, Close(), MySQLConnectionInfo::database, IDX_ASYNC, IDX_SYNCH, LOG_ERROR, and MySQLConnection::m_stmts.

Query() [1/3]

PreparedQueryResult ModuleDatabasePool::Query

(

PreparedStatementBase *

stmt

)

Delete proxy-class. Not needed anymore

{
    if (_connections[IDX_SYNCH].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(), IDX_SYNCH, MySQLConnection::Query(), and MySQLConnection::Unlock().

Query() [2/3]

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

overridevirtual

Implements DatabaseUpdatePool.

{
    if (_connections[IDX_SYNCH].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(), IDX_SYNCH, ResultSet::NextRow(), MySQLConnection::Query(), and MySQLConnection::Unlock().

Referenced by AsyncQuery(), and AsyncQuery().

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().

QueueSize()

std::size_t ModuleDatabasePool::QueueSize

(

)

const

{
    return _queue->Size();
}

References _queue.

SetConnectionInfo() [1/2]

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

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

References _asyncThreads, _connectionInfo, and _synchThreads.

SetConnectionInfo() [2/2]

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

{
    SetConnectionInfo(infoString, 0, synchThreads);
}

References SetConnectionInfo().

Referenced by SetConnectionInfo().

TryDirectCommitTransaction()

bool ModuleDatabasePool::TryDirectCommitTransaction ( std::shared_ptr< TransactionBase >  transaction )

private

Handle MySQL Errno 1213 without extending deadlock to the core itself

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

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

Referenced by AsyncCommitTransaction(), and DirectCommitTransaction().

WarnAboutSyncQueries()

void ModuleDatabasePool::WarnAboutSyncQueries

(

bool

warn

)

{
#ifdef ACORE_DEBUG
    _warnSyncQueries = warn;
#endif
}

Member Data Documentation

_asyncThreads

uint8 ModuleDatabasePool::_asyncThreads

private

Referenced by Open(), and SetConnectionInfo().

_connectionInfo

MySQLConnectionInfo ModuleDatabasePool::_connectionInfo

private

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

_connections

std::array<std::vector<std::unique_ptr<MySQLConnection> >, IDX_SIZE> ModuleDatabasePool::_connections

private

Referenced by AsyncCommitTransaction(), AsyncQuery(), AsyncQuery(), Close(), CommitTransaction(), DelayQueryHolder(), DirectExecute(), DirectExecute(), Execute(), Execute(), GetFreeConnection(), KeepAlive(), Open(), OpenConnections(), PrepareStatements(), Query(), Query(), and TryDirectCommitTransaction().

_preparedStatementSize

std::vector<uint8> ModuleDatabasePool::_preparedStatementSize

private

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

_queue

std::unique_ptr<ProducerConsumerQueue<SQLOperation*> > ModuleDatabasePool::_queue

private

Referenced by Close(), Enqueue(), Open(), OpenConnections(), QueueSize(), and ~ModuleDatabasePool().

_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