DatabaseWorkerPool< T > Class Template Reference

#include "DatabaseWorkerPool.h"

Public Types
typedef T::Statements	PreparedStatementIndex

Public Member Functions
	DatabaseWorkerPool ()
	~DatabaseWorkerPool ()
void	SetConnectionInfo (std::string_view infoString, uint8 const asyncThreads, uint8 const synchThreads)
uint32	Open ()
void	Close ()
bool	PrepareStatements ()
	Prepares all prepared statements. More...
MySQLConnectionInfo const *	GetConnectionInfo () const
void	Execute (std::string_view sql)
template<typename... Args>
void	Execute (std::string_view sql, Args &&... args)
void	Execute (PreparedStatement< T > *stmt)
void	DirectExecute (std::string_view sql)
template<typename... Args>
void	DirectExecute (std::string_view sql, Args &&... args)
void	DirectExecute (PreparedStatement< T > *stmt)
QueryResult	Query (std::string_view sql)
template<typename... Args>
QueryResult	Query (std::string_view sql, Args &&... args)
PreparedQueryResult	Query (PreparedStatement< T > *stmt)
QueryCallback	AsyncQuery (std::string_view sql)
QueryCallback	AsyncQuery (PreparedStatement< T > *stmt)
SQLQueryHolderCallback	DelayQueryHolder (std::shared_ptr< SQLQueryHolder< T > > holder)
SQLTransaction< T >	BeginTransaction ()
	Begins an automanaged transaction pointer that will automatically rollback if not commited. (Autocommit=0) More...
void	CommitTransaction (SQLTransaction< T > transaction)
TransactionCallback	AsyncCommitTransaction (SQLTransaction< T > transaction)
void	DirectCommitTransaction (SQLTransaction< T > &transaction)
void	ExecuteOrAppend (SQLTransaction< T > &trans, std::string_view sql)
void	ExecuteOrAppend (SQLTransaction< T > &trans, PreparedStatement< T > *stmt)
PreparedStatement< T > *	GetPreparedStatement (PreparedStatementIndex index)
void	EscapeString (std::string &str)
	Apply escape string'ing for current collation. (utf8) More...
void	KeepAlive ()
	Keeps all our MySQL connections alive, prevent the server from disconnecting us. More...
void	WarnAboutSyncQueries (bool warn)
std::size_t	QueueSize () const

Private Types
enum	InternalIndex {   IDX_ASYNC ,   IDX_SYNCH ,   IDX_SIZE }

Private Member Functions
uint32	OpenConnections (InternalIndex type, uint8 numConnections)
unsigned long	EscapeString (char *to, char const *from, unsigned long length)
void	Enqueue (SQLOperation *op)
T *	GetFreeConnection ()
std::string_view	GetDatabaseName () const

Private Attributes
std::unique_ptr< ProducerConsumerQueue< SQLOperation * > >	_queue
	Queue shared by async worker threads. More...
std::array< std::vector< std::unique_ptr< T > >, IDX_SIZE >	_connections
std::unique_ptr< MySQLConnectionInfo >	_connectionInfo
std::vector< uint8 >	_preparedStatementSize
uint8	_async_threads
uint8	_synch_threads

Detailed Description

template<class T>
class DatabaseWorkerPool< T >

Member Typedef Documentation

PreparedStatementIndex

template<class T >

typedef T::Statements DatabaseWorkerPool< T >::PreparedStatementIndex

Other

Member Enumeration Documentation

InternalIndex

template<class T >

enum DatabaseWorkerPool::InternalIndex

private

Enumerator
IDX_ASYNC
IDX_SYNCH
IDX_SIZE

    {
        IDX_ASYNC,
        IDX_SYNCH,
        IDX_SIZE
    };

Constructor & Destructor Documentation

DatabaseWorkerPool()

template<class T >

