[6920] Cleaned up DatabaseImpl and added support for async queries with 3 parameters passed to the callback.

src/shared/Database/Database.h

@@ -55,27 +55,41 @@ class MANGOS_DLL_SPEC Database
         QueryResult* PQuery(const char *format,...) ATTR_PRINTF(2,3);
 
         /// Async queries and query holders, implemented in DatabaseImpl.h
+
+        // Query / member
         template<class Class>
             bool AsyncQuery(Class *object, void (Class::*method)(QueryResult*), const char *sql);
         template<class Class, typename ParamType1>
             bool AsyncQuery(Class *object, void (Class::*method)(QueryResult*, ParamType1), ParamType1 param1, const char *sql);
         template<class Class, typename ParamType1, typename ParamType2>
             bool AsyncQuery(Class *object, void (Class::*method)(QueryResult*, ParamType1, ParamType2), ParamType1 param1, ParamType2 param2, const char *sql);
+        template<class Class, typename ParamType1, typename ParamType2, typename ParamType3>
+            bool AsyncQuery(Class *object, void (Class::*method)(QueryResult*, ParamType1, ParamType2, ParamType3), ParamType1 param1, ParamType2 param2, ParamType3 param3, const char *sql);
+        // Query / static
         template<typename ParamType1>
             bool AsyncQuery(void (*method)(QueryResult*, ParamType1), ParamType1 param1, const char *sql);
         template<typename ParamType1, typename ParamType2>
             bool AsyncQuery(void (*method)(QueryResult*, ParamType1, ParamType2), ParamType1 param1, ParamType2 param2, const char *sql);
+        template<typename ParamType1, typename ParamType2, typename ParamType3>
+            bool AsyncQuery(void (*method)(QueryResult*, ParamType1, ParamType2, ParamType3), ParamType1 param1, ParamType2 param2, ParamType3 param3, const char *sql);
+        // PQuery / member
         template<class Class>
             bool AsyncPQuery(Class *object, void (Class::*method)(QueryResult*), const char *format,...) ATTR_PRINTF(4,5);
         template<class Class, typename ParamType1>
             bool AsyncPQuery(Class *object, void (Class::*method)(QueryResult*, ParamType1), ParamType1 param1, const char *format,...) ATTR_PRINTF(5,6);
         template<class Class, typename ParamType1, typename ParamType2>
             bool AsyncPQuery(Class *object, void (Class::*method)(QueryResult*, ParamType1, ParamType2), ParamType1 param1, ParamType2 param2, const char *format,...) ATTR_PRINTF(5,6);
+        template<class Class, typename ParamType1, typename ParamType2, typename ParamType3>
+            bool AsyncPQuery(Class *object, void (Class::*method)(QueryResult*, ParamType1, ParamType2, ParamType3), ParamType1 param1, ParamType2 param2, ParamType3 param3, const char *format,...) ATTR_PRINTF(5,6);
+        // PQuery / static
         template<typename ParamType1>
             bool AsyncPQuery(void (*method)(QueryResult*, ParamType1), ParamType1 param1, const char *format,...) ATTR_PRINTF(5,6);
         template<typename ParamType1, typename ParamType2>
             bool AsyncPQuery(void (*method)(QueryResult*, ParamType1, ParamType2), ParamType1 param1, ParamType2 param2, const char *format,...) ATTR_PRINTF(5,6);
+        template<typename ParamType1, typename ParamType2, typename ParamType3>
+            bool AsyncPQuery(void (*method)(QueryResult*, ParamType1, ParamType2, ParamType3), ParamType1 param1, ParamType2 param2, ParamType3 param3, const char *format,...) ATTR_PRINTF(5,6);
         template<class Class>
+        // QueryHolder
             bool DelayQueryHolder(Class *object, void (Class::*method)(QueryResult*, SqlQueryHolder*), SqlQueryHolder *holder);
         template<class Class, typename ParamType1>
             bool DelayQueryHolder(Class *object, void (Class::*method)(QueryResult*, SqlQueryHolder*, ParamType1), SqlQueryHolder *holder, ParamType1 param1);

src/shared/Database/DatabaseImpl.h

