Core/DBLayer: Prevent using prepared statements on wrong database

(cherry picked from commit e8e89f58fb800014f53341f12505f60ee2b5fb6f)

# Conflicts:
#	src/server/bnetserver/REST/LoginRESTService.cpp
#	src/server/bnetserver/Server/Session.cpp
#	src/server/database/Database/DatabaseWorkerPool.cpp
#	src/server/database/Database/Implementation/HotfixDatabase.h
#	src/server/database/Database/MySQLConnection.cpp
#	src/server/database/Database/MySQLConnection.h
#	src/server/database/Database/PreparedStatement.cpp
#	src/server/database/Database/PreparedStatement.h
#	src/server/database/Database/QueryHolder.cpp
#	src/server/database/Database/SQLOperation.h
#	src/server/database/Database/Transaction.h
#	src/server/game/Accounts/BattlenetAccountMgr.cpp
#	src/server/game/Achievements/AchievementMgr.cpp
#	src/server/game/AuctionHouse/AuctionHouseMgr.cpp
#	src/server/game/AuctionHouseBot/AuctionHouseBot.cpp
#	src/server/game/AuctionHouseBot/AuctionHouseBotBuyer.cpp
#	src/server/game/BattlePets/BattlePetMgr.cpp
#	src/server/game/Battlegrounds/ArenaTeam.cpp
#	src/server/game/BlackMarket/BlackMarketMgr.cpp
#	src/server/game/Chat/Channels/Channel.cpp
#	src/server/game/Entities/Corpse/Corpse.cpp
#	src/server/game/Entities/Creature/Creature.cpp
#	src/server/game/Entities/GameObject/GameObject.cpp
#	src/server/game/Entities/Item/Item.cpp
#	src/server/game/Entities/Pet/Pet.cpp
#	src/server/game/Entities/Player/CollectionMgr.cpp
#	src/server/game/Entities/Player/Player.cpp
#	src/server/game/Garrison/Garrison.cpp
#	src/server/game/Globals/ObjectMgr.cpp
#	src/server/game/Groups/Group.cpp
#	src/server/game/Guilds/Guild.cpp
#	src/server/game/Guilds/GuildFinderMgr.cpp
#	src/server/game/Guilds/GuildMgr.cpp
#	src/server/game/Handlers/AuctionHouseHandler.cpp
#	src/server/game/Handlers/CharacterHandler.cpp
#	src/server/game/Handlers/ItemHandler.cpp
#	src/server/game/Handlers/MailHandler.cpp
#	src/server/game/Handlers/MiscHandler.cpp
#	src/server/game/Handlers/PetitionsHandler.cpp
#	src/server/game/Handlers/SpellHandler.cpp
#	src/server/game/Handlers/TicketHandler.cpp
#	src/server/game/Loot/Loot.cpp
#	src/server/game/Mails/Mail.cpp
#	src/server/game/Maps/Map.cpp
#	src/server/game/Movement/Waypoints/WaypointManager.cpp
#	src/server/game/OutdoorPvP/OutdoorPvP.cpp
#	src/server/game/Pools/PoolMgr.cpp
#	src/server/game/Quests/QuestObjectiveCriteriaMgr.cpp
#	src/server/game/Reputation/ReputationMgr.cpp
#	src/server/game/Scenarios/InstanceScenario.cpp
#	src/server/game/Server/WorldSession.cpp
#	src/server/game/Server/WorldSocket.cpp
#	src/server/game/Spells/SpellHistory.cpp
#	src/server/game/Support/SupportMgr.cpp
#	src/server/game/Tools/PlayerDump.cpp
#	src/server/game/World/World.cpp
#	src/server/scripts/Commands/cs_account.cpp
#	src/server/scripts/Commands/cs_ban.cpp
#	src/server/scripts/Commands/cs_battlenet_account.cpp
#	src/server/scripts/Commands/cs_group.cpp
#	src/server/scripts/Commands/cs_lfg.cpp
#	src/server/scripts/Commands/cs_list.cpp
#	src/server/scripts/Commands/cs_message.cpp
#	src/server/scripts/Commands/cs_misc.cpp
#	src/server/scripts/Commands/cs_npc.cpp
#	src/server/scripts/Commands/cs_tele.cpp
#	src/server/scripts/Commands/cs_wp.cpp
#	src/server/shared/DataStores/DB2DatabaseLoader.cpp
#	src/server/shared/Realm/RealmList.cpp