DatabaseWorkerPool< T >::DatabaseWorkerPool

                                          :
    _queue(new ProducerConsumerQueue<SQLOperation*>()),
    _async_threads(0),
    _synch_threads(0)
{
    WPFatal(mysql_thread_safe(), "Used MySQL library isn't thread-safe.");
 
    bool isSupportClientDB = mysql_get_client_version() >= MIN_MYSQL_CLIENT_VERSION;
    bool isSameClientDB = mysql_get_client_version() == MYSQL_VERSION_ID;
 
    WPFatal(isSupportClientDB, "AzerothCore does not support MySQL versions below 8.0\n\nFound version: {} / {}. Server compiled with: {}.\nSearch the wiki for ACE00043 in Common Errors (https://www.azerothcore.org/wiki/common-errors#ace00043).",
        mysql_get_client_info(), mysql_get_client_version(), MYSQL_VERSION_ID);
    WPFatal(isSameClientDB, "Used MySQL library version ({} id {}) does not match the version id used to compile AzerothCore (id {}).\nSearch the wiki for ACE00046 in Common Errors (https://www.azerothcore.org/wiki/common-errors#ace00046).",
        mysql_get_client_info(), mysql_get_client_version(), MYSQL_VERSION_ID);
}

References MIN_MYSQL_CLIENT_VERSION, and WPFatal.

~DatabaseWorkerPool()

template<class T >

DatabaseWorkerPool< T >::~DatabaseWorkerPool

{
    _queue->Cancel();
}

Member Function Documentation

AsyncCommitTransaction()

template<class T >

TransactionCallback DatabaseWorkerPool< T >::AsyncCommitTransaction

(

SQLTransaction< T >

transaction

)

Enqueues a collection of one-way SQL operations (can be both adhoc and prepared). The order in which these operations were appended to the transaction will be respected during execution.

{
#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 // ACORE_DEBUG
 
    TransactionWithResultTask* task = new TransactionWithResultTask(transaction);
    TransactionFuture result = task->GetFuture();
    Enqueue(task);
    return TransactionCallback(std::move(result));
}

References TransactionWithResultTask::GetFuture(), and LOG_DEBUG.

AsyncQuery() [1/2]

template<class T >

QueryCallback DatabaseWorkerPool< T >::AsyncQuery

(

PreparedStatement< T > *

stmt

)

Enqueues a query in prepared format that will set the value of the PreparedQueryResultFuture return object as soon as the query is executed. The return value is then processed in ProcessQueryCallback methods. Statement must be prepared with CONNECTION_ASYNC flag.

{
    PreparedStatementTask* task = new PreparedStatementTask(stmt, true);
    // Store future result before enqueueing - task might get already processed and deleted before returning from this method
    PreparedQueryResultFuture result = task->GetFuture();
    Enqueue(task);
    return QueryCallback(std::move(result));
}

References PreparedStatementTask::GetFuture().

AsyncQuery() [2/2]

template<class T >

QueryCallback DatabaseWorkerPool< T >::AsyncQuery

(

std::string_view

sql

)

Asynchronous query (with resultset) methods. Enqueues a query in string format that will set the value of the QueryResultFuture return object as soon as the query is executed. The return value is then processed in ProcessQueryCallback methods.

{
    BasicStatementTask* task = new BasicStatementTask(sql, true);
    // Store future result before enqueueing - task might get already processed and deleted before returning from this method
    QueryResultFuture result = task->GetFuture();
    Enqueue(task);
    return QueryCallback(std::move(result));
}

References BasicStatementTask::GetFuture().

BeginTransaction()

template<class T >

SQLTransaction< T > DatabaseWorkerPool< T >::BeginTransaction

Begins an automanaged transaction pointer that will automatically rollback if not commited. (Autocommit=0)

Transaction context methods.

{
    return std::make_shared<Transaction<T>>();
}

Close()

template<class T >

void DatabaseWorkerPool< T >::Close

Closes the actualy MySQL connection.

Shut down the synchronous connections There's no need for locking the connection, because DatabaseWorkerPool<>::Close should only be called after any other thread tasks in the core have exited, meaning there can be no concurrent access at this point.

{
    LOG_INFO("sql.driver", "Closing down DatabasePool '{}'.", GetDatabaseName());
 
    _connections[IDX_ASYNC].clear();
 
    LOG_INFO("sql.driver", "Asynchronous connections on DatabasePool '{}' terminated. Proceeding with synchronous connections.",
        GetDatabaseName());
 
    _connections[IDX_SYNCH].clear();
 
    LOG_INFO("sql.driver", "All connections on DatabasePool '{}' closed.", GetDatabaseName());
}

