#include <DatabaseWorkerPool.h>

Public Types
typedef T::Statements	PreparedStatementIndex

Public Member Functions
	DatabaseWorkerPool ()

	~DatabaseWorkerPool ()

void	SetConnectionInfo (std::string const &infoString, uint8 const asyncThreads, uint8 const synchThreads)

uint32	Open ()

void	Close ()

bool	PrepareStatements ()
	Prepares all prepared statements. More...

MySQLConnectionInfo const *	GetConnectionInfo () const

void	Execute (const char *sql)

template<typename Format , typename... Args>
void	PExecute (Format &&sql, Args &&...args)

void	Execute (PreparedStatement *stmt)

void	DirectExecute (const char *sql)

template<typename Format , typename... Args>
void	DirectPExecute (Format &&sql, Args &&...args)

void	DirectExecute (PreparedStatement *stmt)

QueryResult	Query (const char sql, T connection=nullptr)

template<typename Format , typename... Args>
QueryResult	PQuery (Format &&sql, T *conn, Args &&...args)

template<typename Format , typename... Args>
QueryResult	PQuery (Format &&sql, Args &&...args)

PreparedQueryResult	Query (PreparedStatement *stmt)

QueryResultFuture	AsyncQuery (const char *sql)

template<typename Format , typename... Args>
QueryResultFuture	AsyncPQuery (Format &&sql, Args &&...args)

PreparedQueryResultFuture	AsyncQuery (PreparedStatement *stmt)

QueryResultHolderFuture	DelayQueryHolder (SQLQueryHolder *holder)

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

void	CommitTransaction (SQLTransaction transaction)

void	DirectCommitTransaction (SQLTransaction &transaction)

void	ExecuteOrAppend (SQLTransaction &trans, PreparedStatement *stmt)

void	ExecuteOrAppend (SQLTransaction &trans, const char *sql)

PreparedStatement *	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...

Private Types
enum	InternalIndex { IDX_ASYNC, IDX_SYNCH, IDX_SIZE }

Private Member Functions
uint32	OpenConnections (InternalIndex type, uint8 numConnections)

unsigned long	EscapeString (char to, const char from, unsigned long length)

void	Enqueue (SQLOperation *op)

T *	GetFreeConnection ()

char const *	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

uint8	_async_threads

uint8	_synch_threads

Member Typedef Documentation

template<class T>

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

Other

Member Enumeration Documentation

template<class T>

enum DatabaseWorkerPool::InternalIndex

private

Enumerator
IDX_ASYNC
IDX_SYNCH
IDX_SIZE

  {
  IDX_ASYNC,
  IDX_SYNCH,
  IDX_SIZE
  };

Constructor & Destructor Documentation

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.");
  WPFatal(mysql_get_client_version() >= MIN_MYSQL_CLIENT_VERSION, "TrinityCore does not support MySQL versions below 5.1");
  WPFatal(mysql_get_client_version() == MYSQL_VERSION_ID, "Used MySQL library version (%s) does not match the version used to compile TrinityCore (%s).",
  mysql_get_client_info(), MYSQL_SERVER_VERSION);
 }

template<class T>

DatabaseWorkerPool< T >::~DatabaseWorkerPool ( )

inline

  {
  _queue->Cancel();
  }

Member Function Documentation

template<class T>

template<typename Format , typename... Args>

QueryResultFuture DatabaseWorkerPool< T >::AsyncPQuery	(	Format &&	sql,
		Args &&...	args
	)

inline

Enqueues a query in string format -with variable args- 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.

  {
  return AsyncQuery(Trinity::StringFormat(std::forward<Format>(sql), std::forward<Args>(args)...).c_str());
  }

Here is the call graph for this function:

template<class T >

QueryResultFuture DatabaseWorkerPool< T >::AsyncQuery ( const char * 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 result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

PreparedQueryResultFuture DatabaseWorkerPool< T >::AsyncQuery ( PreparedStatement * 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 result;
 }

Here is the call graph for this function:

template<class T>

SQLTransaction DatabaseWorkerPool< T >::BeginTransaction ( )

inline

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

Transaction context methods.

  {
  return SQLTransaction(new Transaction);
  }

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.

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

Here is the caller graph for this function:

template<class T >

void DatabaseWorkerPool< T >::CommitTransaction ( SQLTransaction 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 TRINITY_DEBUG
  switch (transaction->GetSize())
  {
  case 0:
  TC_LOG_DEBUG("sql.driver", "Transaction contains 0 queries. Not executing.");
  return;
  case 1:
  TC_LOG_DEBUG("sql.driver", "Warning: Transaction only holds 1 query, consider removing Transaction context in code.");
  break;
  default:
  break;
  }
 #endif // TRINITY_DEBUG
 
  Enqueue(new TransactionTask(transaction));
 }

template<class T >

QueryResultHolderFuture DatabaseWorkerPool< T >::DelayQueryHolder ( SQLQueryHolder * 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 result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

void DatabaseWorkerPool< T >::DirectCommitTransaction ( SQLTransaction & 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)
  {
  uint8 loopBreaker = 5;
  for (uint8 i = 0; i < loopBreaker; ++i)
  {
  if (!connection->ExecuteTransaction(transaction))
  break;
  }
  }
 
  transaction->Cleanup();
 
  connection->Unlock();
 }

template<class T>

void DatabaseWorkerPool< T >::DirectExecute ( const char * sql )

inline

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)
  return;
 
  T* connection = GetFreeConnection();
  connection->Execute(sql);
  connection->Unlock();
  }