@@ -21,84 +21,114 @@
 
 /// Function body definitions for the template function members of the Database class
 
+#define ASYNC_QUERY_BODY(sql, queue_itr) \
+    if (!sql) return false; \
+    \
+    QueryQueues::iterator queue_itr; \
+    \
+    { \
+        ZThread::ThreadImpl * queryThread = ZThread::ThreadImpl::current(); \
+        queue_itr = m_queryQueues.find(queryThread); \
+        if (queue_itr == m_queryQueues.end()) return false; \
+    }
+
+#define ASYNC_PQUERY_BODY(format, szQuery) \
+    if(!format) return false; \
+    \
+    char szQuery [MAX_QUERY_LEN]; \
+    \
+    { \
+        va_list ap; \
+        \
+        va_start(ap, format); \
+        int res = vsnprintf( szQuery, MAX_QUERY_LEN, format, ap ); \
+        va_end(ap); \
+        \
+        if(res==-1) \
+        { \
+            sLog.outError("SQL Query truncated (and not execute) for format: %s",format); \
+            return false; \
+        } \
+    }
+
+#define ASYNC_DELAYHOLDER_BODY(holder, queue_itr) \
+    if (!holder) return false; \
+    \
+    QueryQueues::iterator queue_itr; \
+    \
+    { \
+        ZThread::ThreadImpl * queryThread = ZThread::ThreadImpl::current(); \
+        queue_itr = m_queryQueues.find(queryThread); \
+        if (queue_itr == m_queryQueues.end()) return false; \
+    }
+
+// -- Query / member --
+
 template<class Class>
 bool
 Database::AsyncQuery(Class *object, void (Class::*method)(QueryResult*), const char *sql)
 {
-    if (!sql) return false;
+    ASYNC_QUERY_BODY(sql, itr)
-    ZThread::ThreadImpl * queryThread = ZThread::ThreadImpl::current();
+    return m_threadBody->Delay(new SqlQuery(sql, new MaNGOS::QueryCallback<Class>(object, method), itr->second));
-    QueryQueues::iterator itr = m_queryQueues.find(queryThread);
-    if (itr == m_queryQueues.end()) return false;
-    m_threadBody->Delay(new SqlQuery(sql, new MaNGOS::QueryCallback<Class>(object, method), itr->second));
-    return true;
 }
 
 template<class Class, typename ParamType1>
 bool
 Database::AsyncQuery(Class *object, void (Class::*method)(QueryResult*, ParamType1), ParamType1 param1, const char *sql)
 {
-    if (!sql) return false;
+    ASYNC_QUERY_BODY(sql, itr)
-    ZThread::ThreadImpl * queryThread = ZThread::ThreadImpl::current();
+    return m_threadBody->Delay(new SqlQuery(sql, new MaNGOS::QueryCallback<Class, ParamType1>(object, method, (QueryResult*)NULL, param1), itr->second));
-    QueryQueues::iterator itr = m_queryQueues.find(queryThread);
-    if (itr == m_queryQueues.end()) return false;
-    m_threadBody->Delay(new SqlQuery(sql, new MaNGOS::QueryCallback<Class, ParamType1>(object, method, (QueryResult*)NULL, param1), itr->second));
-    return true;
 }
 
 template<class Class, typename ParamType1, typename ParamType2>
 bool
 Database::AsyncQuery(Class *object, void (Class::*method)(QueryResult*, ParamType1, ParamType2), ParamType1 param1, ParamType2 param2, const char *sql)
 {
-    if (!sql) return false;
+    ASYNC_QUERY_BODY(sql, itr)
-    ZThread::ThreadImpl * queryThread = ZThread::ThreadImpl::current();
+    return m_threadBody->Delay(new SqlQuery(sql, new MaNGOS::QueryCallback<Class, ParamType1, ParamType2>(object, method, (QueryResult*)NULL, param1, param2), itr->second));
-    QueryQueues::iterator itr = m_queryQueues.find(queryThread);
-    if (itr == m_queryQueues.end()) return false;
-    m_threadBody->Delay(new SqlQuery(sql, new MaNGOS::QueryCallback<Class, ParamType1, ParamType2>(object, method, (QueryResult*)NULL, param1, param2), itr->second));
-    return true;
 }
 
