Cleanup on some database-related files: merge some DB-related files, add some consistency to callhandles in sourcetree (M

+ combine MySQL-specific files into main database-files (click)
+ fix vcproj-files, adjust handler-function names for consistency (Machiavelli)

--HG--
branch : trunk

1 files changed, 399 insertions, 2 deletions

diff --git a/src/shared/Database/Database.cpp b/src/shared/Database/Database.cpp
index 92538b7d201..bc4e863132e 100644
--- a/src/shared/Database/Database.cpp
+++ b/src/shared/Database/Database.cpp
@@ -24,15 +24,51 @@
 #include "Common.h"
 #include "../../game/UpdateFields.h"
 
+#include "Util.h"
+#include "Policies/SingletonImp.h"
+#include "Platform/Define.h"
+#include "Threading.h"
+#include "Database/SqlDelayThread.h"
+#include "Database/SqlOperations.h"
+#include "Timer.h"
+
+
 #include <ctime>
 #include <iostream>
 #include <fstream>
 
+size_t Database::db_count = 0;
+
+Database::Database()
+{
+    // before first connection
+    if (db_count++ == 0)
+    {
+        // Mysql Library Init
+        mysql_library_init(-1, NULL, NULL);
+
+        if (!mysql_thread_safe())
+        {
+            sLog.outError("FATAL ERROR: Used MySQL library isn't thread-safe.");
+            exit(1);
+        }
+    }
+}
+
 Database::~Database()
 {
+    if (m_delayThread)
+        HaltDelayThread();
+
+    if (mMysql)
+        mysql_close(mMysql);
+
+    // Free Mysql library pointers for last ~DB
+    if (--db_count == 0)
+        mysql_library_end();
 }
 
-bool Database::Initialize(const char *)
+bool Database::Initialize(const char *infoString)
 {
     // Enable logging of SQL commands (usally only GM commands)
     // (See method: PExecuteLog)
@@ -44,15 +80,114 @@ bool Database::Initialize(const char *)
             m_logsDir.append("/");
     }
 
-    return true;
+    tranThread = NULL;
+    MYSQL *mysqlInit;
+    mysqlInit = mysql_init(NULL);
+    if (!mysqlInit)
+    {
+        sLog.outError("Could not initialize Mysql connection");
+        return false;
+    }
+
+    InitDelayThread();
+
+    Tokens tokens = StrSplit(infoString, ";");
+
+    Tokens::iterator iter;
+
+    std::string host, port_or_socket, user, password, database;
+    int port;
+    char const* unix_socket;
+
+    iter = tokens.begin();
+
+    if (iter != tokens.end())
+        host = *iter++;
+    if (iter != tokens.end())
+        port_or_socket = *iter++;
+    if (iter != tokens.end())
+        user = *iter++;
+    if (iter != tokens.end())
+        password = *iter++;
+    if (iter != tokens.end())
+        database = *iter++;
+
+    mysql_options(mysqlInit, MYSQL_SET_CHARSET_NAME, "utf8");
+    #ifdef WIN32
+    if (host==".")                                           // named pipe use option (Windows)
+    {
+        unsigned int opt = MYSQL_PROTOCOL_PIPE;
+        mysql_options(mysqlInit, MYSQL_OPT_PROTOCOL, (char const*)&opt);
+        port = 0;
+        unix_socket = 0;
+    }
+    else                                                    // generic case
+    {
+        port = atoi(port_or_socket.c_str());
+        unix_socket = 0;
+    }
+    #else
+    if (host==".")                                           // socket use option (Unix/Linux)
+    {
+        unsigned int opt = MYSQL_PROTOCOL_SOCKET;
+        mysql_options(mysqlInit, MYSQL_OPT_PROTOCOL, (char const*)&opt);
+        host = "localhost";
+        port = 0;
+        unix_socket = port_or_socket.c_str();
+    }
+    else                                                    // generic case
+    {
+        port = atoi(port_or_socket.c_str());
+        unix_socket = 0;
+    }
+    #endif
+
+    mMysql = mysql_real_connect(mysqlInit, host.c_str(), user.c_str(),
+        password.c_str(), database.c_str(), port, unix_socket, 0);
+
+    if (mMysql)
+    {
+        sLog.outDetail("Connected to MySQL database at %s", host.c_str());
+        sLog.outString("MySQL client library: %s", mysql_get_client_info());
+        sLog.outString("MySQL server ver: %s ", mysql_get_server_info( mMysql));
+
+        if (!mysql_autocommit(mMysql, 1))
+            sLog.outDetail("AUTOCOMMIT SUCCESSFULLY SET TO 1");
+        else
+            sLog.outDetail("AUTOCOMMIT NOT SET TO 1");
+
+        // set connection properties to UTF8 to properly handle locales for different
+        // server configs - core sends data in UTF8, so MySQL must expect UTF8 too
+        PExecute("SET NAMES `utf8`");
+        PExecute("SET CHARACTER SET `utf8`");
+
+    #if MYSQL_VERSION_ID >= 50003
+        my_bool my_true = (my_bool)1;
+        if (mysql_options(mMysql, MYSQL_OPT_RECONNECT, &my_true))
+            sLog.outDetail("Failed to turn on MYSQL_OPT_RECONNECT.");
+        else
+           sLog.outDetail("Successfully turned on MYSQL_OPT_RECONNECT.");
+    #else
+        #warning "Your mySQL client lib version does not support reconnecting after a timeout.\nIf this causes you any trouble we advice you to upgrade your mySQL client libs to at least mySQL 5.0.13 to resolve this problem."
+    #endif
+        return true;
+    }
+    else
+    {
+        sLog.outError("Could not connect to MySQL database at %s: %s\n", host.c_str(),mysql_error(mysqlInit));
+        mysql_close(mysqlInit);
+        return false;
+    }
 }
 
 void Database::ThreadStart()
 {
+    mysql_thread_init();
 }
 
 void Database::ThreadEnd()
 {
+    mysql_thread_end();
 }
 
 void Database::escape_string(std::string& str)
@@ -66,6 +201,15 @@ void Database::escape_string(std::string& str)
     delete[] buf;
 }
 
+unsigned long Database::escape_string(char *to, const char *from, unsigned long length)
+{
+    if (!mMysql || !to || !from || !length)
+        return 0;
+
+    return(mysql_real_escape_string(mMysql, to, from, length));
+}
+
+
 bool Database::PExecuteLog(const char * format,...)
 {
     if (!format)
@@ -115,6 +259,65 @@ void Database::SetResultQueue(SqlResultQueue * queue)
     m_queryQueues[ACE_Based::Thread::current()] = queue;
 }
 
+bool Database::_Query(const char *sql, MYSQL_RES **pResult, MYSQL_FIELD **pFields, uint64* pRowCount, uint32* pFieldCount)
+{
+    if (!mMysql)
+        return 0;
+
+    {
+        // guarded block for thread-safe mySQL request
+        ACE_Guard<ACE_Thread_Mutex> query_connection_guard(mMutex);
+        #ifdef TRINITY_DEBUG
+        uint32 _s = getMSTime();
+        #endif
+        if (mysql_query(mMysql, sql))
+        {
+            sLog.outErrorDb("SQL: %s", sql);
+            sLog.outErrorDb("query ERROR: %s", mysql_error(mMysql));
+            return false;
+        }
+        else
+        {
+            #ifdef TRINITY_DEBUG
+            sLog.outDebug("[%u ms] SQL: %s", getMSTimeDiff(_s,getMSTime()), sql );
+            #endif
+        }
+
+        *pResult = mysql_store_result(mMysql);
+        *pRowCount = mysql_affected_rows(mMysql);
+        *pFieldCount = mysql_field_count(mMysql);
+    }
+
+    if (!*pResult )
+        return false;
+
+    if (!*pRowCount)
+    {
+        mysql_free_result(*pResult);
+        return false;
+    }
+
+    *pFields = mysql_fetch_fields(*pResult);
+    return true;
+}
+
+QueryResult_AutoPtr Database::Query(const char *sql)
+{
+    MYSQL_RES *result = NULL;
+    MYSQL_FIELD *fields = NULL;
+    uint64 rowCount = 0;
+    uint32 fieldCount = 0;
+
+    if (!_Query(sql, &result, &fields, &rowCount, &fieldCount))
+        return QueryResult_AutoPtr(NULL);
+
+    QueryResult *queryResult = new QueryResult(result, fields, rowCount, fieldCount);
+
+    queryResult->NextRow();
+
+    return QueryResult_AutoPtr(queryResult);
+}
+
 QueryResult_AutoPtr Database::PQuery(const char *format,...)
 {
     if (!format)
@@ -135,6 +338,27 @@ QueryResult_AutoPtr Database::PQuery(const char *format,...)
     return Query(szQuery);
 }
 
+QueryNamedResult* Database::QueryNamed(const char *sql)
+{
+    MYSQL_RES *result = NULL;
+    MYSQL_FIELD *fields = NULL;
+    uint64 rowCount = 0;
+    uint32 fieldCount = 0;
+
+    if (!_Query(sql, &result, &fields, &rowCount, &fieldCount))
+        return NULL;
+
+    QueryFieldNames names(fieldCount);
+    for (uint32 i = 0; i < fieldCount; i++)
+         names[i] = fields[i].name;
+
+    QueryResult *queryResult = new QueryResult(result, fields, rowCount, fieldCount);
+
+    queryResult->NextRow();
+
+    return new QueryNamedResult(queryResult, names);
+}
+
 QueryNamedResult* Database::PQueryNamed(const char *format,...)
 {
     if (!format)
@@ -155,6 +379,25 @@ QueryNamedResult* Database::PQueryNamed(const char *format,...)
     return QueryNamed(szQuery);
 }
 
+bool Database::Execute(const char *sql)
+{
+    if (!mMysql)
+        return false;
+
+    // don't use queued execution if it has not been initialized
+    if (!m_threadBody)
+        return DirectExecute(sql);
+
+    tranThread = ACE_Based::Thread::current();              // owner of this transaction
+    TransactionQueues::iterator i = m_tranQueues.find(tranThread);
+    if (i != m_tranQueues.end() && i->second != NULL)
+        i->second->DelayExecute(sql);                       // Statement for transaction
+    else
+        m_threadBody->Delay(new SqlStatement(sql));         // Simple sql statement
+
+    return true;
+}
+
 bool Database::PExecute(const char * format,...)
 {
     if (!format)
@@ -194,6 +437,35 @@ bool Database::_SetDataBlobValue(const uint32 guid, const uint32 field, const ui
         field, value, -int32(PLAYER_END-field), guid);
 }
 
+bool Database::DirectExecute(const char* sql)
+{
+    if (!mMysql)
+        return false;
+
+    {
+        // guarded block for thread-safe mySQL request
+        ACE_Guard<ACE_Thread_Mutex> query_connection_guard(mMutex);
+
+        #ifdef TRINITY_DEBUG
+        uint32 _s = getMSTime();
+        #endif
+        if (mysql_query(mMysql, sql))
+        {
+            sLog.outErrorDb("SQL: %s", sql);
+            sLog.outErrorDb("SQL ERROR: %s", mysql_error(mMysql));
+            return false;
+        }
+        else
+        {
+            #ifdef TRINITY_DEBUG
+            sLog.outDebug("[%u ms] SQL: %s", getMSTimeDiff(_s,getMSTime()), sql);
+            #endif
+        }
+    }
+
+    return true;
+}
+
 bool Database::DirectPExecute(const char * format,...)
 {
     if (!format)
@@ -250,3 +522,128 @@ bool Database::CheckRequiredField(char const* table_name, char const* required_n
 
     return false;
 }
+
+bool Database::_TransactionCmd(const char *sql)
+{
+    if (mysql_query(mMysql, sql))
+    {
+        sLog.outError("SQL: %s", sql);
+        sLog.outError("SQL ERROR: %s", mysql_error(mMysql));
+        return false;
+    }
+    else
+        DEBUG_LOG("SQL: %s", sql);
+
+    return true;
+}
+
+bool Database::BeginTransaction()
+{
+    if (!mMysql)
+        return false;
+
+    // don't use queued execution if it has not been initialized
+    if (!m_threadBody)
+    {
+        if (tranThread == ACE_Based::Thread::current())
+            return false;                                   // huh? this thread already started transaction
+
+        mMutex.acquire();
+        if (!_TransactionCmd("START TRANSACTION"))
+        {
+            mMutex.release();                               // can't start transaction
+            return false;
+        }
+        return true;                                        // transaction started
+    }
+
+    tranThread = ACE_Based::Thread::current();              // owner of this transaction
+    TransactionQueues::iterator i = m_tranQueues.find(tranThread);
+    if (i != m_tranQueues.end() && i->second != NULL)
+        // If for thread exists queue and also contains transaction
+        // delete that transaction (not allow trans in trans)
+        delete i->second;
+
+    m_tranQueues[tranThread] = new SqlTransaction();
+
+    return true;
+}
+
+bool Database::CommitTransaction()
+{
+    if (!mMysql)
+        return false;
+
+    // don't use queued execution if it has not been initialized
+    if (!m_threadBody)
+    {
+        if (tranThread != ACE_Based::Thread::current())
+            return false;
+
+        bool _res = _TransactionCmd("COMMIT");
+        tranThread = NULL;
+        mMutex.release();
+        return _res;
+    }
+
+    tranThread = ACE_Based::Thread::current();
+    TransactionQueues::iterator i = m_tranQueues.find(tranThread);
+    if (i != m_tranQueues.end() && i->second != NULL)
+    {
+        m_threadBody->Delay(i->second);
+        i->second = NULL;
+        return true;
+    }
+    else
+        return false;
+}
+
+bool Database::RollbackTransaction()
+{
+    if (!mMysql)
+        return false;
+
+    // don't use queued execution if it has not been initialized
+    if (!m_threadBody)
+    {
+        if (tranThread != ACE_Based::Thread::current())
+            return false;
+
+        bool _res = _TransactionCmd("ROLLBACK");
+        tranThread = NULL;
+        mMutex.release();
+        return _res;
+    }
+
+    tranThread = ACE_Based::Thread::current();
+    TransactionQueues::iterator i = m_tranQueues.find(tranThread);
+    if (i != m_tranQueues.end() && i->second != NULL)
+    {
+        delete i->second;
+        i->second = NULL;
+    }
+
+    return true;
+}
+
+void Database::InitDelayThread()
+{
+    assert(!m_delayThread);
+
+    //New delay thread for delay execute
+    m_threadBody = new SqlDelayThread(this);              // will deleted at m_delayThread delete
+    m_delayThread = new ACE_Based::Thread(m_threadBody);
+}
+
+void Database::HaltDelayThread()
+{
+    if (!m_threadBody || !m_delayThread)
+        return;
+
+    m_threadBody->Stop();                                   //Stop event
+    m_delayThread->wait();                                  //Wait for flush to DB
+    delete m_delayThread;                                   //This also deletes m_threadBody
+    m_delayThread = NULL;
+    m_threadBody = NULL;
+}
+