From 7e2770a5362c481049d30a1b30ae4f7cda1f65e3 Mon Sep 17 00:00:00 2001 From: Mordred Date: Sat, 7 Oct 2017 23:10:13 +0200 Subject: [PATCH] Updated a number of queries to use new system --- src/libraries | 2 +- .../Database/CharaDbConnection.cpp | 40 ++- .../Database/CharaDbConnection.h | 4 +- .../Server_Common/Database/DbConnection.cpp | 42 +-- .../Server_Common/Database/DbConnection.h | 24 +- .../Server_Common/Database/DbWorker.cpp | 6 +- src/servers/Server_Common/Database/DbWorker.h | 5 +- .../Server_Common/Database/DbWorkerPool.cpp | 66 ++--- .../Server_Common/Database/DbWorkerPool.h | 18 +- .../Database/PreparedStatement.cpp | 14 +- .../Database/PreparedStatement.h | 5 +- .../Server_Common/Database/StatementTask.cpp | 3 +- .../Server_Common/Database/StatementTask.h | 6 +- src/servers/Server_REST/PlayerMinimal.cpp | 247 ++++++++---------- src/servers/Server_REST/PlayerMinimal.h | 6 +- src/servers/Server_REST/SapphireAPI.cpp | 8 +- src/servers/Server_REST/main.cpp | 22 ++ src/servers/Server_Zone/Actor/PlayerSql.cpp | 32 +-- src/servers/Server_Zone/ServerZone.cpp | 8 +- 19 files changed, 280 insertions(+), 278 deletions(-) diff --git a/src/libraries b/src/libraries index 71e7fc37..c71860d7 160000 --- a/src/libraries +++ b/src/libraries @@ -1 +1 @@ -Subproject commit 71e7fc3744abc424c52413f579d60e1916594532 +Subproject commit c71860d79596a93e5668169ac3f0309397c7218c diff --git a/src/servers/Server_Common/Database/CharaDbConnection.cpp b/src/servers/Server_Common/Database/CharaDbConnection.cpp index 09e5f057..67b5f4fd 100644 --- a/src/servers/Server_Common/Database/CharaDbConnection.cpp +++ b/src/servers/Server_Common/Database/CharaDbConnection.cpp @@ -5,7 +5,7 @@ Core::Db::CharaDbConnection::CharaDbConnection( ConnectionInfo& connInfo ) : DbC { } -Core::Db::CharaDbConnection::CharaDbConnection( Core::LockedWaitQueue< Operation * >* q, +Core::Db::CharaDbConnection::CharaDbConnection( Core::LockedWaitQueue< boost::shared_ptr< Operation > >* q, ConnectionInfo& connInfo) : DbConnection( q, connInfo ) { } @@ -21,23 +21,37 @@ void Core::Db::CharaDbConnection::doPrepareStatements() prepareStatement( CHAR_INS_TEST, "INSERT INTO zoneservers ( id, ip, port ) VALUES ( ?, ?, ?);", CONNECTION_BOTH ); - prepareStatement( CHAR_SEL_LOAD, "SELECT c.Name, c.PrimaryTerritoryId, c.Hp, c.Mp, c.Gp, c.Mode, " - "c.Pos_0_0, c.Pos_0_1, c.Pos_0_2, c.Pos_0_3, c.FirstLogin, " - "c.Customize, c.ModelMainWeapon, c.ModelSubWeapon, c.ModelEquip, " - "cd.GuardianDeity, cd.BirthDay, cd.BirthMonth, cd.Status, cd.Class, " - "cd.Homepoint, cd.HowTo, c.ContentId, c.Voice, cd.QuestCompleteFlags, " - "cd.QuestTracking, c.IsNewGame, cd.Aetheryte, cd.unlocks, cd.Discovery, " - "cd.StartTown, cd.TotalPlayTime, c.IsNewAdventurer, cd.GrandCompany, " - "cd.GrandCompanyRank, cd.CFPenaltyUntil, cd.OpeningSequence, cd.GMRank " - "FROM charabase AS c " - " INNER JOIN charadetail AS cd " - " ON c.CharacterId = cd.CharacterId " - "WHERE c.CharacterId = ?;", CONNECTION_SYNCH ); + prepareStatement( CHAR_SEL_LOAD, "SELECT ContentId, Name, Hp, Mp, Tp, Gp, Mode, Mount, InvincibleGM, Voice, " + "Customize, ModelMainWeapon, ModelSubWeapon, ModelSystemWeapon, " + "ModelEquip, EmoteModeType, FirstLoginTime, Language, IsNewGame, " + "IsNewAdventurer, TerritoryType, TerritoryId, PosX, PosY, PosZ, PosR, " + "OTerritoryType, OTerritoryId, OPosX, OPosY, OPosZ, OPosR, GuardianDeity, " + "BirthDay, BirthMonth, Class, Status, TotalPlayTime, FirstClass, HomePoint, " + "FavoritePoint, RestPoint, StartTown, ActiveTitle, TitleList, Achievement, " + "Aetheryte, HowTo, Minions, Mounts, EquippedMannequin, ConfigFlags, " + "QuestCompleteFlags, OpeningSequence, QuestTracking, GrandCompany, " + "GrandCompanyRank, Discovery, GMRank, Unlocks, CFPenaltyUntil " + "FROM charainfo WHERE CharacterId = ?;", CONNECTION_SYNCH ); + + + prepareStatement( CHAR_SEL_LOAD_MINIMAL, "SELECT Name, Customize, ModelEquip, TerritoryId, GuardianDeity, " + "Class, ContentId, BirthDay, BirthMonth " + "FROM charainfo WHERE CharacterId = ?;", CONNECTION_SYNCH ); prepareStatement( CHAR_SEL_LOAD_CLASSINFO, "SELECT * FROM characlass WHERE CharacterId = ?;", CONNECTION_SYNCH ); prepareStatement( CHAR_SEL_LOAD_SEARCHINFO, "SELECT * FROM charainfosearch WHERE CharacterId = ?;", CONNECTION_SYNCH ); prepareStatement( CHAR_SEL_LOAD_QUESTINFO, "SELECT * FROM charaquest WHERE CharacterId = ?;", CONNECTION_SYNCH ); + prepareStatement( CHAR_INS_CHARINFO, "INSERT INTO charainfo (AccountId, CharacterId, ContentId, Name, Hp, Mp, " + "Customize, Voice, IsNewGame, TerritoryId, PosX, PosY, PosZ, PosR, ModelEquip, " + "IsNewAdventurer, GuardianDeity, Birthday, BirthMonth, Class, Status, FirstClass, " + "HomePoint, StartTown, Discovery, HowTo, QuestCompleteFlags, Unlocks, QuestTracking, " + "Aetheryte, GMRank, UPDATE_DATE ) " + "VALUES ( ?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,NOW() );", + CONNECTION_SYNCH ); + + + diff --git a/src/servers/Server_Common/Database/CharaDbConnection.h b/src/servers/Server_Common/Database/CharaDbConnection.h index 9827f90d..3bd909a4 100644 --- a/src/servers/Server_Common/Database/CharaDbConnection.h +++ b/src/servers/Server_Common/Database/CharaDbConnection.h @@ -12,9 +12,11 @@ class DbConnectionInfo; enum CharaDbStatements : uint32_t { CHAR_SEL_LOAD, + CHAR_SEL_LOAD_MINIMAL, CHAR_SEL_LOAD_CLASSINFO, CHAR_SEL_LOAD_SEARCHINFO, CHAR_SEL_LOAD_QUESTINFO, + CHAR_INS_CHARINFO, CHAR_INS_TEST, MAX_STATEMENTS @@ -26,7 +28,7 @@ public: typedef CharaDbStatements Statements; CharaDbConnection( ConnectionInfo& connInfo ); - CharaDbConnection( Core::LockedWaitQueue< Operation* >* q, ConnectionInfo &connInfo ); + CharaDbConnection( Core::LockedWaitQueue< boost::shared_ptr< Operation > >* q, ConnectionInfo &connInfo ); ~CharaDbConnection(); diff --git a/src/servers/Server_Common/Database/DbConnection.cpp b/src/servers/Server_Common/Database/DbConnection.cpp index f3045d3f..c4a00cd3 100644 --- a/src/servers/Server_Common/Database/DbConnection.cpp +++ b/src/servers/Server_Common/Database/DbConnection.cpp @@ -4,6 +4,7 @@ #include "src/servers/Server_Common/Logging/Logger.h" #include "PreparedStatement.h" +#include extern Core::Logger g_log; @@ -19,7 +20,8 @@ Core::Db::DbConnection::DbConnection( ConnectionInfo &connInfo ) : } -Core::Db::DbConnection::DbConnection( Core::LockedWaitQueue* queue, Core::Db::ConnectionInfo& connInfo ) : +Core::Db::DbConnection::DbConnection( Core::LockedWaitQueue< boost::shared_ptr< Operation > >* queue, + Core::Db::ConnectionInfo& connInfo ) : m_reconnecting( false ), m_prepareError( false ), m_queue( queue ), @@ -27,7 +29,7 @@ Core::Db::DbConnection::DbConnection( Core::LockedWaitQueue* queue, m_connectionInfo( connInfo ), m_connectionFlags( CONNECTION_ASYNC ) { - m_worker = std::unique_ptr< DbWorker >( new DbWorker( m_queue, this ) ); + m_worker = boost::make_shared< DbWorker >( m_queue, this ); } Core::Db::DbConnection::~DbConnection() @@ -51,18 +53,16 @@ void Core::Db::DbConnection::close() uint32_t Core::Db::DbConnection::open() { - Mysql::MySqlBase base; + boost::shared_ptr< Mysql::MySqlBase > base( new Mysql::MySqlBase() ); Mysql::optionMap options; options[ MYSQL_OPT_RECONNECT ] = "1"; options[ MYSQL_SET_CHARSET_NAME ] = "utf8"; try { - m_pConnection = std::shared_ptr< Mysql::Connection >( base.connect( m_connectionInfo.host, - m_connectionInfo.user, - m_connectionInfo.password, - options, - m_connectionInfo.port ) ); + m_pConnection = base->connect( m_connectionInfo.host, m_connectionInfo.user, m_connectionInfo.password, + options, m_connectionInfo.port ); + m_pConnection->setSchema( m_connectionInfo.database ); } catch( std::runtime_error& e ) @@ -113,7 +113,7 @@ bool Core::Db::DbConnection::execute( const std::string& sql ) { try { - Mysql::Statement* stmt( m_pConnection->createStatement() ); + auto stmt = m_pConnection->createStatement(); bool result = stmt->execute( sql ); return result; } @@ -124,12 +124,12 @@ bool Core::Db::DbConnection::execute( const std::string& sql ) } } -Mysql::ResultSet *Core::Db::DbConnection::query( const std::string& sql ) +boost::shared_ptr< Mysql::ResultSet > Core::Db::DbConnection::query( const std::string& sql ) { try { - Mysql::Statement* stmt( m_pConnection->createStatement() ); - Mysql::ResultSet* result = stmt->executeQuery( sql ); + auto stmt = m_pConnection->createStatement(); + auto result = stmt->executeQuery( sql ); return result; } catch( std::runtime_error& e ) @@ -140,15 +140,15 @@ Mysql::ResultSet *Core::Db::DbConnection::query( const std::string& sql ) } -Mysql::ResultSet* Core::Db::DbConnection::query( Core::Db::PreparedStatement* stmt ) +boost::shared_ptr< Mysql::ResultSet > Core::Db::DbConnection::query( boost::shared_ptr< Core::Db::PreparedStatement > stmt ) { - Mysql::ResultSet* res = nullptr; + boost::shared_ptr< Mysql::ResultSet > res( nullptr ); if( !stmt ) return nullptr; uint32_t index = stmt->getIndex(); - Mysql::PreparedStatement* pStmt = getPreparedStatement( index ); + auto pStmt = getPreparedStatement( index ); if( !pStmt ) return nullptr; @@ -167,14 +167,14 @@ Mysql::ResultSet* Core::Db::DbConnection::query( Core::Db::PreparedStatement* st } -bool Core::Db::DbConnection::execute( Core::Db::PreparedStatement* stmt ) +bool Core::Db::DbConnection::execute( boost::shared_ptr< Core::Db::PreparedStatement > stmt ) { if( !stmt ) return false; uint32_t index = stmt->getIndex(); - Mysql::PreparedStatement* pStmt = getPreparedStatement( index ); + auto pStmt = getPreparedStatement( index ); if( !pStmt ) return false; @@ -192,10 +192,10 @@ bool Core::Db::DbConnection::execute( Core::Db::PreparedStatement* stmt ) } } -Mysql::PreparedStatement* Core::Db::DbConnection::getPreparedStatement( uint32_t index ) +boost::shared_ptr< Mysql::PreparedStatement > Core::Db::DbConnection::getPreparedStatement( uint32_t index ) { assert( index < m_stmts.size() ); - Mysql::PreparedStatement* ret = m_stmts[index].get(); + auto ret = m_stmts[index]; if( !ret ) nullptr; @@ -215,7 +215,7 @@ void Core::Db::DbConnection::prepareStatement( uint32_t index, const std::string return; } - Mysql::PreparedStatement* pStmt = nullptr; + boost::shared_ptr< Mysql::PreparedStatement > pStmt( nullptr ); try { @@ -227,7 +227,7 @@ void Core::Db::DbConnection::prepareStatement( uint32_t index, const std::string m_prepareError = true; } - m_stmts[index] = std::unique_ptr< Mysql::PreparedStatement >( pStmt ); + m_stmts[index] = boost::shared_ptr< Mysql::PreparedStatement >( pStmt ); } diff --git a/src/servers/Server_Common/Database/DbConnection.h b/src/servers/Server_Common/Database/DbConnection.h index f86c145a..6aea6589 100644 --- a/src/servers/Server_Common/Database/DbConnection.h +++ b/src/servers/Server_Common/Database/DbConnection.h @@ -9,6 +9,8 @@ #include "src/servers/Server_Common/Util/LockedWaitQueue.h" #include #include +#include +#include namespace Mysql { @@ -49,13 +51,13 @@ namespace Db typedef std::map< uint32_t, std::pair< std::string, ConnectionFlags > > PreparedStatementMap; - class DbConnection + class DbConnection : public boost::enable_shared_from_this< DbConnection > { public: // Constructor for synchronous connections. DbConnection( ConnectionInfo& connInfo ); // Constructor for asynchronous connections. - DbConnection( Core::LockedWaitQueue< Operation* >* queue, ConnectionInfo& connInfo ); + DbConnection( Core::LockedWaitQueue< boost::shared_ptr< Operation > >* queue, ConnectionInfo& connInfo ); virtual ~DbConnection(); virtual uint32_t open(); @@ -64,9 +66,9 @@ namespace Db bool prepareStatements(); bool execute( const std::string& sql ); - bool execute( PreparedStatement* stmt ); - Mysql::ResultSet* query( const std::string& sql ); - Mysql::ResultSet* query( PreparedStatement* stmt ); + bool execute( boost::shared_ptr< PreparedStatement > stmt ); + boost::shared_ptr< Mysql::ResultSet > query( const std::string& sql ); + boost::shared_ptr< Mysql::ResultSet > query( boost::shared_ptr< PreparedStatement > stmt ); void beginTransaction(); void rollbackTransaction(); @@ -79,22 +81,22 @@ namespace Db void unlock(); - std::shared_ptr< Mysql::Connection > getConnection() { return m_pConnection; } - Mysql::PreparedStatement* getPreparedStatement( uint32_t index ); + boost::shared_ptr< Mysql::Connection > getConnection() { return m_pConnection; } + boost::shared_ptr< Mysql::PreparedStatement > getPreparedStatement( uint32_t index ); void prepareStatement( uint32_t index, const std::string& sql, ConnectionFlags flags ); virtual void doPrepareStatements() = 0; protected: - std::vector< std::unique_ptr< Mysql::PreparedStatement > > m_stmts; + std::vector< boost::shared_ptr< Mysql::PreparedStatement > > m_stmts; PreparedStatementMap m_queries; bool m_reconnecting; bool m_prepareError; private: - LockedWaitQueue< Operation* >* m_queue; - std::unique_ptr< DbWorker > m_worker; - std::shared_ptr< Mysql::Connection > m_pConnection; + LockedWaitQueue< boost::shared_ptr< Operation > >* m_queue; + boost::shared_ptr< DbWorker > m_worker; + boost::shared_ptr< Mysql::Connection > m_pConnection; ConnectionInfo& m_connectionInfo; ConnectionFlags m_connectionFlags; std::mutex m_mutex; diff --git a/src/servers/Server_Common/Database/DbWorker.cpp b/src/servers/Server_Common/Database/DbWorker.cpp index 47ce7947..9c1f5c8b 100644 --- a/src/servers/Server_Common/Database/DbWorker.cpp +++ b/src/servers/Server_Common/Database/DbWorker.cpp @@ -2,7 +2,7 @@ #include "Operation.h" #include -Core::Db::DbWorker::DbWorker( Core::LockedWaitQueue< Operation* >* newQueue, DbConnection* pConn ) +Core::Db::DbWorker::DbWorker( Core::LockedWaitQueue< boost::shared_ptr< Operation > >* newQueue, DbConnection* pConn ) { m_pConn = pConn; m_queue = newQueue; @@ -24,7 +24,7 @@ void Core::Db::DbWorker::workerThread() while( true ) { - Operation* operation = nullptr; + boost::shared_ptr< Operation > operation = nullptr; m_queue->waitAndPop( operation ); @@ -33,7 +33,5 @@ void Core::Db::DbWorker::workerThread() operation->setConnection( m_pConn ); operation->call(); - - delete operation; } } diff --git a/src/servers/Server_Common/Database/DbWorker.h b/src/servers/Server_Common/Database/DbWorker.h index be114888..679b1522 100644 --- a/src/servers/Server_Common/Database/DbWorker.h +++ b/src/servers/Server_Common/Database/DbWorker.h @@ -4,6 +4,7 @@ #include #include #include +#include namespace Core { @@ -15,11 +16,11 @@ namespace Db class DbWorker { public: - DbWorker( LockedWaitQueue< Operation* >* newQueue, DbConnection* connection ); + DbWorker( LockedWaitQueue< boost::shared_ptr< Operation > >* newQueue, DbConnection* connection ); ~DbWorker(); private: - LockedWaitQueue< Operation* >* m_queue; + LockedWaitQueue< boost::shared_ptr< Operation > >* m_queue; DbConnection* m_pConn; void workerThread(); diff --git a/src/servers/Server_Common/Database/DbWorkerPool.cpp b/src/servers/Server_Common/Database/DbWorkerPool.cpp index 6f4433c2..003cb3af 100644 --- a/src/servers/Server_Common/Database/DbWorkerPool.cpp +++ b/src/servers/Server_Common/Database/DbWorkerPool.cpp @@ -5,6 +5,7 @@ #include "StatementTask.h" #include "Operation.h" #include "CharaDbConnection.h" +#include #include extern Core::Logger g_log; @@ -20,7 +21,7 @@ class PingOperation : public Core::Db::Operation template< class T > Core::Db::DbWorkerPool::DbWorkerPool() - : m_queue( new Core::LockedWaitQueue< Operation* >() ), + : m_queue( new Core::LockedWaitQueue< boost::shared_ptr< Operation > >() ), m_asyncThreads( 0 ), m_synchThreads( 0 ) { @@ -33,9 +34,9 @@ Core::Db::DbWorkerPool< T >::~DbWorkerPool() } template< class T > -void Core::Db::DbWorkerPool::setConnectionInfo( const ConnectionInfo& info, - uint8_t asyncThreads, - uint8_t synchThreads) +void Core::Db::DbWorkerPool< T >::setConnectionInfo( const ConnectionInfo& info, + uint8_t asyncThreads, + uint8_t synchThreads) { m_connectionInfo = info; m_asyncThreads = asyncThreads; @@ -96,31 +97,31 @@ bool Core::Db::DbWorkerPool::prepareStatements() } template< class T > -Mysql::ResultSet* Core::Db::DbWorkerPool::query( const std::string& sql, T* connection ) +boost::shared_ptr< Mysql::ResultSet > Core::Db::DbWorkerPool< T >::query( const std::string& sql, boost::shared_ptr< T > connection ) { if( !connection ) connection = getFreeConnection(); - Mysql::ResultSet* result = connection->query( sql ); + boost::shared_ptr< Mysql::ResultSet > result = connection->query( sql ); connection->unlock(); return result; } template< class T > -Mysql::PreparedResultSet* Core::Db::DbWorkerPool::query( PreparedStatement* stmt ) +boost::shared_ptr< Mysql::PreparedResultSet > Core::Db::DbWorkerPool< T >::query( boost::shared_ptr< PreparedStatement > stmt ) { auto connection = getFreeConnection(); - auto ret = dynamic_cast< Mysql::PreparedResultSet* >( connection->query( stmt ) ); + auto ret = boost::static_pointer_cast< Mysql::PreparedResultSet >( connection->query( stmt ) ); connection->unlock(); return ret; } template< class T > -Core::Db::PreparedStatement* Core::Db::DbWorkerPool< T >::getPreparedStatement( PreparedStatementIndex index ) +boost::shared_ptr< Core::Db::PreparedStatement > Core::Db::DbWorkerPool< T >::getPreparedStatement( PreparedStatementIndex index ) { - return new PreparedStatement( index ); + return boost::make_shared< PreparedStatement >( index ); } template< class T > @@ -149,7 +150,7 @@ void Core::Db::DbWorkerPool< T >::keepAlive() const auto count = m_connections[IDX_ASYNC].size(); for( uint8_t i = 0; i < count; ++i ) - enqueue( new PingOperation ); + enqueue( boost::make_shared< PingOperation >() ); } template< class T > @@ -162,11 +163,11 @@ uint32_t Core::Db::DbWorkerPool< T >::openConnections( InternalIndex type, uint8 switch (type) { case IDX_ASYNC: - return std::unique_ptr( new T( m_queue.get(), m_connectionInfo ) ); + return boost::make_shared< T >( m_queue.get(), m_connectionInfo ); case IDX_SYNCH: - return std::unique_ptr( new T( m_connectionInfo ) ); + return boost::make_shared< T >( m_connectionInfo ); default: - return std::unique_ptr(); + return boost::shared_ptr< T >( nullptr ); } }(); @@ -176,10 +177,7 @@ uint32_t Core::Db::DbWorkerPool< T >::openConnections( InternalIndex type, uint8 m_connections[type].clear(); return error; } - else - { - m_connections[type].push_back( std::move( connection ) ); - } + m_connections[type].push_back( connection ); } return 0; @@ -188,29 +186,29 @@ uint32_t Core::Db::DbWorkerPool< T >::openConnections( InternalIndex type, uint8 template< class T > unsigned long Core::Db::DbWorkerPool< T >::escapeString( char *to, const char *from, unsigned long length ) { - if (!to || !from || !length) + if( !to || !from || !length ) return 0; return mysql_real_escape_string( - m_connections[IDX_SYNCH].front()->getConnection()->getRawCon(), to, from, length); + m_connections[IDX_SYNCH].front()->getConnection()->getRawCon(), to, from, length ); } template< class T > -void Core::Db::DbWorkerPool< T >::enqueue( Operation* op ) +void Core::Db::DbWorkerPool< T >::enqueue( boost::shared_ptr< Operation > op ) { m_queue->push( op ); } template< class T > -T* Core::Db::DbWorkerPool< T >::getFreeConnection() +boost::shared_ptr< T > Core::Db::DbWorkerPool< T >::getFreeConnection() { uint8_t i = 0; const auto numCons = m_connections[IDX_SYNCH].size(); - T* connection = nullptr; + boost::shared_ptr< T > connection = nullptr; while( true ) { - connection = m_connections[IDX_SYNCH][i++ % numCons].get(); + connection = m_connections[IDX_SYNCH][i++ % numCons]; if (connection->lockIfReady()) break; @@ -228,34 +226,31 @@ const std::string& Core::Db::DbWorkerPool< T >::getDatabaseName() const template< class T > void Core::Db::DbWorkerPool< T >::execute( const std::string& sql ) { - StatementTask* task = new StatementTask( sql ); + auto task = boost::make_shared< StatementTask >( sql ); enqueue( task ); } template< class T > -void Core::Db::DbWorkerPool< T >::execute( PreparedStatement* stmt ) +void Core::Db::DbWorkerPool< T >::execute( boost::shared_ptr< PreparedStatement > stmt ) { - PreparedStatementTask* task = new PreparedStatementTask(stmt); + auto task = boost::make_shared< PreparedStatementTask >( stmt ); enqueue( task ); } template< class T > void Core::Db::DbWorkerPool< T >::directExecute( const std::string& sql ) { - T* connection = getFreeConnection(); + auto connection = getFreeConnection(); connection->execute( sql ); connection->unlock(); } template< class T > -void Core::Db::DbWorkerPool< T >::directExecute( PreparedStatement* stmt ) +void Core::Db::DbWorkerPool< T >::directExecute( boost::shared_ptr< PreparedStatement > stmt ) { - T* connection = getFreeConnection(); + auto connection = getFreeConnection(); connection->execute( stmt ); connection->unlock(); - - //! Delete proxy-class. Not needed anymore - delete stmt; } /* @@ -278,7 +273,4 @@ void DatabaseWorkerPool::ExecuteOrAppend(SQLTransaction& trans, PreparedState } */ -template class Core::Db::DbWorkerPool< Core::Db::CharaDbConnection >; -//template class TC_DATABASE_API DatabaseWorkerPool; -//template class TC_DATABASE_API DatabaseWorkerPool; -//template class TC_DATABASE_API DatabaseWorkerPool; +template class Core::Db::DbWorkerPool< Core::Db::CharaDbConnection >; \ No newline at end of file diff --git a/src/servers/Server_Common/Database/DbWorkerPool.h b/src/servers/Server_Common/Database/DbWorkerPool.h index 9f31b9d5..63a6754a 100644 --- a/src/servers/Server_Common/Database/DbWorkerPool.h +++ b/src/servers/Server_Common/Database/DbWorkerPool.h @@ -49,17 +49,17 @@ public: // Async execution void execute( const std::string& sql ); - void execute( PreparedStatement* stmt ); + void execute( boost::shared_ptr< PreparedStatement > stmt ); // Sync execution void directExecute( const std::string& sql ); - void directExecute( PreparedStatement* stmt ); - Mysql::ResultSet* query( const std::string& sql, T* connection = nullptr ); - Mysql::PreparedResultSet* query( PreparedStatement* stmt ); + void directExecute( boost::shared_ptr< PreparedStatement > stmt ); + boost::shared_ptr< Mysql::ResultSet > query( const std::string& sql, boost::shared_ptr< T > connection = nullptr ); + boost::shared_ptr< Mysql::PreparedResultSet > query( boost::shared_ptr< PreparedStatement > stmt ); typedef typename T::Statements PreparedStatementIndex; - PreparedStatement* getPreparedStatement( PreparedStatementIndex index ); + boost::shared_ptr< PreparedStatement > getPreparedStatement( PreparedStatementIndex index ); void escapeString( std::string& str ); @@ -70,14 +70,14 @@ private: unsigned long escapeString( char *to, const char *from, unsigned long length ); - void enqueue( Operation* op ); + void enqueue( boost::shared_ptr< Operation > op ); - T* getFreeConnection(); + boost::shared_ptr< T > getFreeConnection(); const std::string& getDatabaseName() const; - std::unique_ptr< Core::LockedWaitQueue< Operation* > > m_queue; - std::array< std::vector< std::unique_ptr< T > >, IDX_SIZE > m_connections; + std::unique_ptr< Core::LockedWaitQueue< boost::shared_ptr< Operation > > > m_queue; + std::array< std::vector< boost::shared_ptr< T > >, IDX_SIZE > m_connections; ConnectionInfo m_connectionInfo; uint8_t m_asyncThreads; uint8_t m_synchThreads; diff --git a/src/servers/Server_Common/Database/PreparedStatement.cpp b/src/servers/Server_Common/Database/PreparedStatement.cpp index 463137c3..84b9960c 100644 --- a/src/servers/Server_Common/Database/PreparedStatement.cpp +++ b/src/servers/Server_Common/Database/PreparedStatement.cpp @@ -44,10 +44,12 @@ void Core::Db::PreparedStatement::bindParameters() break; case TYPE_BINARY: { - std::stringstream is; - is.rdbuf()->pubsetbuf( reinterpret_cast< char* >( &m_statementData[i].binary[0] ), - m_statementData[i].binary.size() ); - m_stmt->setBlob( i, &is ); + std::stringstream *is = new std::stringstream; + + for( auto entry : m_statementData[i].binary ) + is->rdbuf()->sputc( static_cast< char > ( entry ) ); + + m_stmt->setBlob( i, is ); } break; case TYPE_NULL: @@ -97,7 +99,7 @@ void Core::Db::PreparedStatement::setInt( uint8_t index, int32_t value ) void Core::Db::PreparedStatement::setInt64( uint8_t index, int64_t value ) { if( index >= m_statementData.size() ) - m_statementData.resize(index+1); + m_statementData.resize( index + 1); m_statementData[index].data.i64 = value; m_statementData[index].type = TYPE_I64; @@ -144,7 +146,7 @@ uint32_t Core::Db::PreparedStatement::getIndex() const return m_index; } -void Core::Db::PreparedStatement::setMysqlPS( Mysql::PreparedStatement* pStmt ) +void Core::Db::PreparedStatement::setMysqlPS( boost::shared_ptr< Mysql::PreparedStatement> pStmt ) { m_stmt = pStmt; } diff --git a/src/servers/Server_Common/Database/PreparedStatement.h b/src/servers/Server_Common/Database/PreparedStatement.h index 30d5ed6f..fbf04de2 100644 --- a/src/servers/Server_Common/Database/PreparedStatement.h +++ b/src/servers/Server_Common/Database/PreparedStatement.h @@ -3,6 +3,7 @@ #include #include #include +#include #include "Operation.h" namespace Mysql @@ -61,12 +62,12 @@ namespace Db void setNull( uint8_t index ); uint32_t getIndex() const; - void setMysqlPS( Mysql::PreparedStatement* pStmt ); + void setMysqlPS( boost::shared_ptr< Mysql::PreparedStatement > pStmt ); void bindParameters(); protected: - Mysql::PreparedStatement* m_stmt; + boost::shared_ptr< Mysql::PreparedStatement > m_stmt; uint32_t m_index; std::vector< PreparedStatementData > m_statementData; diff --git a/src/servers/Server_Common/Database/StatementTask.cpp b/src/servers/Server_Common/Database/StatementTask.cpp index de26c70f..9422f164 100644 --- a/src/servers/Server_Common/Database/StatementTask.cpp +++ b/src/servers/Server_Common/Database/StatementTask.cpp @@ -39,7 +39,7 @@ bool Core::Db::StatementTask::execute() -Core::Db::PreparedStatementTask::PreparedStatementTask( Core::Db::PreparedStatement *stmt, bool async ) : +Core::Db::PreparedStatementTask::PreparedStatementTask( boost::shared_ptr< Core::Db::PreparedStatement > stmt, bool async ) : m_stmt(stmt) //, m_result(nullptr) { @@ -48,7 +48,6 @@ Core::Db::PreparedStatementTask::PreparedStatementTask( Core::Db::PreparedStatem Core::Db::PreparedStatementTask::~PreparedStatementTask() { - delete m_stmt; //if (m_has_result && m_result != nullptr) // delete m_result; } diff --git a/src/servers/Server_Common/Database/StatementTask.h b/src/servers/Server_Common/Database/StatementTask.h index cac96905..377c7bc6 100644 --- a/src/servers/Server_Common/Database/StatementTask.h +++ b/src/servers/Server_Common/Database/StatementTask.h @@ -2,6 +2,7 @@ #define SAPPHIRE_STATEMENTTASK_H #include +#include #include "Operation.h" namespace Core @@ -31,18 +32,17 @@ namespace Db // QueryResultPromise *m_result; }; - //- Lower-level class, enqueuable operation class PreparedStatementTask : public Operation { public: - PreparedStatementTask( PreparedStatement* stmt, bool async = false); + PreparedStatementTask( boost::shared_ptr< PreparedStatement > stmt, bool async = false); ~PreparedStatementTask(); bool execute() override; //PreparedQueryResultFuture getFuture() { return m_result->get_future(); } protected: - PreparedStatement* m_stmt; + boost::shared_ptr< PreparedStatement > m_stmt; bool m_hasResult; //PreparedQueryResultPromise* m_result; }; diff --git a/src/servers/Server_REST/PlayerMinimal.cpp b/src/servers/Server_REST/PlayerMinimal.cpp index 9643a35b..9b0fb58f 100644 --- a/src/servers/Server_REST/PlayerMinimal.cpp +++ b/src/servers/Server_REST/PlayerMinimal.cpp @@ -1,13 +1,19 @@ #include "PlayerMinimal.h" -//#include "Core/Server_Game/CServerGame.h" -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "src/libraries/sapphire/mysqlConnector/MySqlConnector.h" extern Core::Db::Database g_database; +extern Core::Db::DbWorkerPool< Core::Db::CharaDbConnection > g_charaDb; extern Core::Data::ExdData g_exdData; namespace Core { @@ -15,7 +21,7 @@ namespace Core { using namespace Common; // player constructor - PlayerMinimal::PlayerMinimal( void ) : m_iD( 0 ) + PlayerMinimal::PlayerMinimal( void ) : m_id( 0 ) { @@ -32,46 +38,37 @@ namespace Core { void PlayerMinimal::load( uint32_t charId ) { - boost::shared_ptr pQR = g_database.query( "SELECT c.Name, " - " c.Customize, " - " cpc.BirthDay, " - " cpc.BirthMonth, " - " cpc.GuardianDeity, " - " cpc.Class, " - " c.ModelEquip, " - " c.ContentId, " - " c.PrimaryTerritoryId " - " FROM charabase AS c " - " INNER JOIN charadetail AS cpc " - " ON cpc.CharacterId = c.CharacterId " - " WHERE c.CharacterId = " + std::to_string( charId ) + ";" ); - if( !pQR ) - { + Core::Db::PreparedStmtScopedPtr stmt( g_charaDb.getPreparedStatement( + Core::Db::CharaDbStatements::CHAR_SEL_LOAD_MINIMAL ) ); + + stmt->setUInt( 1, charId ); + Mysql::PreparedResultSetScopedPtr res( g_charaDb.query( stmt.get() ) ); + + if( !res->next() ) return; - } - m_iD = charId; - - Db::Field *field = pQR->fetch(); + m_id = charId; memset( m_name, 0, 32 ); - strcpy( m_name, field[0].getString().c_str() ); - - field[1].getBinary( (char*)m_look, 26 ); - - field[6].getBinary( (char*)m_modelEquip, 40 ); + strcpy( m_name, res->getString( "Name" ).c_str() ); + auto customize = res->getBlobVector( "Customize" ); + memcpy( (char*)m_look, customize.data(), customize.size() ); for( int32_t i = 0; i < 26; i++ ) { m_lookMap[i] = m_look[i]; } - setBirthDay( field[2].get< int8_t >(), field[3].get< int8_t >() ); - m_guardianDeity = field[4].get< int8_t >(); - m_class = field[5].get< int8_t >(); - m_contentId = field[7].getUInt64(); - m_zoneId = field[8].get< uint16_t >(); + auto modelEquip = res->getBlobVector( "ModelEquip" ); + memcpy( (char*)m_modelEquip, modelEquip.data(), modelEquip.size() ); + + + setBirthDay( res->getUInt8( "BirthDay" ), res->getUInt8( "BirthMonth" ) ); + m_guardianDeity = res->getUInt8( "GuardianDeity" ); + m_class = res->getUInt8( "Class" ); + m_contentId = res->getUInt64( "ContentId" ); + m_zoneId = res->getUInt8( "TerritoryId" ); auto pQR2 = g_database.query( "SELECT * FROM characlass WHERE CharacterId = " + std::to_string( charId ) + ";" ); @@ -159,23 +156,17 @@ namespace Core { void PlayerMinimal::saveAsNew() { - char customize[32]; - char howTo[32]; - memset( howTo, 0, 32 ); + std::vector< uint8_t > customize( 32 ); + std::vector< uint8_t > howTo( 32 ); + std::vector< uint8_t > aetherytes( 12 ); + std::vector< uint8_t > discovery( 411 ); + std::vector< uint8_t > questComplete( 200 ); + std::vector< uint8_t > unlocks( 64 ); + std::vector< uint8_t > modelEquip( 40 ); + std::vector< uint8_t > questTracking8(10); + std::vector< int16_t > questTracking = { -1, -1, -1, -1, -1 }; - char aetherytes[12]; - memset( aetherytes, 0, 12 ); - - char discovery[411]; - memset( discovery, 0, 411 ); - - char questComplete[200]; - memset( questComplete, 0, 200 ); - - char unlocks[64]; - memset( unlocks, 0, 64 ); - - int16_t questTracking[5] = { -1, -1, -1, -1, -1 }; + memcpy( questTracking8.data(), questTracking.data(), questTracking8.size() ); uint16_t size = static_cast< uint16_t >( m_lookMap.size() ); @@ -186,6 +177,7 @@ namespace Core { uint32_t equipModel[10]; memset( equipModel, 0, 40 ); + memcpy( modelEquip.data(), equipModel, modelEquip.size() ); uint32_t startZone; float x, y, z, o; @@ -226,133 +218,114 @@ namespace Core { break; } - g_database.execute( "INSERT INTO charabase " - "(Hp, " - " Mp, " - " CharacterId, " - " ContentId, " - " Customize, " - " Name, " - " Voice, " - " FirstLogin, " - " IsNewGame, " - " PrimaryTerritoryId, " - " Pos_0_0, " - " Pos_0_1, " - " Pos_0_2, " - " Pos_0_3, " - " AccountId, " - " ModelEquip, " - " IsNewAdventurer, " - " UPDATE_DATE ) " - " VALUES (100, 100, " + std::to_string( m_iD ) + ", " + std::to_string( m_contentId ) + ", " + - " UNHEX('" + std::string( Util::binaryToHexString( (uint8_t*)customize, size ) ) + "'), " + - "'" + g_database.escapeString( std::string( m_name ) ) + "', " + std::to_string( m_voice ) + ", 1, 1, " + - std::to_string( startZone ) + ", " + std::to_string( x ) + ", " + - std::to_string( y ) + ", " + std::to_string( z ) + ", " + std::to_string( o ) + ", " + - std::to_string( m_accountId ) + ", UNHEX('" + std::string( Util::binaryToHexString( (uint8_t*)equipModel, 40 ) ) + "'), 1, NOW());" ); + // "(AccountId, CharacterId, ContentId, Name, Hp, Mp, " + // "Customize, Voice, IsNewGame, TerritoryId, PosX, PosY, PosZ, PosR, ModelEquip, " + // "IsNewAdventurer, GuardianDeity, Birthday, BirthMonth, Class, Status, FirstClass, " + // "HomePoint, StartTown, Discovery, HowTo, QuestCompleteFlags, Unlocks, QuestTracking, " + // "Aetheryte, GMRank, UPDATE_DATE ) - g_database.execute( "INSERT INTO charadetail " - "(CharacterId, " - " GuardianDeity, " - " Birthday, " - " BirthMonth, " - " Class, " - " CreateUnixTime, " - " IsActive, " - " Status, " - " FirstClass, " - " HomePoint, " - " StartTown, " - " Discovery, " - " HowTo, " - " QuestCompleteFlags, " - " unlocks, " - " QuestTracking, " - " Aetheryte, " - " GMRank, " - " UPDATE_DATE ) " - " VALUES (" + std::to_string( m_iD ) + ", " - + std::to_string( m_guardianDeity ) + ", " - + std::to_string( m_birthDay ) + ", " - + std::to_string( m_birthMonth ) + ", " - + std::to_string( m_class ) + ", UNIX_TIMESTAMP(NOW()), 1, 1, " - + std::to_string( m_class ) + ", 2, " - + std::to_string( startTown ) + ", " - + "UNHEX('" + std::string( Util::binaryToHexString( (uint8_t*)discovery, 411 ) ) + "'), " - + "UNHEX('" + std::string( Util::binaryToHexString( (uint8_t*)howTo, 32 ) ) + "'), " - + "UNHEX('" + std::string( Util::binaryToHexString( (uint8_t*)questComplete, 200 ) ) + "'), " - + "UNHEX('" + std::string( Util::binaryToHexString( (uint8_t*)unlocks, 64 ) ) + "'), " - + "UNHEX('" + std::string( Util::binaryToHexString( (uint8_t*)questTracking, 10 ) ) + "'), " - + "UNHEX('" + std::string( Util::binaryToHexString( (uint8_t*)aetherytes, 12 ) ) + "')," - + std::to_string( m_gmRank ) + ", NOW());" ); + Core::Db::PreparedStatement* stmt( g_charaDb.getPreparedStatement( + Core::Db::CharaDbStatements::CHAR_INS_CHARINFO ) ); + stmt->setInt( 1, m_accountId ); + stmt->setInt( 2, m_id ); + stmt->setInt64( 3, m_contentId ); + stmt->setString( 4, std::string( m_name ) ); + stmt->setInt( 5, 100 ); + stmt->setInt( 6, 100 ); + stmt->setBinary( 7, customize ); + stmt->setInt( 8, m_voice ); + stmt->setInt( 9, 1 ); + stmt->setInt( 10, startZone ); + stmt->setDouble( 11, x ); + stmt->setDouble( 12, y ); + stmt->setDouble( 13, z ); + stmt->setDouble( 14, o ); + stmt->setBinary( 15, modelEquip ); + stmt->setInt( 16, 1 ); + stmt->setInt( 17, m_guardianDeity ); + stmt->setInt( 18, m_birthDay ); + stmt->setInt( 19, m_birthMonth ); + stmt->setInt( 20, m_class ); + stmt->setInt( 21, 1 ); + stmt->setInt( 22, m_class ); + stmt->setInt( 23, 2 ); + stmt->setInt( 24, startTown ); + stmt->setBinary( 25, discovery ); + stmt->setBinary( 26, howTo ); + stmt->setBinary( 27, questComplete ); + stmt->setBinary( 28, unlocks ); + stmt->setBinary( 29, questTracking8 ); + stmt->setBinary( 30, aetherytes ); + stmt->setInt( 31, m_gmRank ); + + g_charaDb.directExecute( stmt ); g_database.execute( "INSERT INTO characlass (CharacterId, Lv_" + std::to_string( g_exdData.m_classJobInfoMap[m_class].exp_idx ) + ", UPDATE_DATE ) " - " VALUES (" + std::to_string( m_iD ) + ", 1, NOW());" ); + " VALUES (" + std::to_string( m_id ) + ", 1, NOW());" ); g_database.execute( "INSERT INTO charaquest (CharacterId, UPDATE_DATE ) " - " VALUES (" + std::to_string( m_iD ) + ", NOW());" ); + " VALUES (" + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charainfosearch (CharacterId, UPDATE_DATE ) " - " VALUES (" + std::to_string( m_iD ) + ", NOW());" ); + " VALUES (" + std::to_string( m_id ) + ", NOW());" ); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // SET UP INVENTORIES g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::Bag0 ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::Bag0 ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::Bag1 ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::Bag1 ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::Bag2 ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::Bag2 ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::Bag3 ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::Bag3 ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::ArmoryOff ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::ArmoryOff ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::ArmoryHead ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::ArmoryHead ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::ArmoryBody ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::ArmoryBody ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::ArmoryHand ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::ArmoryHand ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::ArmoryWaist ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::ArmoryWaist ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::ArmoryLegs ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::ArmoryLegs ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::ArmoryFeet ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::ArmoryFeet ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::ArmotyNeck ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::ArmotyNeck ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::ArmoryEar ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::ArmoryEar ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE )" - "VALUES ( " + std::to_string( InventoryType::ArmoryWrist ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::ArmoryWrist ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::ArmoryRing ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::ArmoryRing ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::ArmoryMain ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::ArmoryMain ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::Currency ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::Currency ) + ", " + std::to_string( m_id ) + ", NOW());" ); g_database.execute( "INSERT INTO charaiteminventory (storageId, CharacterId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::Crystal ) + ", " + std::to_string( m_iD ) + ", NOW());" ); + "VALUES ( " + std::to_string( InventoryType::Crystal ) + ", " + std::to_string( m_id ) + ", NOW());" ); /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // SETUP EQUIPMENT / STARTING GEAR @@ -390,19 +363,19 @@ namespace Core { } g_database.execute( "INSERT INTO charaglobalitem (CharacterId, ItemId, catalogId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( m_iD ) + ", " + std::to_string( uniqueId ) + ", " + + "VALUES ( " + std::to_string( m_id ) + ", " + std::to_string( uniqueId ) + ", " + std::to_string( weaponId ) + ", NOW());" ); g_database.execute( "INSERT INTO charaglobalitem (CharacterId, ItemId, catalogId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( m_iD ) + ", " + std::to_string( bodyUid ) + ", " + + "VALUES ( " + std::to_string( m_id ) + ", " + std::to_string( bodyUid ) + ", " + std::to_string( body ) + ", NOW());" ); g_database.execute( "INSERT INTO charaglobalitem (CharacterId, ItemId, catalogId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( m_iD ) + ", " + std::to_string( handsUid ) + ", " + + "VALUES ( " + std::to_string( m_id ) + ", " + std::to_string( handsUid ) + ", " + std::to_string( hands ) + ", NOW());" ); g_database.execute( "INSERT INTO charaglobalitem (CharacterId, ItemId, catalogId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( m_iD ) + ", " + std::to_string( legsUid ) + ", " + + "VALUES ( " + std::to_string( m_id ) + ", " + std::to_string( legsUid ) + ", " + std::to_string( legs ) + ", NOW());" ); g_database.execute( "INSERT INTO charaglobalitem (CharacterId, ItemId, catalogId, UPDATE_DATE ) " - "VALUES ( " + std::to_string( m_iD ) + ", " + std::to_string( feetUid ) + ", " + + "VALUES ( " + std::to_string( m_id ) + ", " + std::to_string( feetUid ) + ", " + std::to_string( feet ) + ", NOW());" ); g_database.execute( "INSERT INTO charaitemgearset (storageId, CharacterId, " "container_" + std::to_string( EquipSlot::MainHand ) + ", " @@ -411,7 +384,7 @@ namespace Core { "container_" + std::to_string( EquipSlot::Legs ) + ", " "container_" + std::to_string( EquipSlot::Feet ) + ", " "UPDATE_DATE ) " - "VALUES ( " + std::to_string( InventoryType::GearSet0 ) + ", " + std::to_string( m_iD ) + ", " + + "VALUES ( " + std::to_string( InventoryType::GearSet0 ) + ", " + std::to_string( m_id ) + ", " + std::to_string( uniqueId ) + ", " + std::to_string( bodyUid ) + ", " + std::to_string( handsUid ) + ", " + diff --git a/src/servers/Server_REST/PlayerMinimal.h b/src/servers/Server_REST/PlayerMinimal.h index 26b3b753..62e6c84a 100644 --- a/src/servers/Server_REST/PlayerMinimal.h +++ b/src/servers/Server_REST/PlayerMinimal.h @@ -32,12 +32,12 @@ namespace Core { // return the id of the actor uint32_t getId() const { - return m_iD; + return m_id; } void setId( uint32_t id ) { - m_iD = id; + m_id = id; } void setContentId( uint64_t id ) @@ -154,7 +154,7 @@ namespace Core { private: uint32_t m_accountId; - uint32_t m_iD; + uint32_t m_id; uint64_t m_contentId; uint8_t m_guardianDeity; diff --git a/src/servers/Server_REST/SapphireAPI.cpp b/src/servers/Server_REST/SapphireAPI.cpp index bf415fbb..59ccb6e8 100644 --- a/src/servers/Server_REST/SapphireAPI.cpp +++ b/src/servers/Server_REST/SapphireAPI.cpp @@ -209,7 +209,7 @@ std::vector Core::Network::SapphireAPI::getCharList( uint32 std::vector charList; - boost::shared_ptr pQR = g_database.query( "SELECT CharacterId, ContentId FROM charabase WHERE AccountId = " + std::to_string( accountId ) + ";" ); + boost::shared_ptr pQR = g_database.query( "SELECT CharacterId, ContentId FROM charainfo WHERE AccountId = " + std::to_string( accountId ) + ";" ); if( !pQR ) { @@ -236,7 +236,7 @@ std::vector Core::Network::SapphireAPI::getCharList( uint32 bool Core::Network::SapphireAPI::checkNameTaken( std::string name ) { - std::string query = "SELECT * FROM charabase WHERE Name = '" + g_database.escapeString( name ) + "';"; + std::string query = "SELECT * FROM charainfo WHERE Name = '" + g_database.escapeString( name ) + "';"; auto pQR = g_database.query( query ); @@ -250,7 +250,7 @@ uint32_t Core::Network::SapphireAPI::getNextCharId() { int32_t charId = 0; - boost::shared_ptr pQR = g_database.query( "SELECT MAX(CharacterId) FROM charabase" ); + boost::shared_ptr pQR = g_database.query( "SELECT MAX(CharacterId) FROM charainfo" ); if( !pQR ) { @@ -270,7 +270,7 @@ uint64_t Core::Network::SapphireAPI::getNextContentId() { uint64_t contentId = 0; - boost::shared_ptr pQR = g_database.query( "SELECT MAX(ContentId) FROM charabase" ); + boost::shared_ptr pQR = g_database.query( "SELECT MAX(ContentId) FROM charainfo" ); if( !pQR ) { diff --git a/src/servers/Server_REST/main.cpp b/src/servers/Server_REST/main.cpp index 419dc0a6..153bfe86 100644 --- a/src/servers/Server_REST/main.cpp +++ b/src/servers/Server_REST/main.cpp @@ -17,6 +17,12 @@ #include #include + +#include +#include +#include +#include + //Added for the default_resource example #include #include @@ -31,6 +37,7 @@ Core::Logger g_log; Core::Db::Database g_database; +Core::Db::DbWorkerPool< Core::Db::CharaDbConnection > g_charaDb; Core::Data::ExdData g_exdData; Core::Network::SapphireAPI g_sapphireAPI; @@ -140,6 +147,21 @@ bool loadSettings( int32_t argc, char* argv[] ) return false; } + Core::Db::DbLoader loader; + + Core::Db::ConnectionInfo info; + info.password = m_pConfig->getValue< std::string >( "Settings.General.Mysql.Pass", "" ); + info.host = m_pConfig->getValue< std::string >( "Settings.General.Mysql.Host", "127.0.0.1" ); + info.database = m_pConfig->getValue< std::string >( "Settings.General.Mysql.Database", "sapphire" ); + info.port = m_pConfig->getValue< uint16_t >( "Settings.General.Mysql.Port", 3306 ); + info.user = m_pConfig->getValue< std::string >( "Settings.General.Mysql.Username", "root" ); + info.syncThreads = m_pConfig->getValue< uint8_t >( "Settings.General.Mysql.SyncThreads", 2 ); + info.asyncThreads = m_pConfig->getValue< uint8_t >( "Settings.General.Mysql.AsyncThreads", 2 ); + + loader.addDb( g_charaDb, info ); + if( !loader.initDbs() ) + return false; + Core::Db::DatabaseParams params; params.bufferSize = 16384; params.connectionCount = 3; diff --git a/src/servers/Server_Zone/Actor/PlayerSql.cpp b/src/servers/Server_Zone/Actor/PlayerSql.cpp index 12771408..67700039 100644 --- a/src/servers/Server_Zone/Actor/PlayerSql.cpp +++ b/src/servers/Server_Zone/Actor/PlayerSql.cpp @@ -51,11 +51,10 @@ bool Core::Entity::Player::load( uint32_t charId, Core::SessionPtr pSession ) { const std::string char_id_str = std::to_string( charId ); - Core::Db::PreparedStmtScopedPtr stmt( g_charaDb.getPreparedStatement( - Core::Db::CharaDbStatements::CHAR_SEL_LOAD ) ); + auto stmt = g_charaDb.getPreparedStatement( Core::Db::CharaDbStatements::CHAR_SEL_LOAD ); stmt->setUInt( 1, charId ); - Mysql::PreparedResultSetScopedPtr res( g_charaDb.query( stmt.get() ) ); + auto res = g_charaDb.query( stmt ); if( !res->next() ) return false; @@ -65,7 +64,7 @@ bool Core::Entity::Player::load( uint32_t charId, Core::SessionPtr pSession ) auto name = res->getString( "Name" ); strcpy( m_name, name.c_str() ); - auto zoneId = res->getUInt( "PrimaryTerritoryId" ); + auto zoneId = res->getUInt( "TerritoryId" ); ZonePtr pCurrZone = g_zoneMgr.getZone( zoneId ); m_zoneId = zoneId; @@ -91,10 +90,10 @@ bool Core::Entity::Player::load( uint32_t charId, Core::SessionPtr pSession ) m_mp = res->getUInt( "Mp" ); m_tp = 0; - m_pos.x = res->getFloat( "Pos_0_0" ); - m_pos.y = res->getFloat( "Pos_0_1" ); - m_pos.z = res->getFloat( "Pos_0_2" ); - setRotation( res->getFloat( "Pos_0_3" ) ); + m_pos.x = res->getFloat( "PosX" ); + m_pos.y = res->getFloat( "PosY" ); + m_pos.z = res->getFloat( "PosZ" ); + setRotation( res->getFloat( "PosR" ) ); auto custom = res->getBlobVector( "Customize" ); memcpy( reinterpret_cast< char* >( m_customize ), custom.data(), custom.size() ); @@ -129,7 +128,7 @@ bool Core::Entity::Player::load( uint32_t charId, Core::SessionPtr pSession ) auto aetheryte = res->getBlobVector( "Aetheryte" ); memcpy( reinterpret_cast< char* >( m_aetheryte ), aetheryte.data(), aetheryte.size() ); - auto unlocks = res->getBlobVector( "unlocks" ); + auto unlocks = res->getBlobVector( "Unlocks" ); memcpy( reinterpret_cast< char* >( m_unlocks ), unlocks.data(), unlocks.size() ); auto discovery = res->getBlobVector( "Discovery" ); @@ -208,11 +207,10 @@ bool Core::Entity::Player::load( uint32_t charId, Core::SessionPtr pSession ) bool Core::Entity::Player::loadActiveQuests() { - Core::Db::PreparedStmtScopedPtr stmt( g_charaDb.getPreparedStatement( - Core::Db::CharaDbStatements::CHAR_SEL_LOAD_QUESTINFO ) ); + auto stmt = g_charaDb.getPreparedStatement( Core::Db::CharaDbStatements::CHAR_SEL_LOAD_QUESTINFO ); stmt->setUInt( 1, m_id ); - Mysql::PreparedResultSetScopedPtr res( g_charaDb.query( stmt.get() ) ); + auto res = g_charaDb.query( stmt ); if( !res->next() ) return false; @@ -264,10 +262,9 @@ bool Core::Entity::Player::loadActiveQuests() bool Core::Entity::Player::loadClassData() { - Core::Db::PreparedStmtScopedPtr stmt( g_charaDb.getPreparedStatement( - Core::Db::CharaDbStatements::CHAR_SEL_LOAD_CLASSINFO ) ); + auto stmt = g_charaDb.getPreparedStatement( Core::Db::CharaDbStatements::CHAR_SEL_LOAD_CLASSINFO ); stmt->setUInt( 1, m_id ); - Mysql::PreparedResultSetScopedPtr res( g_charaDb.query( stmt.get() ) ); + auto res = g_charaDb.query( stmt ); if( !res->next() ) return false; @@ -284,10 +281,9 @@ bool Core::Entity::Player::loadClassData() bool Core::Entity::Player::loadSearchInfo() { - Core::Db::PreparedStmtScopedPtr stmt( g_charaDb.getPreparedStatement( - Core::Db::CharaDbStatements::CHAR_SEL_LOAD_SEARCHINFO ) ); + auto stmt = g_charaDb.getPreparedStatement( Core::Db::CharaDbStatements::CHAR_SEL_LOAD_SEARCHINFO ); stmt->setUInt( 1, m_id ); - Mysql::PreparedResultSetScopedPtr res( g_charaDb.query( stmt.get() ) ); + auto res = g_charaDb.query( stmt ); if( !res->next() ) return false; diff --git a/src/servers/Server_Zone/ServerZone.cpp b/src/servers/Server_Zone/ServerZone.cpp index 373ead00..a90f76f8 100644 --- a/src/servers/Server_Zone/ServerZone.cpp +++ b/src/servers/Server_Zone/ServerZone.cpp @@ -194,7 +194,7 @@ bool Core::ServerZone::loadSettings( int32_t argc, char* argv[] ) g_charaDb.execute( "DELETE FROM zoneservers WHERE id = 101" ); // query runs synchronous - boost::scoped_ptr< Mysql::ResultSet > res( g_charaDb.query( "SELECT id,ip,port FROM zoneservers" ) ); + auto res = g_charaDb.query( "SELECT id,ip,port FROM zoneservers" ); while( res->next() ) { g_log.info( "id: " + std::to_string( res->getUInt( "id" ) ) ); @@ -215,13 +215,13 @@ bool Core::ServerZone::loadSettings( int32_t argc, char* argv[] ) try { // // bunch of test cases for db wrapper - Mysql::MySqlBase base; - g_log.info( base.getVersionInfo() ); + boost::shared_ptr< Mysql::MySqlBase > base( new Mysql::MySqlBase() ); + g_log.info( base->getVersionInfo() ); Mysql::optionMap options; options[ MYSQL_OPT_RECONNECT ] = "1"; - boost::scoped_ptr< Mysql::Connection > con( base.connect( "127.0.0.1", "root", "", options, 3306 ) ); + auto con = base->connect( "127.0.0.1", "root", "", options, 3306 ); // if( con->getAutoCommit() ) // g_log.info( "autocommit active" );