+template<class Class, typename ParamType1, typename ParamType2, typename ParamType3>
+bool
+Database::AsyncQuery(Class *object, void (Class::*method)(QueryResult*, ParamType1, ParamType2, ParamType3), ParamType1 param1, ParamType2 param2, ParamType3 param3, const char *sql)
+{
+    ASYNC_QUERY_BODY(sql, itr)
+    return m_threadBody->Delay(new SqlQuery(sql, new MaNGOS::QueryCallback<Class, ParamType1, ParamType2, ParamType3>(object, method, (QueryResult*)NULL, param1, param2, param3), itr->second));
+}
+
+// -- Query / static -- 
+
 template<typename ParamType1>
 bool
 Database::AsyncQuery(void (*method)(QueryResult*, ParamType1), ParamType1 param1, const char *sql)
 {
-    if (!sql) return false;
+    ASYNC_QUERY_BODY(sql, itr)
-    ZThread::ThreadImpl * queryThread = ZThread::ThreadImpl::current();
+    return m_threadBody->Delay(new SqlQuery(sql, new MaNGOS::SQueryCallback<ParamType1>(method, (QueryResult*)NULL, param1), itr->second));
-    QueryQueues::iterator itr = m_queryQueues.find(queryThread);
-    if (itr == m_queryQueues.end()) return false;
-    m_threadBody->Delay(new SqlQuery(sql, new MaNGOS::SQueryCallback<ParamType1>(method, (QueryResult*)NULL, param1), itr->second));
-    return true;
 }
 
 template<typename ParamType1, typename ParamType2>
 bool
 Database::AsyncQuery(void (*method)(QueryResult*, ParamType1, ParamType2), ParamType1 param1, ParamType2 param2, const char *sql)
 {
-    if (!sql) return false;
+    ASYNC_QUERY_BODY(sql, itr)
-    ZThread::ThreadImpl * queryThread = ZThread::ThreadImpl::current();
+    return m_threadBody->Delay(new SqlQuery(sql, new MaNGOS::SQueryCallback<ParamType1, ParamType2>(method, (QueryResult*)NULL, param1, param2), itr->second));
-    QueryQueues::iterator itr = m_queryQueues.find(queryThread);
-    if (itr == m_queryQueues.end()) return false;
-    m_threadBody->Delay(new SqlQuery(sql, new MaNGOS::SQueryCallback<ParamType1, ParamType2>(method, (QueryResult*)NULL, param1, param2), itr->second));
-    return true;
 }
 
+template<typename ParamType1, typename ParamType2, typename ParamType3>
+bool
+Database::AsyncQuery(void (*method)(QueryResult*, ParamType1, ParamType2, ParamType3), ParamType1 param1, ParamType2 param2, ParamType3 param3, const char *sql)
+{
+    ASYNC_QUERY_BODY(sql, itr)
+    return m_threadBody->Delay(new SqlQuery(sql, new MaNGOS::SQueryCallback<ParamType1, ParamType2, ParamType3>(method, (QueryResult*)NULL, param1, param2, param3), itr->second));
+}
+
+// -- PQuery / member --
+
 template<class Class>
 bool
 Database::AsyncPQuery(Class *object, void (Class::*method)(QueryResult*), const char *format,...)
 {
-    if(!format) return false;
+    ASYNC_PQUERY_BODY(format, szQuery)
-
-    va_list ap;
-    char szQuery [MAX_QUERY_LEN];
-    va_start(ap, format);
-    int res = vsnprintf( szQuery, MAX_QUERY_LEN, format, ap );
-    va_end(ap);
-
-    if(res==-1)
-    {
-        sLog.outError("SQL Query truncated (and not execute) for format: %s",format);
-        return false;
-    }
-
     return AsyncQuery(object, method, szQuery);
 }
 
@@ -106,20 +136,7 @@ template<class Class, typename ParamType1>
 bool
 Database::AsyncPQuery(Class *object, void (Class::*method)(QueryResult*, ParamType1), ParamType1 param1, const char *format,...)
 {
-    if(!format) return false;
+    ASYNC_PQUERY_BODY(format, szQuery)
-
-    va_list ap;
-    char szQuery [MAX_QUERY_LEN];
-    va_start(ap, format);
-    int res = vsnprintf( szQuery, MAX_QUERY_LEN, format, ap );
-    va_end(ap);
-
-    if(res==-1)
-    {
-        sLog.outError("SQL Query truncated (and not execute) for format: %s",format);
-        return false;
-    }
-
     return AsyncQuery(object, method, param1, szQuery);
 }
 
@@ -127,41 +144,25 @@ template<class Class, typename ParamType1, typename ParamType2>
 bool
 Database::AsyncPQuery(Class *object, void (Class::*method)(QueryResult*, ParamType1, ParamType2), ParamType1 param1, ParamType2 param2, const char *format,...)
 {
-    if(!format) return false;
+    ASYNC_PQUERY_BODY(format, szQuery)
-
-    va_list ap;
-    char szQuery [MAX_QUERY_LEN];
-    va_start(ap, format);
-    int res = vsnprintf( szQuery, MAX_QUERY_LEN, format, ap );
-    va_end(ap);
-
-    if(res==-1)
-    {
-        sLog.outError("SQL Query truncated (and not execute) for format: %s",format);
-        return false;
-    }
-
     return AsyncQuery(object, method, param1, param2, szQuery);
 }
 
+template<class Class, typename ParamType1, typename ParamType2, typename ParamType3>
+bool
+Database::AsyncPQuery(Class *object, void (Class::*method)(QueryResult*, ParamType1, ParamType2, ParamType3), ParamType1 param1, ParamType2 param2, ParamType3 param3, const char *format,...)
+{
+    ASYNC_PQUERY_BODY(format, szQuery)
+    return AsyncQuery(object, method, param1, param2, param3, szQuery);
+}
+
+// -- PQuery / static --
+
 template<typename ParamType1>
 bool
 Database::AsyncPQuery(void (*method)(QueryResult*, ParamType1), ParamType1 param1, const char *format,...)
 {
-    if(!format) return false;
+    ASYNC_PQUERY_BODY(format, szQuery)
-
-    va_list ap;
-    char szQuery [MAX_QUERY_LEN];
-    va_start(ap, format);
-    int res = vsnprintf( szQuery, MAX_QUERY_LEN, format, ap );
-    va_end(ap);
-
-    if(res==-1)
-    {
-        sLog.outError("SQL Query truncated (and not execute) for format: %s",format);
-        return false;
-    }
-
     return AsyncQuery(method, param1, szQuery);
 }
 
@@ -169,43 +170,36 @@ template<typename ParamType1, typename ParamType2>
 bool
 Database::AsyncPQuery(void (*method)(QueryResult*, ParamType1, ParamType2), ParamType1 param1, ParamType2 param2, const char *format,...)
 {
-    if(!format) return false;
+    ASYNC_PQUERY_BODY(format, szQuery)
-
-    va_list ap;
-    char szQuery [MAX_QUERY_LEN];
-    va_start(ap, format);
-    int res = vsnprintf( szQuery, MAX_QUERY_LEN, format, ap );
-    va_end(ap);
-
-    if(res==-1)
-    {
-        sLog.outError("SQL Query truncated (and not execute) for format: %s",format);
-        return false;
-    }
-
     return AsyncQuery(method, param1, param2, szQuery);
 }
 