18 files changed, 80 insertions, 58 deletions

diff --git a/src/server/database/Database/DatabaseEnvFwd.h b/src/server/database/Database/DatabaseEnvFwd.h
index 9223e6117e5..1fe95c54a5c 100644
--- a/src/server/database/Database/DatabaseEnvFwd.h
+++ b/src/server/database/Database/DatabaseEnvFwd.h
@@ -28,6 +28,9 @@ typedef std::shared_ptr<ResultSet> QueryResult;
 typedef std::future<QueryResult> QueryResultFuture;
 typedef std::promise<QueryResult> QueryResultPromise;
 
+class PreparedStatementBase;
+
+template<typename T>
 class PreparedStatement;
 
 class PreparedResultSet;
diff --git a/src/server/database/Database/DatabaseWorkerPool.cpp b/src/server/database/Database/DatabaseWorkerPool.cpp
index 83d2adaede7..da30c84a753 100644
--- a/src/server/database/Database/DatabaseWorkerPool.cpp
+++ b/src/server/database/Database/DatabaseWorkerPool.cpp
@@ -183,7 +183,7 @@ QueryResult DatabaseWorkerPool<T>::Query(char const* sql, T* connection /*= null
 }
 
 template <class T>
-PreparedQueryResult DatabaseWorkerPool<T>::Query(PreparedStatement* stmt)
+PreparedQueryResult DatabaseWorkerPool<T>::Query(PreparedStatement<T>* stmt)
 {
     auto connection = GetFreeConnection();
     PreparedResultSet* ret = connection->Query(stmt);
@@ -212,7 +212,7 @@ QueryCallback DatabaseWorkerPool<T>::AsyncQuery(char const* sql)
 }
 
 template <class T>
-QueryCallback DatabaseWorkerPool<T>::AsyncQuery(PreparedStatement* stmt)
+QueryCallback DatabaseWorkerPool<T>::AsyncQuery(PreparedStatement<T>* stmt)
 {
     PreparedStatementTask* task = new PreparedStatementTask(stmt, true);
     // Store future result before enqueueing - task might get already processed and deleted before returning from this method
@@ -291,9 +291,9 @@ void DatabaseWorkerPool<T>::DirectCommitTransaction(SQLTransaction& transaction)
 }
 
 template <class T>
-PreparedStatement* DatabaseWorkerPool<T>::GetPreparedStatement(PreparedStatementIndex index)
+PreparedStatement<T>* DatabaseWorkerPool<T>::GetPreparedStatement(PreparedStatementIndex index)
 {
-    return new PreparedStatement(index, _preparedStatementSize[index]);
+    return new PreparedStatement<T>(index, _preparedStatementSize[index]);
 }
 
 template <class T>
@@ -418,7 +418,7 @@ void DatabaseWorkerPool<T>::Execute(char const* sql)
 }
 
 template <class T>
-void DatabaseWorkerPool<T>::Execute(PreparedStatement* stmt)
+void DatabaseWorkerPool<T>::Execute(PreparedStatement<T>* stmt)
 {
     PreparedStatementTask* task = new PreparedStatementTask(stmt);
     Enqueue(task);
@@ -436,7 +436,7 @@ void DatabaseWorkerPool<T>::DirectExecute(char const* sql)
 }
 
 template <class T>
-void DatabaseWorkerPool<T>::DirectExecute(PreparedStatement* stmt)
+void DatabaseWorkerPool<T>::DirectExecute(PreparedStatement<T>* stmt)
 {
     T* connection = GetFreeConnection();
     connection->Execute(stmt);
@@ -456,7 +456,7 @@ void DatabaseWorkerPool<T>::ExecuteOrAppend(SQLTransaction& trans, char const* s
 }
 
 template <class T>
-void DatabaseWorkerPool<T>::ExecuteOrAppend(SQLTransaction& trans, PreparedStatement* stmt)
+void DatabaseWorkerPool<T>::ExecuteOrAppend(SQLTransaction& trans, PreparedStatement<T>* stmt)
 {
     if (!trans)
         Execute(stmt);
diff --git a/src/server/database/Database/DatabaseWorkerPool.h b/src/server/database/Database/DatabaseWorkerPool.h
index 35220144970..635670dce08 100644
--- a/src/server/database/Database/DatabaseWorkerPool.h
+++ b/src/server/database/Database/DatabaseWorkerPool.h
@@ -83,7 +83,7 @@ class DatabaseWorkerPool
 
         //! Enqueues a one-way SQL operation in prepared statement format that will be executed asynchronously.
         //! Statement must be prepared with CONNECTION_ASYNC flag.
-        void Execute(PreparedStatement* stmt);
+        void Execute(PreparedStatement<T>* stmt);
 
         /**
             Direct synchronous one-way statement methods.
@@ -106,7 +106,7 @@ class DatabaseWorkerPool
 
         //! 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.
-        void DirectExecute(PreparedStatement* stmt);
+        void DirectExecute(PreparedStatement<T>* stmt);
 
         /**
             Synchronous query (with resultset) methods.
@@ -141,7 +141,7 @@ class DatabaseWorkerPool
         //! 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.
-        PreparedQueryResult Query(PreparedStatement* stmt);
+        PreparedQueryResult Query(PreparedStatement<T>* stmt);
 
         /**
             Asynchronous query (with resultset) methods.
@@ -154,7 +154,7 @@ class DatabaseWorkerPool
         //! 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.
-        QueryCallback AsyncQuery(PreparedStatement* stmt);
+        QueryCallback AsyncQuery(PreparedStatement<T>* stmt);
 
         //! 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.
@@ -183,7 +183,7 @@ class DatabaseWorkerPool
 
         //! Method used to execute prepared statements in a diverse context.
         //! Will be wrapped in a transaction if valid object is present, otherwise executed standalone.
-        void ExecuteOrAppend(SQLTransaction& trans, PreparedStatement* stmt);
+        void ExecuteOrAppend(SQLTransaction& trans, PreparedStatement<T>* stmt);
 
         /**
             Other
@@ -194,7 +194,7 @@ class DatabaseWorkerPool
         //! 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.
-        PreparedStatement* GetPreparedStatement(PreparedStatementIndex index);
+        PreparedStatement<T>* GetPreparedStatement(PreparedStatementIndex index);
 
         //! Apply escape string'ing for current collation. (utf8)
         void EscapeString(std::string& str);
diff --git a/src/server/database/Database/Implementation/CharacterDatabase.h b/src/server/database/Database/Implementation/CharacterDatabase.h
index 1367971d697..bb78cdbc542 100644
--- a/src/server/database/Database/Implementation/CharacterDatabase.h
+++ b/src/server/database/Database/Implementation/CharacterDatabase.h
@@ -540,4 +540,6 @@ public:
     void DoPrepareStatements() override;
 };
 
+using CharacterDatabasePreparedStatement = PreparedStatement<CharacterDatabaseConnection>;
+
 #endif
diff --git a/src/server/database/Database/Implementation/LoginDatabase.h b/src/server/database/Database/Implementation/LoginDatabase.h
index f9a18960728..ea9b0d4a30f 100644
--- a/src/server/database/Database/Implementation/LoginDatabase.h
+++ b/src/server/database/Database/Implementation/LoginDatabase.h
@@ -137,4 +137,6 @@ public:
     void DoPrepareStatements() override;
 };
 
+using LoginDatabasePreparedStatement = PreparedStatement<LoginDatabaseConnection>;
+
 #endif
diff --git a/src/server/database/Database/Implementation/WorldDatabase.h b/src/server/database/Database/Implementation/WorldDatabase.h
index 7b009320716..d767908244a 100644
--- a/src/server/database/Database/Implementation/WorldDatabase.h
+++ b/src/server/database/Database/Implementation/WorldDatabase.h
@@ -118,4 +118,6 @@ public:
     void DoPrepareStatements() override;
 };
 
+using WorldDatabasePreparedStatement = PreparedStatement<WorldDatabaseConnection>;
+
 #endif
diff --git a/src/server/database/Database/MySQLConnection.cpp b/src/server/database/Database/MySQLConnection.cpp
index a45851bab76..06e7f703437 100644
--- a/src/server/database/Database/MySQLConnection.cpp
+++ b/src/server/database/Database/MySQLConnection.cpp
@@ -193,7 +193,7 @@ bool MySQLConnection::Execute(char const* sql)
     return true;
 }
 
-bool MySQLConnection::Execute(PreparedStatement* stmt)
+bool MySQLConnection::Execute(PreparedStatementBase* stmt)
 {
     if (!m_Mysql)
         return false;
@@ -240,7 +240,7 @@ bool MySQLConnection::Execute(PreparedStatement* stmt)
     return true;
 }
 
-bool MySQLConnection::_Query(PreparedStatement* stmt, MySQLPreparedStatement** mysqlStmt, MySQLResult** pResult, uint64* pRowCount, uint32* pFieldCount)
+bool MySQLConnection::_Query(PreparedStatementBase* stmt, MySQLPreparedStatement** mysqlStmt, MySQLResult** pResult, uint64* pRowCount, uint32* pFieldCount)
 {
     if (!m_Mysql)
         return false;
@@ -381,7 +381,7 @@ int MySQLConnection::ExecuteTransaction(SQLTransaction& transaction)
         {
             case SQL_ELEMENT_PREPARED:
             {
-                PreparedStatement* stmt = data.element.stmt;
+                PreparedStatementBase* stmt = data.element.stmt;
                 ASSERT(stmt);
                 if (!Execute(stmt))
                 {
@@ -491,7 +491,7 @@ void MySQLConnection::PrepareStatement(uint32 index, std::string const& sql, Con
     }
 }
 
-PreparedResultSet* MySQLConnection::Query(PreparedStatement* stmt)
+PreparedResultSet* MySQLConnection::Query(PreparedStatementBase* stmt)
 {
     MySQLPreparedStatement* mysqlStmt = nullptr;
     MySQLResult* result = nullptr;
diff --git a/src/server/database/Database/MySQLConnection.h b/src/server/database/Database/MySQLConnection.h
index bd4e22a2cac..411f570ba32 100644
--- a/src/server/database/Database/MySQLConnection.h
+++ b/src/server/database/Database/MySQLConnection.h
@@ -67,11 +67,11 @@ class TC_DATABASE_API MySQLConnection
         bool PrepareStatements();
 
         bool Execute(char const* sql);
-        bool Execute(PreparedStatement* stmt);
+        bool Execute(PreparedStatementBase* stmt);
         ResultSet* Query(char const* sql);
-        PreparedResultSet* Query(PreparedStatement* stmt);
+        PreparedResultSet* Query(PreparedStatementBase* stmt);
         bool _Query(char const* sql, MySQLResult** pResult, MySQLField** pFields, uint64* pRowCount, uint32* pFieldCount);
-        bool _Query(PreparedStatement* stmt, MySQLPreparedStatement** mysqlStmt, MySQLResult** pResult, uint64* pRowCount, uint32* pFieldCount);
+        bool _Query(PreparedStatementBase* stmt, MySQLPreparedStatement** mysqlStmt, MySQLResult** pResult, uint64* pRowCount, uint32* pFieldCount);
 
         void BeginTransaction();
         void RollbackTransaction();
diff --git a/src/server/database/Database/MySQLPreparedStatement.cpp b/src/server/database/Database/MySQLPreparedStatement.cpp
index 7f08b5f1ac6..41f9bcba5b1 100644
--- a/src/server/database/Database/MySQLPreparedStatement.cpp
+++ b/src/server/database/Database/MySQLPreparedStatement.cpp
@@ -61,7 +61,7 @@ MySQLPreparedStatement::~MySQLPreparedStatement()
     delete[] m_bind;
 }
 
-void MySQLPreparedStatement::BindParameters(PreparedStatement* stmt)
+void MySQLPreparedStatement::BindParameters(PreparedStatementBase* stmt)
 {
     m_stmt = stmt;     // Cross reference them for debug output
 
diff --git a/src/server/database/Database/MySQLPreparedStatement.h b/src/server/database/Database/MySQLPreparedStatement.h
index 27ce911a0ba..d03ce29c480 100644
--- a/src/server/database/Database/MySQLPreparedStatement.h
+++ b/src/server/database/Database/MySQLPreparedStatement.h
@@ -25,7 +25,7 @@
 #include <vector>
 
 class MySQLConnection;
-class PreparedStatement;
+class PreparedStatementBase;
 
 //- Class of which the instances are unique per MySQLConnection
 //- access to these class objects is only done when a prepared statement task
@@ -33,13 +33,13 @@ class PreparedStatement;
 class TC_DATABASE_API MySQLPreparedStatement
 {
     friend class MySQLConnection;
-    friend class PreparedStatement;
+    friend class PreparedStatementBase;
 
     public:
         MySQLPreparedStatement(MySQLStmt* stmt, std::string queryString);
         ~MySQLPreparedStatement();
 
-        void BindParameters(PreparedStatement* stmt);
+        void BindParameters(PreparedStatementBase* stmt);
 
         uint32 GetParameterCount() const { return m_paramCount; }
 
@@ -53,7 +53,7 @@ class TC_DATABASE_API MySQLPreparedStatement
 
         MySQLStmt* GetSTMT() { return m_Mstmt; }
         MySQLBind* GetBind() { return m_bind; }
-        PreparedStatement* m_stmt;
+        PreparedStatementBase* m_stmt;
         void ClearParameters();
         void AssertValidIndex(uint8 index);
         std::string getQueryString() const;
diff --git a/src/server/database/Database/PreparedStatement.cpp b/src/server/database/Database/PreparedStatement.cpp
index cfb4dcc3dcf..261ff1af9b7 100644
--- a/src/server/database/Database/PreparedStatement.cpp
+++ b/src/server/database/Database/PreparedStatement.cpp
@@ -23,98 +23,98 @@
 #include "Log.h"
 #include "MySQLWorkaround.h"
 
-PreparedStatement::PreparedStatement(uint32 index, uint8 capacity) :
+PreparedStatementBase::PreparedStatementBase(uint32 index, uint8 capacity) :
 m_index(index), statement_data(capacity) { }
 
-PreparedStatement::~PreparedStatement() { }
+PreparedStatementBase::~PreparedStatementBase() { }
 
 //- Bind to buffer
-void PreparedStatement::setBool(const uint8 index, const bool value)
+void PreparedStatementBase::setBool(const uint8 index, const bool value)
 {
     ASSERT(index < statement_data.size());
     statement_data[index].data = value;
 }
 
-void PreparedStatement::setUInt8(const uint8 index, const uint8 value)
+void PreparedStatementBase::setUInt8(const uint8 index, const uint8 value)
 {
     ASSERT(index < statement_data.size());
     statement_data[index].data = value;
 }
 
-void PreparedStatement::setUInt16(const uint8 index, const uint16 value)
+void PreparedStatementBase::setUInt16(const uint8 index, const uint16 value)
 {
     ASSERT(index < statement_data.size());
     statement_data[index].data = value;
 }
 
-void PreparedStatement::setUInt32(const uint8 index, const uint32 value)
+void PreparedStatementBase::setUInt32(const uint8 index, const uint32 value)
 {
     ASSERT(index < statement_data.size());
     statement_data[index].data = value;
 }
 
-void PreparedStatement::setUInt64(const uint8 index, const uint64 value)
+void PreparedStatementBase::setUInt64(const uint8 index, const uint64 value)
 {
     ASSERT(index < statement_data.size());
     statement_data[index].data = value;
 }
 
-void PreparedStatement::setInt8(const uint8 index, const int8 value)
+void PreparedStatementBase::setInt8(const uint8 index, const int8 value)
 {
     ASSERT(index < statement_data.size());
     statement_data[index].data = value;
 }
 
-void PreparedStatement::setInt16(const uint8 index, const int16 value)
+void PreparedStatementBase::setInt16(const uint8 index, const int16 value)
 {
     ASSERT(index < statement_data.size());
     statement_data[index].data = value;
 }
 
-void PreparedStatement::setInt32(const uint8 index, const int32 value)
+void PreparedStatementBase::setInt32(const uint8 index, const int32 value)
 {
     ASSERT(index < statement_data.size());
     statement_data[index].data = value;
 }
 
-void PreparedStatement::setInt64(const uint8 index, const int64 value)
+void PreparedStatementBase::setInt64(const uint8 index, const int64 value)
 {
     ASSERT(index < statement_data.size());
     statement_data[index].data = value;
 }
 
-void PreparedStatement::setFloat(const uint8 index, const float value)
+void PreparedStatementBase::setFloat(const uint8 index, const float value)
 {
     ASSERT(index < statement_data.size());
     statement_data[index].data = value;
 }
 
-void PreparedStatement::setDouble(const uint8 index, const double value)
+void PreparedStatementBase::setDouble(const uint8 index, const double value)
 {
     ASSERT(index < statement_data.size());
     statement_data[index].data = value;
 }
 
-void PreparedStatement::setString(const uint8 index, const std::string& value)
+void PreparedStatementBase::setString(const uint8 index, const std::string& value)
 {
     ASSERT(index < statement_data.size());
     statement_data[index].data = value;
 }
 
-void PreparedStatement::setBinary(const uint8 index, const std::vector<uint8>& value)
+void PreparedStatementBase::setBinary(const uint8 index, const std::vector<uint8>& value)
 {
     ASSERT(index < statement_data.size());
     statement_data[index].data = value;
 }
 
-void PreparedStatement::setNull(const uint8 index)
+void PreparedStatementBase::setNull(const uint8 index)
 {
     ASSERT(index < statement_data.size());
     statement_data[index].data = nullptr;
 }
 
 //- Execution
-PreparedStatementTask::PreparedStatementTask(PreparedStatement* stmt, bool async) :
+PreparedStatementTask::PreparedStatementTask(PreparedStatementBase* stmt, bool async) :
 m_stmt(stmt), m_result(nullptr)
 {
     m_has_result = async; // If it's async, then there's a result
diff --git a/src/server/database/Database/PreparedStatement.h b/src/server/database/Database/PreparedStatement.h
index d87bd3ba2aa..e7f39156252 100644
--- a/src/server/database/Database/PreparedStatement.h
+++ b/src/server/database/Database/PreparedStatement.h
@@ -55,13 +55,13 @@ struct PreparedStatementData
 };
 
 //- Upper-level class that is used in code
-class TC_DATABASE_API PreparedStatement
+class TC_DATABASE_API PreparedStatementBase
 {
     friend class PreparedStatementTask;
 
     public:
-        PreparedStatement(uint32 index, uint8 capacity);
-        ~PreparedStatement();
+        explicit PreparedStatementBase(uint32 index, uint8 capacity);
+        virtual ~PreparedStatementBase();
 
         void setNull(const uint8 index);
         void setBool(const uint8 index, const bool value);
@@ -87,22 +87,35 @@ class TC_DATABASE_API PreparedStatement
         //- Buffer of parameters, not tied to MySQL in any way yet
         std::vector<PreparedStatementData> statement_data;
 
-        PreparedStatement(PreparedStatement const& right) = delete;
-        PreparedStatement& operator=(PreparedStatement const& right) = delete;
+        PreparedStatementBase(PreparedStatementBase const& right) = delete;
+        PreparedStatementBase& operator=(PreparedStatementBase const& right) = delete;
+};
+
+template<typename T>
+class PreparedStatement : public PreparedStatementBase
+{
+public:
+    explicit PreparedStatement(uint32 index, uint8 capacity) : PreparedStatementBase(index, capacity)
+    {
+    }
+
+private:
+    PreparedStatement(PreparedStatement const& right) = delete;
+    PreparedStatement& operator=(PreparedStatement const& right) = delete;
 };
 
 //- Lower-level class, enqueuable operation
 class TC_DATABASE_API PreparedStatementTask : public SQLOperation
 {
     public:
-        PreparedStatementTask(PreparedStatement* stmt, bool async = false);
+        PreparedStatementTask(PreparedStatementBase* stmt, bool async = false);
         ~PreparedStatementTask();
 
         bool Execute() override;
         PreparedQueryResultFuture GetFuture() { return m_result->get_future(); }
 
     protected:
-        PreparedStatement* m_stmt;
+        PreparedStatementBase* m_stmt;
         bool m_has_result;
         PreparedQueryResultPromise* m_result;
 };
diff --git a/src/server/database/Database/QueryHolder.cpp b/src/server/database/Database/QueryHolder.cpp
index 363d3dd8d9b..e9012cc9a90 100644
--- a/src/server/database/Database/QueryHolder.cpp
+++ b/src/server/database/Database/QueryHolder.cpp
@@ -21,7 +21,7 @@
 #include "Log.h"
 #include "QueryResult.h"
 
-bool SQLQueryHolder::SetPreparedQuery(size_t index, PreparedStatement* stmt)
+bool SQLQueryHolder::SetPreparedQuery(size_t index, PreparedStatementBase* stmt)
 {
     if (m_queries.size() <= index)
     {
@@ -57,7 +57,7 @@ void SQLQueryHolder::SetPreparedResult(size_t index, PreparedResultSet* result)
 
 SQLQueryHolder::~SQLQueryHolder()
 {
-    for (std::pair<PreparedStatement*, PreparedQueryResult>& query : m_queries)
+    for (std::pair<PreparedStatementBase*, PreparedQueryResult>& query : m_queries)
     {
         /// if the result was never used, free the resources
         /// results used already (getresult called) are expected to be deleted
@@ -86,7 +86,7 @@ bool SQLQueryHolderTask::Execute()
 
     /// execute all queries in the holder and pass the results
     for (size_t i = 0; i < m_holder->m_queries.size(); ++i)
-        if (PreparedStatement* stmt = m_holder->m_queries[i].first)
+        if (PreparedStatementBase* stmt = m_holder->m_queries[i].first)
             m_holder->SetPreparedResult(i, m_conn->Query(stmt));
 
     m_result.set_value(m_holder);
diff --git a/src/server/database/Database/QueryHolder.h b/src/server/database/Database/QueryHolder.h
index 7e7ac7891a8..f7a21a97e70 100644
--- a/src/server/database/Database/QueryHolder.h
+++ b/src/server/database/Database/QueryHolder.h
@@ -24,11 +24,11 @@ class TC_DATABASE_API SQLQueryHolder
 {
     friend class SQLQueryHolderTask;
     private:
-        std::vector<std::pair<PreparedStatement*, PreparedQueryResult>> m_queries;
+        std::vector<std::pair<PreparedStatementBase*, PreparedQueryResult>> m_queries;
     public:
         SQLQueryHolder() { }
         virtual ~SQLQueryHolder();
-        bool SetPreparedQuery(size_t index, PreparedStatement* stmt);
+        bool SetPreparedQuery(size_t index, PreparedStatementBase* stmt);
         void SetSize(size_t size);
         PreparedQueryResult GetPreparedResult(size_t index);
         void SetPreparedResult(size_t index, PreparedResultSet* result);
diff --git a/src/server/database/Database/SQLOperation.h b/src/server/database/Database/SQLOperation.h
index d148704f4ce..97f1b396cea 100644
--- a/src/server/database/Database/SQLOperation.h
+++ b/src/server/database/Database/SQLOperation.h
@@ -24,7 +24,7 @@
 //- Union that holds element data
 union SQLElementUnion
 {
-    PreparedStatement* stmt;
+    PreparedStatementBase* stmt;
     char const* query;
 };
 
diff --git a/src/server/database/Database/Transaction.cpp b/src/server/database/Database/Transaction.cpp
index 6d1778e413e..867dcf1f1f0 100644
--- a/src/server/database/Database/Transaction.cpp
+++ b/src/server/database/Database/Transaction.cpp
@@ -38,7 +38,7 @@ void Transaction::Append(char const* sql)
 }
 
 //- Append a prepared statement to the transaction
-void Transaction::Append(PreparedStatement* stmt)
+void Transaction::Append(PreparedStatementBase* stmt)
 {
     SQLElementData data;
     data.type = SQL_ELEMENT_PREPARED;
diff --git a/src/server/database/Database/Transaction.h b/src/server/database/Database/Transaction.h
index 2383fbab901..0a926f1e55d 100644
--- a/src/server/database/Database/Transaction.h
+++ b/src/server/database/Database/Transaction.h
@@ -38,7 +38,7 @@ class TC_DATABASE_API Transaction
         Transaction() : _cleanedUp(false) { }
         ~Transaction() { Cleanup(); }
 
-        void Append(PreparedStatement* statement);
+        void Append(PreparedStatementBase* statement);
         void Append(char const* sql);
         template<typename Format, typename... Args>
         void PAppend(Format&& sql, Args&&... args)
diff --git a/src/server/database/Logging/AppenderDB.cpp b/src/server/database/Logging/AppenderDB.cpp
index bdea4635cb9..87910b49c30 100644
--- a/src/server/database/Logging/AppenderDB.cpp
+++ b/src/server/database/Logging/AppenderDB.cpp
@@ -31,7 +31,7 @@ void AppenderDB::_write(LogMessage const* message)
     if (!enabled || (message->type.find("sql") != std::string::npos))
         return;
 
-    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_LOG);
+    LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_LOG);
     stmt->setUInt64(0, message->mtime);
     stmt->setUInt32(1, realmId);
     stmt->setString(2, message->type);