DatabaseLoader Class Reference

#include <DatabaseLoader.h>

Public Types
enum	DatabaseTypeFlags {   DATABASE_NONE = 0, DATABASE_LOGIN = 1, DATABASE_CHARACTER = 2, DATABASE_WORLD = 4,   DATABASE_HOTFIX = 8, DATABASE_MASK_ALL = DATABASE_LOGIN | DATABASE_CHARACTER | DATABASE_WORLD | DATABASE_HOTFIX }

Public Member Functions
	DatabaseLoader (std::string const &logger, uint32 const defaultUpdateMask)
template<class T >
DatabaseLoader &	AddDatabase (DatabaseWorkerPool< T > &pool, std::string const &name)
bool	Load ()

Private Types
using	Predicate = std::function< bool()>
using	Closer = std::function< void()>

Private Member Functions
bool	OpenDatabases ()
bool	PopulateDatabases ()
bool	UpdateDatabases ()
bool	PrepareStatements ()
bool	Process (std::queue< Predicate > &queue)

Private Attributes
std::string const	_logger
bool const	_autoSetup
uint32 const	_updateFlags
std::queue< Predicate >	_open
std::queue< Predicate >	_populate
std::queue< Predicate >	_update
std::queue< Predicate >	_prepare
std::stack< Closer >	_close

Member Typedef Documentation

using DatabaseLoader::Closer = std::function<void()>

private

using DatabaseLoader::Predicate = std::function<bool()>

private

Member Enumeration Documentation

enum DatabaseLoader::DatabaseTypeFlags

Enumerator
DATABASE_NONE
DATABASE_LOGIN
DATABASE_CHARACTER
DATABASE_WORLD
DATABASE_HOTFIX
DATABASE_MASK_ALL

 {
 DATABASE_NONE = 0,

 DATABASE_LOGIN = 1,
 DATABASE_CHARACTER = 2,
 DATABASE_WORLD = 4,
 DATABASE_HOTFIX = 8,

 DATABASE_MASK_ALL = DATABASE_LOGIN | DATABASE_CHARACTER | DATABASE_WORLD | DATABASE_HOTFIX
 };

Constructor & Destructor Documentation

DatabaseLoader::DatabaseLoader	(	std::string const &	logger,
		uint32 const	defaultUpdateMask
	)

 : _logger(logger), _autoSetup(sConfigMgr->GetBoolDefault("Updates.AutoSetup", true)),
 _updateFlags(sConfigMgr->GetIntDefault("Updates.EnableDatabases", defaultUpdateMask))
{
}

Member Function Documentation

template<class T >

template TC_DATABASE_API DatabaseLoader & DatabaseLoader::AddDatabase< WorldDatabaseConnection >	(	DatabaseWorkerPool< T > &	pool,
		std::string const &	name
	)

{
 bool const updatesEnabledForThis = DBUpdater<T>::IsEnabled(_updateFlags);

 _open.push([this, name, updatesEnabledForThis, &pool]() -> bool
 {
 std::string const dbString = sConfigMgr->GetStringDefault(name + "DatabaseInfo", "");
 if (dbString.empty())
 {
 TC_LOG_ERROR(_logger, "Database %s not specified in configuration file!", name.c_str());
 return false;
 }

 uint8 const asyncThreads = uint8(sConfigMgr->GetIntDefault(name + "Database.WorkerThreads", 1));
 if (asyncThreads < 1 || asyncThreads > 32)
 {
 TC_LOG_ERROR(_logger, "%s database: invalid number of worker threads specified. "
 "Please pick a value between 1 and 32.", name.c_str());
 return false;
 }

 uint8 const synchThreads = uint8(sConfigMgr->GetIntDefault(name + "Database.SynchThreads", 1));

 pool.SetConnectionInfo(dbString, asyncThreads, synchThreads);
 if (uint32 error = pool.Open())
 {
 // Database does not exist
 if ((error == ER_BAD_DB_ERROR) && updatesEnabledForThis && _autoSetup)
 {
 // Try to create the database and connect again if auto setup is enabled
 if (DBUpdater<T>::Create(pool) && (!pool.Open()))
 error = 0;
 }

 // If the error wasn't handled quit
 if (error)
 {
 TC_LOG_ERROR("sql.driver", "\nDatabasePool %s NOT opened. There were errors opening the MySQL connections. Check your SQLDriverLogFile "
 "for specific errors. Read wiki at http://www.trinitycore.info/display/tc/TrinityCore+Home", name.c_str());

 return false;
 }
 }
 // Add the close operation
 _close.push([&pool]
 {
 pool.Close();
 });
 return true;
 });

 // Populate and update only if updates are enabled for this pool
 if (updatesEnabledForThis)
 {
 _populate.push([this, name, &pool]() -> bool
 {
 if (!DBUpdater<T>::Populate(pool))
 {
 TC_LOG_ERROR(_logger, "Could not populate the %s database, see log for details.", name.c_str());
 return false;
 }
 return true;
 });

 _update.push([this, name, &pool]() -> bool
 {
 if (!DBUpdater<T>::Update(pool))
 {
 TC_LOG_ERROR(_logger, "Could not update the %s database, see log for details.", name.c_str());
 return false;
 }
 return true;
 });
 }

 _prepare.push([this, name, &pool]() -> bool
 {
 if (!pool.PrepareStatements())
 {
 TC_LOG_ERROR(_logger, "Could not prepare statements of the %s database, see log for details.", name.c_str());
 return false;
 }
 return true;
 });

 return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool DatabaseLoader::Load

(

)

{
 if (!_updateFlags)
 TC_LOG_INFO("sql.updates", "Automatic database updates are disabled for all databases!");

 if (!OpenDatabases())
 return false;

 if (!PopulateDatabases())
 return false;

 if (!UpdateDatabases())
 return false;

 if (!PrepareStatements())
 return false;

 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool DatabaseLoader::OpenDatabases ( )

private

{
 return Process(_open);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool DatabaseLoader::PopulateDatabases ( )

private

{
 return Process(_populate);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool DatabaseLoader::PrepareStatements ( )

private

{
 return Process(_prepare);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool DatabaseLoader::Process ( std::queue< Predicate > &  queue )

private

{
 while (!queue.empty())
 {
 if (!queue.front()())
 {
 // Close all open databases which have a registered close operation
 while (!_close.empty())
 {
 _close.top()();
 _close.pop();
 }

 return false;
 }

 queue.pop();
 }
 return true;
}

Here is the caller graph for this function:

bool DatabaseLoader::UpdateDatabases ( )

private

{
 return Process(_update);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

bool const DatabaseLoader::_autoSetup

private

std::stack<Closer> DatabaseLoader::_close

private

std::string const DatabaseLoader::_logger

private

std::queue<Predicate> DatabaseLoader::_open

private

std::queue<Predicate> DatabaseLoader::_populate

private

std::queue<Predicate> DatabaseLoader::_prepare

private

std::queue<Predicate> DatabaseLoader::_update

private

uint32 const DatabaseLoader::_updateFlags

private

---

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

• src/server/database/Database/DatabaseLoader.h
• src/server/database/Database/DatabaseLoader.cpp