+template<typename ParamType1, typename ParamType2, typename ParamType3>
+bool
+Database::AsyncPQuery(void (*method)(QueryResult*, ParamType1, ParamType2, ParamType3), ParamType1 param1, ParamType2 param2, ParamType3 param3, const char *format,...)
+{
+    ASYNC_PQUERY_BODY(format, szQuery)
+    return AsyncQuery(method, param1, param2, param3, szQuery);
+}
+
+// -- QueryHolder --
+
 template<class Class>
 bool
 Database::DelayQueryHolder(Class *object, void (Class::*method)(QueryResult*, SqlQueryHolder*), SqlQueryHolder *holder)
 {
-    if (!holder) return false;
+    ASYNC_DELAYHOLDER_BODY(holder, itr)
-    ZThread::ThreadImpl * queryThread = ZThread::ThreadImpl::current();
+    return holder->Execute(new MaNGOS::QueryCallback<Class, SqlQueryHolder*>(object, method, (QueryResult*)NULL, holder), m_threadBody, itr->second);
-    QueryQueues::iterator itr = m_queryQueues.find(queryThread);
-    if (itr == m_queryQueues.end()) return false;
-    holder->Execute(new MaNGOS::QueryCallback<Class, SqlQueryHolder*>(object, method, (QueryResult*)NULL, holder), m_threadBody, itr->second);
-    return true;
 }
 
 template<class Class, typename ParamType1>
 bool
 Database::DelayQueryHolder(Class *object, void (Class::*method)(QueryResult*, SqlQueryHolder*, ParamType1), SqlQueryHolder *holder, ParamType1 param1)
 {
-    if (!holder) return false;
+    ASYNC_DELAYHOLDER_BODY(holder, itr)
-    ZThread::ThreadImpl * queryThread = ZThread::ThreadImpl::current();
+    return holder->Execute(new MaNGOS::QueryCallback<Class, SqlQueryHolder*, ParamType1>(object, method, (QueryResult*)NULL, holder, param1), m_threadBody, itr->second);
-    QueryQueues::iterator itr = m_queryQueues.find(queryThread);
-    if (itr == m_queryQueues.end()) return false;
-    holder->Execute(new MaNGOS::QueryCallback<Class, SqlQueryHolder*, ParamType1>(object, method, (QueryResult*)NULL, holder, param1), m_threadBody, itr->second);
-    return true;
 }
+
+#undef ASYNC_QUERY_BODY
+#undef ASYNC_PQUERY_BODY
+#undef ASYNC_DELAYHOLDER_BODY

src/shared/Database/SqlDelayThread.h

@@ -40,7 +40,7 @@ class SqlDelayThread : public ZThread::Runnable
         SqlDelayThread(Database* db);
 
         ///< Put sql statement to delay queue
-        inline void Delay(SqlOperation* sql) { m_sqlQueue.add(sql); }
+        inline bool Delay(SqlOperation* sql) { m_sqlQueue.add(sql); return true; }
 
         virtual void Stop();                                ///< Stop event
         virtual void run();                                 ///< Main Thread loop

src/shared/Database/SqlOperations.cpp

@@ -79,15 +79,16 @@ void SqlResultQueue::Update()
     }
 }
 
-void SqlQueryHolder::Execute(MaNGOS::IQueryCallback * callback, SqlDelayThread *thread, SqlResultQueue *queue)
+bool SqlQueryHolder::Execute(MaNGOS::IQueryCallback * callback, SqlDelayThread *thread, SqlResultQueue *queue)
 {
     if(!callback || !thread || !queue)
-        return;
+        return false;
 
     /// delay the execution of the queries, sync them with the delay thread
     /// which will in turn resync on execution (via the queue) and call back
     SqlQueryHolderEx *holderEx = new SqlQueryHolderEx(this, callback, queue);
     thread->Delay(holderEx);
+    return true;
 }
 
 bool SqlQueryHolder::SetQuery(size_t index, const char *sql)

src/shared/Database/SqlOperations.h

@@ -104,7 +104,7 @@ class SqlQueryHolder
         void SetSize(size_t size);
         QueryResult* GetResult(size_t index);
         void SetResult(size_t index, QueryResult *result);
-        void Execute(MaNGOS::IQueryCallback * callback, SqlDelayThread *thread, SqlResultQueue *queue);
+        bool Execute(MaNGOS::IQueryCallback * callback, SqlDelayThread *thread, SqlResultQueue *queue);
 };
 
 class SqlQueryHolderEx : public SqlOperation

src/shared/revision_nr.h

@@ -1,4 +1,4 @@
 #ifndef __REVISION_NR_H__
 #define __REVISION_NR_H__
- #define REVISION_NR "6919"
+ #define REVISION_NR "6920"
 #endif // __REVISION_NR_H__