References LOG_INFO.

Referenced by DatabaseLoader::AddDatabase().

CommitTransaction()

template<class T >

void DatabaseWorkerPool< T >::CommitTransaction

(

SQLTransaction< T >

transaction

)

Enqueues a collection of one-way SQL operations (can be both adhoc and prepared). The order in which these operations were appended to the transaction will be respected during execution.

{
#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 // ACORE_DEBUG
 
    Enqueue(new TransactionTask(transaction));
}

References LOG_DEBUG.

DelayQueryHolder()

template<class T >

SQLQueryHolderCallback DatabaseWorkerPool< T >::DelayQueryHolder

(

std::shared_ptr< SQLQueryHolder< T > >

holder

)

Enqueues a vector of SQL operations (can be both adhoc and prepared) that will set the value of the QueryResultHolderFuture return object as soon as the query is executed. The return value is then processed in ProcessQueryCallback methods. Any prepared statements added to this holder need to be prepared with the CONNECTION_ASYNC flag.

{
    SQLQueryHolderTask* task = new SQLQueryHolderTask(holder);
    // Store future result before enqueueing - task might get already processed and deleted before returning from this method
    QueryResultHolderFuture result = task->GetFuture();
    Enqueue(task);
    return { std::move(holder), std::move(result) };
}

References SQLQueryHolderTask::GetFuture().

DirectCommitTransaction()

template<class T >

void DatabaseWorkerPool< T >::DirectCommitTransaction

(

SQLTransaction< T > &

transaction

)

Directly executes a collection of one-way SQL operations (can be both adhoc and prepared). The order in which these operations were appended to the transaction will be respected during execution.

Handle MySQL Errno 1213 without extending deadlock to the core itself

Todo:

More elegant way

Clean up now.

{
    T* connection = GetFreeConnection();
    int errorCode = connection->ExecuteTransaction(transaction);
 
    if (!errorCode)
    {
        connection->Unlock();      // OK, operation succesful
        return;
    }
 
    if (errorCode == ER_LOCK_DEADLOCK)
    {
        //todo: handle multiple sync threads deadlocking in a similar way as async threads
        uint8 loopBreaker = 5;
 
        for (uint8 i = 0; i < loopBreaker; ++i)
        {
            if (!connection->ExecuteTransaction(transaction))
                break;
        }
    }
 
    transaction->Cleanup();
 
    connection->Unlock();
}

DirectExecute() [1/3]

template<class T >

void DatabaseWorkerPool< T >::DirectExecute

(

PreparedStatement< T > *

stmt

)

Directly executes a one-way SQL operation in prepared statement format, that will block the calling thread until finished. Statement must be prepared with the CONNECTION_SYNCH flag.

Delete proxy-class. Not needed anymore

{
    T* connection = GetFreeConnection();
    connection->Execute(stmt);
    connection->Unlock();
 
    delete stmt;
}

DirectExecute() [2/3]

template<class T >

void DatabaseWorkerPool< T >::DirectExecute

(

std::string_view

sql

)

Direct synchronous one-way statement methods. Directly executes a one-way SQL operation in string format, that will block the calling thread until finished. This method should only be used for queries that are only executed once, e.g during startup.

{
    if (sql.empty())
        return;
 
    T* connection = GetFreeConnection();
    connection->Execute(sql);
    connection->Unlock();
}

Referenced by DBUpdater< T >::Apply(), and DatabaseWorkerPool< T >::DirectExecute().

DirectExecute() [3/3]

template<class T >

template<typename... Args>

void DatabaseWorkerPool< T >::DirectExecute ( std::string_view  sql, Args &&...  args  )

inline

Directly executes a one-way SQL operation in string format -with variable args-, that will block the calling thread until finished. This method should only be used for queries that are only executed once, e.g during startup.

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

References DatabaseWorkerPool< T >::DirectExecute(), and Acore::StringFormat().

Enqueue()

template<class T >

void DatabaseWorkerPool< T >::Enqueue ( SQLOperation *  op )

private

{
    _queue->Push(op);
}

EscapeString() [1/2]

template<class T >

unsigned long DatabaseWorkerPool< T >::EscapeString ( char *  to, char const *  from, unsigned long  length  )

private

{
    if (!to || !from || !length)
        return 0;
 
    return _connections[IDX_SYNCH].front()->EscapeString(to, from, length);
}

EscapeString() [2/2]

template<class T >

void DatabaseWorkerPool< T >::EscapeString

(

std::string &

str

)

Apply escape string'ing for current collation. (utf8)

{
    if (str.empty())
        return;
 
    char* buf = new char[str.size() * 2 + 1];
    EscapeString(buf, str.c_str(), uint32(str.size()));
    str = buf;
    delete[] buf;
}

Execute() [1/3]

template<class T >

void DatabaseWorkerPool< T >::Execute

(

PreparedStatement< T > *

stmt

)

Enqueues a one-way SQL operation in prepared statement format that will be executed asynchronously. Statement must be prepared with CONNECTION_ASYNC flag.

{
    PreparedStatementTask* task = new PreparedStatementTask(stmt);
    Enqueue(task);
}

Execute() [2/3]

template<class T >

void DatabaseWorkerPool< T >::Execute

(

std::string_view

sql

)

Delayed one-way statement methods. Enqueues a one-way SQL operation in string format that will be executed asynchronously. This method should only be used for queries that are only executed once, e.g during startup.

{
    if (sql.empty())
        return;
 
    BasicStatementTask* task = new BasicStatementTask(sql);
    Enqueue(task);
}

Referenced by DatabaseWorkerPool< T >::Execute().

Execute() [3/3]

template<class T >

template<typename... Args>

void DatabaseWorkerPool< T >::Execute ( std::string_view  sql, Args &&...  args  )

inline

Enqueues a one-way SQL operation in string format -with variable args- that will be executed asynchronously. This method should only be used for queries that are only executed once, e.g during startup.

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

References DatabaseWorkerPool< T >::Execute(), and Acore::StringFormat().

ExecuteOrAppend() [1/2]

template<class T >

void DatabaseWorkerPool< T >::ExecuteOrAppend	(	SQLTransaction< T > &	trans,
		PreparedStatement< T > *	stmt
	)

Method used to execute prepared statements in a diverse context. Will be wrapped in a transaction if valid object is present, otherwise executed standalone.

{
    if (!trans)
        Execute(stmt);
    else
        trans->Append(stmt);
}

ExecuteOrAppend() [2/2]

template<class T >

void DatabaseWorkerPool< T >::ExecuteOrAppend	(	SQLTransaction< T > &	trans,
		std::string_view	sql
	)

Method used to execute ad-hoc statements in a diverse context. Will be wrapped in a transaction if valid object is present, otherwise executed standalone.

{
    if (!trans)
        Execute(sql);
    else
        trans->Append(sql);
}

GetConnectionInfo()

template<class T >

MySQLConnectionInfo const * DatabaseWorkerPool< T >::GetConnectionInfo ( ) const

inline

    {
        return _connectionInfo.get();
    }

References DatabaseWorkerPool< T >::_connectionInfo.

Referenced by DBUpdater< T >::ApplyFile(), DBUpdater< T >::Create(), and DBUpdater< T >::Update().

GetDatabaseName()

template<class T >

std::string_view DatabaseWorkerPool< T >::GetDatabaseName

private

{
    return std::string_view{ _connectionInfo->database };
}

GetFreeConnection()

template<class T >

T * DatabaseWorkerPool< T >::GetFreeConnection

private

Gets a free connection in the synchronous connection pool. Caller MUST call t->Unlock() after touching the MySQL context to prevent deadlocks.

Block forever until a connection is free

Must be matched with t->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();
    T* connection = nullptr;
 
    for (;;)
    {
        connection = _connections[IDX_SYNCH][++i % num_cons].get();
        if (connection->LockIfReady())
            break;
    }
 
    return connection;
}

References LOG_WARN.

GetPreparedStatement()

template<class T >

PreparedStatement< T > * DatabaseWorkerPool< T >::GetPreparedStatement

(

PreparedStatementIndex

index

)

Automanaged (internally) pointer to a prepared statement object for usage in upper level code. Pointer is deleted in this->DirectExecute(PreparedStatement*), this->Query(PreparedStatement*) or PreparedStatementTask::~PreparedStatementTask. This object is not tied to the prepared statement on the MySQL context yet until execution.

{
    return new PreparedStatement<T>(index, _preparedStatementSize[index]);
}

KeepAlive()

template<class T >

void DatabaseWorkerPool< T >::KeepAlive

Keeps all our MySQL connections alive, prevent the server from disconnecting us.

Ping synchronous connections

Assuming all worker threads are free, every worker thread will receive 1 ping operation request If one or more worker threads are busy, the ping operations will not be split evenly, but this doesn't matter as the sole purpose is to prevent connections from idling.

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

Open()

template<class T >

uint32 DatabaseWorkerPool< T >::Open

{
    WPFatal(_connectionInfo.get(), "Connection info was not set!");
 
    LOG_INFO("sql.driver", "Opening DatabasePool '{}'. Asynchronous connections: {}, synchronous connections: {}.",
        GetDatabaseName(), _async_threads, _synch_threads);
 
    uint32 error = OpenConnections(IDX_ASYNC, _async_threads);
 
    if (error)
        return error;
 
    error = OpenConnections(IDX_SYNCH, _synch_threads);
 
    if (!error)
    {
        LOG_INFO("sql.driver", "DatabasePool '{}' opened successfully. {} total connections running.",
            GetDatabaseName(), (_connections[IDX_SYNCH].size() + _connections[IDX_ASYNC].size()));
    }
 
    LOG_INFO("sql.driver", " ");
 
    return error;
}

References LOG_INFO, and WPFatal.

Referenced by DatabaseLoader::AddDatabase().

OpenConnections()

template<class T >

uint32 DatabaseWorkerPool< T >::OpenConnections ( InternalIndex  type, uint8  numConnections  )

private

{
    for (uint8 i = 0; i < numConnections; ++i)
    {
        // Create the connection
        auto connection = [&]
        {
            switch (type)
            {
            case IDX_ASYNC:
                return std::make_unique<T>(_queue.get(), *_connectionInfo);
            case IDX_SYNCH:
                return std::make_unique<T>(*_connectionInfo);
            default:
                ABORT();
            }
        }();
 
        if (uint32 error = connection->Open())
        {
            // Failed to open a connection or invalid version, abort and cleanup
            _connections[type].clear();
            return error;
        }
        else if (DatabaseIncompatibleVersion(connection->GetServerInfo()))
        {
            LOG_ERROR("sql.driver", "AzerothCore does not support MySQL versions below 8.0\n\nFound server version: {}. Server compiled with: {}.",
                connection->GetServerInfo(), MYSQL_VERSION_ID);
            return 1;
        }
        else
        {
            _connections[type].push_back(std::move(connection));
        }
    }
 
    // Everything is fine
    return 0;
}

References ABORT, DatabaseIncompatibleVersion(), and LOG_ERROR.

PrepareStatements()

template<class T >

bool DatabaseWorkerPool< T >::PrepareStatements

Prepares all prepared statements.

{
    for (auto const& connections : _connections)
    {
        for (auto const& connection : connections)
        {
            connection->LockIfReady();
            if (!connection->PrepareStatements())
            {
                connection->Unlock();
                Close();
                return false;
            }
            else
                connection->Unlock();
 
            std::size_t const preparedSize = connection->m_stmts.size();
            if (_preparedStatementSize.size() < preparedSize)
                _preparedStatementSize.resize(preparedSize);
 
            for (std::size_t i = 0; i < preparedSize; ++i)
            {
                // already set by another connection
                // (each connection only has prepared statements of it's own type sync/async)
                if (_preparedStatementSize[i] > 0)
                    continue;
 
                if (MySQLPreparedStatement* stmt = connection->m_stmts[i].get())
                {
                    uint32 const paramCount = stmt->GetParameterCount();
 
                    // WH only supports uint8 indices.
                    ASSERT(paramCount < std::numeric_limits<uint8>::max());
 
                    _preparedStatementSize[i] = static_cast<uint8>(paramCount);
                }
            }
        }
    }
 
    return true;
}

References ASSERT, and Close.

Referenced by DatabaseLoader::AddDatabase().

Query() [1/3]

template<class T >

PreparedQueryResult DatabaseWorkerPool< T >::Query

(

PreparedStatement< T > *

stmt

)

Directly executes an SQL query in prepared format that will block the calling thread until finished. Returns reference counted auto pointer, no need for manual memory management in upper level code. Statement must be prepared with CONNECTION_SYNCH flag.

Delete proxy-class. Not needed anymore

{
    auto connection = GetFreeConnection();
    PreparedResultSet* ret = connection->Query(stmt);
    connection->Unlock();
 
    delete stmt;
 
    if (!ret || !ret->GetRowCount())
    {
        delete ret;
        return PreparedQueryResult(nullptr);
    }
 
    return PreparedQueryResult(ret);
}

References PreparedResultSet::GetRowCount().

Query() [2/3]

template<class T >

QueryResult DatabaseWorkerPool< T >::Query

(

std::string_view

sql

)

Synchronous query (with resultset) methods. Directly executes an SQL query in string format that will block the calling thread until finished. Returns reference counted auto pointer, no need for manual memory management in upper level code.

{
    auto connection = GetFreeConnection();
 
    ResultSet* result = connection->Query(sql);
    connection->Unlock();
 
    if (!result || !result->GetRowCount() || !result->NextRow())
    {
        delete result;
        return QueryResult(nullptr);
    }
 
    return QueryResult(result);
}

References ResultSet::GetRowCount(), and ResultSet::NextRow().

Referenced by DatabaseWorkerPool< T >::Query(), and DBUpdater< T >::Retrieve().

Query() [3/3]

template<class T >

template<typename... Args>

QueryResult DatabaseWorkerPool< T >::Query ( std::string_view  sql, Args &&...  args  )

inline

Directly executes an SQL query in string format -with variable args- that will block the calling thread until finished. Returns reference counted auto pointer, no need for manual memory management in upper level code.

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

References DatabaseWorkerPool< T >::Query(), and Acore::StringFormat().

QueueSize()

template<class T >

std::size_t DatabaseWorkerPool< T >::QueueSize

{
    return _queue->Size();
}

SetConnectionInfo()

template<class T >

void DatabaseWorkerPool< T >::SetConnectionInfo	(	std::string_view	infoString,
		uint8 const	asyncThreads,
		uint8 const	synchThreads
	)

{
    _connectionInfo = std::make_unique<MySQLConnectionInfo>(infoString);
 
    _async_threads = asyncThreads;
    _synch_threads = synchThreads;
}

Referenced by DatabaseLoader::AddDatabase().

WarnAboutSyncQueries()

template<class T >

void DatabaseWorkerPool< T >::WarnAboutSyncQueries ( bool  warn )

inline

    {
#ifdef ACORE_DEBUG
        _warnSyncQueries = warn;
#endif
    }

Member Data Documentation

_async_threads

template<class T >

uint8 DatabaseWorkerPool< T >::_async_threads

private

_connectionInfo

template<class T >

std::unique_ptr<MySQLConnectionInfo> DatabaseWorkerPool< T >::_connectionInfo

private

Referenced by DatabaseWorkerPool< T >::GetConnectionInfo().

_connections

template<class T >

std::array<std::vector<std::unique_ptr<T> >, IDX_SIZE> DatabaseWorkerPool< T >::_connections

private

_preparedStatementSize

template<class T >

std::vector<uint8> DatabaseWorkerPool< T >::_preparedStatementSize

private

_queue

template<class T >

std::unique_ptr<ProducerConsumerQueue<SQLOperation*> > DatabaseWorkerPool< T >::_queue

private

Queue shared by async worker threads.

_synch_threads

template<class T >

uint8 DatabaseWorkerPool< T >::_synch_threads

private