Core/DBLayer: Prevent mixing databases with query holders

(cherry picked from commit 13440434c3)

# Conflicts:
#	src/server/game/Server/WorldSession.cpp
#	src/server/game/Server/WorldSession.h

src/server/database/Database/DatabaseEnvFwd.h

@@ -63,9 +63,17 @@ using HotfixDatabaseTransaction = SQLTransaction<HotfixDatabaseConnection>;
 using LoginDatabaseTransaction = SQLTransaction<LoginDatabaseConnection>;
 using WorldDatabaseTransaction = SQLTransaction<WorldDatabaseConnection>;
 
+class SQLQueryHolderBase;
+typedef std::future<SQLQueryHolderBase*> QueryResultHolderFuture;
+typedef std::promise<SQLQueryHolderBase*> QueryResultHolderPromise;
+
+template<typename T>
 class SQLQueryHolder;
-typedef std::future<SQLQueryHolder*> QueryResultHolderFuture;
-typedef std::promise<SQLQueryHolder*> QueryResultHolderPromise;
+
+using CharacterDatabaseQueryHolder = SQLQueryHolder<CharacterDatabaseConnection>;
+using HotfixDatabaseQueryHolder = SQLQueryHolder<HotfixDatabaseConnection>;
+using LoginDatabaseQueryHolder = SQLQueryHolder<LoginDatabaseConnection>;
+using WorldDatabaseQueryHolder = SQLQueryHolder<WorldDatabaseConnection>;
 
 // mysql
 struct MySQLHandle;

src/server/database/Database/DatabaseWorkerPool.cpp

@@ -222,7 +222,7 @@ QueryCallback DatabaseWorkerPool<T>::AsyncQuery(PreparedStatement<T>* stmt)
 }
 
 template <class T>
-QueryResultHolderFuture DatabaseWorkerPool<T>::DelayQueryHolder(SQLQueryHolder* holder)
+QueryResultHolderFuture DatabaseWorkerPool<T>::DelayQueryHolder(SQLQueryHolder<T>* holder)
 {
     SQLQueryHolderTask* task = new SQLQueryHolderTask(holder);
     // Store future result before enqueueing - task might get already processed and deleted before returning from this method

src/server/database/Database/DatabaseWorkerPool.h

@@ -160,7 +160,7 @@ class DatabaseWorkerPool
         //! 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.
-        QueryResultHolderFuture DelayQueryHolder(SQLQueryHolder* holder);
+        QueryResultHolderFuture DelayQueryHolder(SQLQueryHolder<T>* holder);
 
         /**
             Transaction context methods.

src/server/database/Database/QueryHolder.cpp

@@ -21,7 +21,7 @@
 #include "Log.h"
 #include "QueryResult.h"
 
-bool SQLQueryHolder::SetPreparedQuery(size_t index, PreparedStatementBase* stmt)
+bool SQLQueryHolderBase::SetPreparedQueryImpl(size_t index, PreparedStatementBase* stmt)
 {
     if (m_queries.size() <= index)
     {
@@ -33,7 +33,7 @@ bool SQLQueryHolder::SetPreparedQuery(size_t index, PreparedStatementBase* stmt)
     return true;
 }
 
-PreparedQueryResult SQLQueryHolder::GetPreparedResult(size_t index)
+PreparedQueryResult SQLQueryHolderBase::GetPreparedResult(size_t index)
 {
     // Don't call to this function if the index is of a prepared statement
     if (index < m_queries.size())
@@ -42,7 +42,7 @@ PreparedQueryResult SQLQueryHolder::GetPreparedResult(size_t index)
         return PreparedQueryResult(nullptr);
 }
 
-void SQLQueryHolder::SetPreparedResult(size_t index, PreparedResultSet* result)
+void SQLQueryHolderBase::SetPreparedResult(size_t index, PreparedResultSet* result)
 {
     if (result && !result->GetRowCount())
     {
@@ -55,7 +55,7 @@ void SQLQueryHolder::SetPreparedResult(size_t index, PreparedResultSet* result)
         m_queries[index].second = PreparedQueryResult(result);
 }
 
-SQLQueryHolder::~SQLQueryHolder()
+SQLQueryHolderBase::~SQLQueryHolderBase()
 {
     for (std::pair<PreparedStatementBase*, PreparedQueryResult>& query : m_queries)
     {
@@ -65,7 +65,7 @@ SQLQueryHolder::~SQLQueryHolder()
     }
 }
 
-void SQLQueryHolder::SetSize(size_t size)
+void SQLQueryHolderBase::SetSize(size_t size)
 {
     /// to optimize push_back, reserve the number of queries about to be executed
     m_queries.resize(size);

src/server/database/Database/QueryHolder.h

@@ -20,29 +20,41 @@
 
 #include "SQLOperation.h"
 
-class TC_DATABASE_API SQLQueryHolder
+class TC_DATABASE_API SQLQueryHolderBase
 {
     friend class SQLQueryHolderTask;
     private:
         std::vector<std::pair<PreparedStatementBase*, PreparedQueryResult>> m_queries;
     public:
-        SQLQueryHolder() { }
-        virtual ~SQLQueryHolder();
-        bool SetPreparedQuery(size_t index, PreparedStatementBase* stmt);
+        SQLQueryHolderBase() { }
+        virtual ~SQLQueryHolderBase();
         void SetSize(size_t size);
         PreparedQueryResult GetPreparedResult(size_t index);
         void SetPreparedResult(size_t index, PreparedResultSet* result);
+
+    protected:
+        bool SetPreparedQueryImpl(size_t index, PreparedStatementBase* stmt);
+};
+
+template<typename T>
+class SQLQueryHolder : public SQLQueryHolderBase
+{
+public:
+    bool SetPreparedQuery(size_t index, PreparedStatement<T>* stmt)
+    {
+        return SetPreparedQueryImpl(index, stmt);
+    }
 };
 
 class TC_DATABASE_API SQLQueryHolderTask : public SQLOperation
 {
     private:
-        SQLQueryHolder* m_holder;
+        SQLQueryHolderBase* m_holder;
         QueryResultHolderPromise m_result;
         bool m_executed;
 
     public:
-        SQLQueryHolderTask(SQLQueryHolder* holder)
+        SQLQueryHolderTask(SQLQueryHolderBase* holder)
             : m_holder(holder), m_executed(false) { }
 
         ~SQLQueryHolderTask();