Here is the caller graph for this function:

template<class T>

void DatabaseWorkerPool< T >::DirectExecute ( PreparedStatement * stmt )

inline

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

Here is the call graph for this function:

template<class T>

template<typename Format , typename... Args>

void DatabaseWorkerPool< T >::DirectPExecute	(	Format &&	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 (Trinity::IsFormatEmptyOrNull(sql))
  return;
 
  DirectExecute(Trinity::StringFormat(std::forward<Format>(sql), std::forward<Args>(args)...).c_str());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T>

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

inlineprivate

  {
  _queue->Push(op);
  }

Here is the caller graph for this function:

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

Here is the caller graph for this function:

template<class T>

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

inlineprivate

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

template<class T>

void DatabaseWorkerPool< T >::Execute ( const char * sql )

inline

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 (Trinity::IsFormatEmptyOrNull(sql))
  return;
 
  BasicStatementTask* task = new BasicStatementTask(sql);
  Enqueue(task);
  }

template<class T>

void DatabaseWorkerPool< T >::Execute ( PreparedStatement * stmt )

inline

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

Here is the call graph for this function:

template<class T>

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

inline

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

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T>

void DatabaseWorkerPool< T >::ExecuteOrAppend	(	SQLTransaction &	trans,
		const char *	sql
	)

inline

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

Here is the call graph for this function:

template<class T>

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

inline

  {
  return _connectionInfo.get();
  }

Here is the caller graph for this function:

template<class T>

char const* DatabaseWorkerPool< T >::GetDatabaseName ( ) const

inlineprivate

  {
  return _connectionInfo->database.c_str();
  }

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

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

Here is the caller graph for this function:

template<class T>

PreparedStatement* DatabaseWorkerPool< T >::GetPreparedStatement ( PreparedStatementIndex index )

inline

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(index);
  }

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

Here is the caller graph for this function:

template<class T >

uint32 DatabaseWorkerPool< T >::Open ( )

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

Here is the caller graph for this function:

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 Trinity::make_unique<T>(_queue.get(), *_connectionInfo);
  case IDX_SYNCH:
  return Trinity::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 (mysql_get_server_version(connection->GetHandle()) < MIN_MYSQL_SERVER_VERSION)
  {
  TC_LOG_ERROR("sql.driver", "TrinityCore does not support MySQL versions below 5.1");
  return 1;
  }
  else
  {
  _connections[type].push_back(std::move(connection));
  }
  }
 
  // Everything is fine
  return 0;
 }

template<class T>

template<typename Format , typename... Args>

void DatabaseWorkerPool< T >::PExecute	(	Format &&	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 (Trinity::IsFormatEmptyOrNull(sql))
  return;
 
  Execute(Trinity::StringFormat(std::forward<Format>(sql), std::forward<Args>(args)...).c_str());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T>

template<typename Format , typename... Args>

QueryResult DatabaseWorkerPool< T >::PQuery	(	Format &&	sql,
		T *	conn,
		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 (Trinity::IsFormatEmptyOrNull(sql))
  return QueryResult(nullptr);
 
  return Query(Trinity::StringFormat(std::forward<Format>(sql), std::forward<Args>(args)...).c_str(), conn);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T>

template<typename Format , typename... Args>

QueryResult DatabaseWorkerPool< T >::PQuery	(	Format &&	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)
  return QueryResult(nullptr);
 
  return Query(Trinity::StringFormat(std::forward<Format>(sql), std::forward<Args>(args)...).c_str());
  }

Here is the call graph for this function:

template<class T >

bool DatabaseWorkerPool< T >::PrepareStatements ( )

Prepares all prepared statements.

 {
  for (auto& connections : _connections)
  for (auto& connection : connections)
  {
  connection->LockIfReady();
  if (!connection->PrepareStatements())
  {
  connection->Unlock();
  Close();
  return false;
  }
  else
  connection->Unlock();
  }
 
  return true;
 }

Here is the caller graph for this function:

template<class T >

QueryResult DatabaseWorkerPool< T >::Query	(	const char *	sql,
		T *	connection = `nullptr`
	)

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.

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

Here is the call graph for this function:

template<class T >

PreparedQueryResult DatabaseWorkerPool< T >::Query ( PreparedStatement * 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(NULL);
  }
 
  return PreparedQueryResult(ret);
 }

Here is the call graph for this function:

template<class T >

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

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

Here is the caller graph for this function:

Member Data Documentation

template<class T>

uint8 DatabaseWorkerPool< T >::_async_threads

private

template<class T>

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

private

template<class T>

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

private

template<class T>

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

private

Queue shared by async worker threads.

template<class T>

uint8 DatabaseWorkerPool< T >::_synch_threads

private

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

src/server/database/Database/DatabaseWorkerPool.h
src/server/database/Database/DatabaseWorkerPool.cpp

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation