Core/DBLayer:

- Add basic prepared statement interface (without implementation and thus without testing, without resultset support).
- Based on raczman/Albator´s work on TrinityCore3

Build:
- Add sLog define ¨hack¨ in DatbaseWorkerPool.h to fix some more sLog errors temporarily

FYI: Builds on windows

--HG--
branch : trunk

src/server/shared/Database/DatabaseWorkerPool.h

@@ -31,6 +31,9 @@
 #include "MySQLConnection.h"
 #include "DatabaseWorker.h"
 
+// TODO: Fixme
+#define sLog (*ACE_Singleton<Log, ACE_Thread_Mutex>::instance())
+
 enum MySQLThreadBundle
 {
     MYSQL_BUNDLE_NONE   = 0x00,     //- Each task will run their own MySQL connection
@@ -257,6 +260,17 @@ class DatabaseWorkerPool
             Enqueue(new TransactionTask(transaction));
         }
 
+        PreparedStatement* GetPreparedStatement(uint32 index)
+        {
+            return new PreparedStatement(index);
+        }
+
+        void Execute(PreparedStatement* stmt)
+        {
+            PreparedStatementTask* task = new PreparedStatementTask(stmt);
+            Enqueue(task);
+        }
+
         void escape_string(std::string& str)
         {
             if (str.empty())

src/server/shared/Database/MySQLConnection.cpp

@@ -27,6 +27,7 @@
 #include "DatabaseEnv.h"
 #include "QueryResult.h"
 #include "SQLOperation.h"
+#include "PreparedStatement.h"
 #include "MySQLConnection.h"
 #include "DatabaseWorker.h"
 #include "Log.h"
@@ -49,6 +50,9 @@ m_Mysql(NULL)
 
 MySQLConnection::~MySQLConnection()
 {
+    for (size_t i = 0; i < m_stmts.size(); ++i)
+        delete m_stmts[i];
+
     MySQL::Thread_End();
     mysql_close(m_Mysql);
 }
@@ -181,6 +185,52 @@ bool MySQLConnection::Execute(const char* sql)
     return true;
 }
 
+bool MySQLConnection::Execute(PreparedStatement* stmt)
+{
+    if (!m_Mysql)
+        return false;
+
+    uint32 index = stmt->m_index;
+    MySQLPreparedStatement* m_mStmt = GetPreparedStatement(index);
+    m_mStmt->m_stmt = stmt;     // Cross reference them for debug output
+    stmt->m_stmt = m_mStmt;
+
+    {
+        // guarded block for thread-safe mySQL request
+        ACE_Guard<ACE_Thread_Mutex> query_connection_guard(m_Mutex);
+        
+        stmt->BindParameters();
+
+        MYSQL_STMT* msql_STMT = m_mStmt->GetSTMT();
+        MYSQL_BIND* msql_BIND = m_mStmt->GetBind();
+
+        #ifdef TRINITY_DEBUG
+        uint32 _s = getMSTime();
+        #endif
+        if (mysql_stmt_bind_param(msql_STMT, msql_BIND))
+        {
+            sLog.outSQLDriver("[ERROR]: PreparedStatement (id: %u) error binding params:  %s", index, mysql_stmt_error(msql_STMT));
+            m_mStmt->ClearParameters();
+            return false;
+        }
+
+        if (mysql_stmt_execute(msql_STMT))
+        {
+            sLog.outSQLDriver("[ERROR]: PreparedStatement (id: %u) error executing:  %s", index, mysql_stmt_error(msql_STMT));
+            m_mStmt->ClearParameters();
+            return false;
+        }
+        else
+        {
+            #ifdef TRINITY_DEBUG
+            sLog.outSQLDriver("[%u ms] Prepared SQL: %u", getMSTimeDiff(_s, getMSTime()), index);
+            #endif
+            m_mStmt->ClearParameters();
+            return true;
+        }
+    }
+}
+
 QueryResult_AutoPtr MySQLConnection::Query(const char* sql)
 {
     if (!sql)
@@ -257,3 +307,31 @@ void MySQLConnection::CommitTransaction()
 {
     Execute("COMMIT");
 }
+
+MySQLPreparedStatement* MySQLConnection::GetPreparedStatement(uint32 index)
+{
+    return m_stmts[index];
+}
+
+void MySQLConnection::PrepareStatement(uint32 index, const char* sql)
+{
+    MYSQL_STMT * stmt = mysql_stmt_init(m_Mysql);
+    if (!stmt)
+    {
+        sLog.outSQLDriver("[ERROR]: In mysql_stmt_init() id: %u, sql: \"%s\"", index, sql);
+        sLog.outSQLDriver("[ERROR]: %s", mysql_error(m_Mysql));
+        return;
+    }
+
+    if (mysql_stmt_prepare(stmt, sql, static_cast<unsigned long>(strlen(sql))))
+    {
+        mysql_stmt_close(stmt);
+        sLog.outSQLDriver("[ERROR]: In mysql_stmt_close() id: %u, sql: \"%s\"", index, sql);
+        sLog.outSQLDriver("[ERROR]: %s", mysql_error(m_Mysql));
+        return;
+    }
+
+    MySQLPreparedStatement* mStmt = new MySQLPreparedStatement(stmt);
+    m_stmts[index] = mStmt;
+}
+    

src/server/shared/Database/MySQLConnection.h

@@ -20,6 +20,8 @@
 #define _MYSQLCONNECTION_H
 
 class DatabaseWorker;
+class PreparedStatement;
+class MySQLPreparedStatement;
 
 class MySQLConnection
 {
@@ -34,6 +36,7 @@ class MySQLConnection
 
     public:
         bool Execute(const char* sql);
+        bool Execute(PreparedStatement* stmt);
         QueryResult_AutoPtr Query(const char* sql);
         bool _Query(const char *sql, MYSQL_RES **pResult, MYSQL_FIELD **pFields, uint64* pRowCount, uint32* pFieldCount);
 
@@ -45,12 +48,15 @@ class MySQLConnection
 
     protected:
         MYSQL* GetHandle()  { return m_Mysql; }
+        MySQLPreparedStatement* GetPreparedStatement(uint32 index);
+        void PrepareStatement(uint32 index, const char* sql);
 
     private:
         ACE_Activation_Queue* m_queue;                      //! Queue shared with other asynchroneous connections.
         DatabaseWorker*       m_worker;                     //! Core worker task.
         MYSQL *               m_Mysql;                      //! MySQL Handle.
         ACE_Thread_Mutex      m_Mutex;
+        std::vector<MySQLPreparedStatement*> m_stmts;       //! PreparedStatements storage
 };
 
 #endif

src/server/shared/Database/PreparedStatement.cpp

@@ -0,0 +1,325 @@
+/*
+ * Copyright (C) 2008-2010 Trinity <http://www.trinitycore.org/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "PreparedStatement.h"
+#include "MySQLConnection.h"
+
+PreparedStatement::PreparedStatement(uint32 index) :
+m_index(index),
+m_stmt(NULL)
+{
+}
+
+PreparedStatement::~PreparedStatement()
+{
+}
+
+void PreparedStatement::BindParameters()
+{
+    ASSERT (m_stmt);
+
+    uint32 i = 0;
+    for (; i < statement_data.size(); i++)
+    {
+        switch (statement_data[i].type)
+        {
+            case TYPE_BOOL:
+                m_stmt->setBool(i, statement_data[i].data.boolean);
+                break;
+            case TYPE_UI8:
+            case TYPE_UI16:
+            case TYPE_UI32:
+                m_stmt->setUInt32(i, statement_data[i].data.ui32);
+                break;
+            case TYPE_I8:
+            case TYPE_I16:
+            case TYPE_I32:
+                m_stmt->setInt32(i, statement_data[i].data.i32);
+                break;
+            case TYPE_UI64:
+                m_stmt->setUInt64(i, statement_data[i].data.ui64);
+                break;
+            case TYPE_I64:
+                m_stmt->setInt64(i, statement_data[i].data.i64);
+                break;
+            case TYPE_FLOAT:
+                m_stmt->setDouble(i, statement_data[i].data.f);
+                break;
+            case TYPE_STRING:
+                m_stmt->setString(i, statement_data[i].str.c_str());
+                break;
+        }
+    }
+    #ifdef _DEBUG
+    if (i < m_stmt->m_paramCount)
+        sLog.outSQLDriver("[WARNING]: BindParameters() for statement %u did not bind all allocated parameters", m_index);
+    #endif
+}
+
+//- Bind to buffer
+void PreparedStatement::setBool(const uint8 index, const bool value)
+{
+    if (index >= statement_data.size())
+        statement_data.resize(index+1);
+
+    statement_data[index].data.boolean = value;
+    statement_data[index].type = TYPE_BOOL;
+}
+
+void PreparedStatement::setUInt8(const uint8 index, const uint8 value)
+{
+    if (index >= statement_data.size())
+        statement_data.resize(index+1);
+
+    statement_data[index].data.ui32 = value;
+    statement_data[index].type = TYPE_UI8;
+}
+
+void PreparedStatement::setUInt16(const uint8 index, const uint16 value)
+{
+    if (index >= statement_data.size())
+        statement_data.resize(index+1);
+
+    statement_data[index].data.ui32 = value;
+    statement_data[index].type = TYPE_UI16;
+}
+
+void PreparedStatement::setUInt32(const uint8 index, const uint32 value)
+{
+    if (index >= statement_data.size())
+        statement_data.resize(index+1);
+
+    statement_data[index].data.ui32 = value;
+    statement_data[index].type = TYPE_UI32;
+}
+
+void PreparedStatement::setUInt64(const uint8 index, const uint64 value)
+{
+    if (index >= statement_data.size())
+        statement_data.resize(index+1);
+
+    statement_data[index].data.ui64 = value;
+    statement_data[index].type = TYPE_UI64;
+}
+
+void PreparedStatement::setInt8(const uint8 index, const int8 value)
+{
+    if (index >= statement_data.size())
+        statement_data.resize(index+1);
+
+    statement_data[index].data.i32 = value;
+    statement_data[index].type = TYPE_I8;
+}
+
+void PreparedStatement::setInt16(const uint8 index, const int16 value)
+{
+    if (index >= statement_data.size())
+        statement_data.resize(index+1);
+
+    statement_data[index].data.i32 = value;
+    statement_data[index].type = TYPE_I16;
+}
+
+void PreparedStatement::setInt32(const uint8 index, const int32 value)
+{
+    if (index >= statement_data.size())
+        statement_data.resize(index+1);
+
+    statement_data[index].data.i32 = value;
+    statement_data[index].type = TYPE_I32;
+}
+
+void PreparedStatement::setInt64(const uint8 index, const int64 value)
+{
+    if (index >= statement_data.size())
+        statement_data.resize(index+1);
+
+    statement_data[index].data.i64 = value;
+    statement_data[index].type = TYPE_I64;
+}
+
+void PreparedStatement::setDouble(const uint8 index, const double value)
+{
+    if (index >= statement_data.size())
+        statement_data.resize(index+1);
+
+    statement_data[index].data.f = value;
+    statement_data[index].type = TYPE_FLOAT;
+}
+
+void PreparedStatement::setString(const uint8 index, const std::string& value)
+{
+    if (index >= statement_data.size())
+        statement_data.resize(index+1);
+
+    statement_data[index].str = value;
+    statement_data[index].type = TYPE_STRING;
+}
+
+MySQLPreparedStatement::MySQLPreparedStatement(MYSQL_STMT* stmt) :
+m_Mstmt(stmt),
+m_bind(NULL)
+{
+    /// Initialize variable parameters
+    m_paramCount = mysql_stmt_param_count(stmt);
+    m_paramsSet.assign(m_paramCount, false);
+    m_bind = new MYSQL_BIND[m_paramCount];
+    memset(m_bind, 0, sizeof(MYSQL_BIND)*m_paramCount);
+
+    /// "If set to 1, causes mysql_stmt_store_result() to update the metadata MYSQL_FIELD->max_length value."
+    my_bool	bool_tmp = 1;
+    mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &bool_tmp);
+}
+
+MySQLPreparedStatement::~MySQLPreparedStatement()
+{
+    ClearParameters();
+    mysql_stmt_close(m_Mstmt);
+    delete[] m_bind;
+}
+
+void MySQLPreparedStatement::ClearParameters()
+{
+    for (uint32 i=0; i < m_paramCount; ++i)
+    {
+        delete m_bind[i].length;
+        m_bind[i].length = NULL;
+        delete[] m_bind[i].buffer;
+        m_bind[i].buffer = NULL;
+        m_paramsSet[i] = false;
+    }
+}
+
+//- Bind on mysql level
+bool MySQLPreparedStatement::CheckValidIndex(uint8 index)
+{
+    if (index >= m_paramCount)
+        return false;
+
+    if (m_paramsSet[index])
+        sLog.outSQLDriver("[WARNING] Prepared Statement (id: %u) trying to bind value on already bound index (%u).", m_stmt->m_index, index);
+    return true;
+}
+
+void MySQLPreparedStatement::setBool(const uint8 index,const bool value)
+{
+    setUInt32(index, value);
+}
+
+void MySQLPreparedStatement::setUInt8(const uint8 index, const uint8 value)
+{
+    setUInt32(index, value);
+}
+
+void MySQLPreparedStatement::setUInt16(const uint8 index, const uint16 value)
+{
+    setUInt32(index, value);
+}
+
+void MySQLPreparedStatement::setUInt32(const uint8 index, const uint32 value)
+{
+    CheckValidIndex(index);
+    m_paramsSet[index] = true;
+    MYSQL_BIND* param = &m_bind[index];
+    setValue(param, MYSQL_TYPE_LONG, &value, sizeof(uint32), true);
+}
+
+void MySQLPreparedStatement::setUInt64(const uint8 index, const uint64 value)
+{
+    CheckValidIndex(index);
+    m_paramsSet[index] = true;
+    MYSQL_BIND* param = &m_bind[index];
+    setValue(param, MYSQL_TYPE_LONGLONG, &value, sizeof(uint64), true);
+}
+
+void MySQLPreparedStatement::setInt8(const uint8 index, const int8 value)
+{
+    setInt32(index, value);
+}
+
+void MySQLPreparedStatement::setInt16(const uint8 index, const int16 value)
+{
+    setInt32(index, value);
+}
+
+void MySQLPreparedStatement::setInt32(const uint8 index, const int32 value)
+{
+    CheckValidIndex(index);
+    m_paramsSet[index] = true;
+    MYSQL_BIND* param = &m_bind[index];
+    setValue(param, MYSQL_TYPE_LONG, &value, sizeof(int32), false);
+}
+
+void MySQLPreparedStatement::setInt64(const uint8 index, const int64 value)
+{
+    CheckValidIndex(index);
+    m_paramsSet[index] = true;
+    MYSQL_BIND* param = &m_bind[index];
+    setValue(param, MYSQL_TYPE_LONGLONG, &value, sizeof(int64), false);
+}
+
+void MySQLPreparedStatement::setDouble(const uint8 index, const double value)
+{
+    CheckValidIndex(index);
+    m_paramsSet[index] = true;
+    MYSQL_BIND* param = &m_bind[index];
+    setValue(param, MYSQL_TYPE_DOUBLE, &value, sizeof(double), (value > 0.0f));
+}
+
+void MySQLPreparedStatement::setString(const uint8 index, const char* value)
+{
+    CheckValidIndex(index);
+    m_paramsSet[index] = true;
+    MYSQL_BIND* param = &m_bind[index];
+    size_t len = strlen(value) + 1;
+    param->buffer_type = MYSQL_TYPE_VAR_STRING;
+    param->buffer = new char[len];
+    param->buffer_length = len;
+    param->is_null_value = 0;
+    param->length = new unsigned long(len-1);
+
+    memcpy(param->buffer, value, len);
+}
+
+void MySQLPreparedStatement::setValue(MYSQL_BIND* param, enum_field_types type, const void* value, uint32 len, bool isUnsigned)
+{
+    param->buffer_type = type;
+    param->buffer = new char[len];
+    param->buffer_length = 0;
+    param->is_null_value = 0;
+    param->length = NULL;               // Only != NULL for strings
+    param->is_unsigned = isUnsigned;
+
+    memcpy(param->buffer, value, len);
+}
+
+//- Execution
+PreparedStatementTask::PreparedStatementTask(PreparedStatement* stmt) :
+m_stmt(stmt)
+{
+}
+
+PreparedStatementTask::~PreparedStatementTask()
+{
+    delete m_stmt;
+}
+
+bool PreparedStatementTask::Execute()
+{
+    return m_conn->Execute(m_stmt);
+}

src/server/shared/Database/PreparedStatement.h

@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2008-2010 Trinity <http://www.trinitycore.org/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _PREPAREDSTATEMENT_H
+#define _PREPAREDSTATEMENT_H
+
+#include "SQLOperation.h"
+
+//- Union for data buffer (upper-level bind -> queue -> lower-level bind)
+union PreparedStatementDataUnion
+{
+    bool boolean;
+    uint8 ui8;
+    int8 i8;
+    uint16 ui16;
+    int16 i16;
+    uint32 ui32;
+    int32 i32;
+    uint64 ui64;
+    int64 i64;
+    double f;   // TODO: Maybe split it up in double and float types
+};
+
+//- This enum helps us differ data held in above union
+enum PreparedStatementValueType
+{
+    TYPE_BOOL,
+    TYPE_UI8,
+    TYPE_UI16,
+    TYPE_UI32,
+    TYPE_UI64,
+    TYPE_I8,
+    TYPE_I16,
+    TYPE_I32,
+    TYPE_I64,
+    TYPE_FLOAT,
+    TYPE_STRING
+};
+
+struct PreparedStatementData
+{
+    PreparedStatementDataUnion data;
+    PreparedStatementValueType type;
+    std::string str;
+};
+
+//- Upper-level class that is used in code
+class PreparedStatement
+{
+    friend class PreparedStatementTask;
+    friend class MySQLPreparedStatement;
+    friend class MySQLConnection;
+
+    public:
+        explicit PreparedStatement(uint32 index);
+        ~PreparedStatement();
+
+        void setBool(const uint8 index,const bool value);
+        void setUInt8(const uint8 index, const uint8 value);
+        void setUInt16(const uint8 index, const uint16 value);
+        void setUInt32(const uint8 index, const uint32 value);
+        void setUInt64(const uint8 index, const uint64 value);
+        void setInt8(const uint8 index, const int8 value);
+        void setInt16(const uint8 index, const int16 value);
+        void setInt32(const uint8 index, const int32 value);
+        void setInt64(const uint8 index, const int64 value);
+        void setDouble(const uint8 index, const double value);
+        void setString(const uint8 index, const std::string& value);
+
+    protected:
+        void BindParameters();
+
+    protected:
+        MySQLPreparedStatement* m_stmt;
+        uint32 m_index;
+        std::vector<PreparedStatementData> statement_data;    //- Buffer of parameters, not tied to MySQL in any way yet
+};
+
+//- Class of which the instances are unique per MySQLConnection
+//- access to these class objects is only done when a prepared statement task
+//- is executed.
+class MySQLPreparedStatement
+{
+    friend class MySQLConnection;
+    friend class PreparedStatement;
+
+    public:
+        MySQLPreparedStatement(MYSQL_STMT* stmt);
+        ~MySQLPreparedStatement();
+
+        void setBool(const uint8 index,const bool value);
+        void setUInt8(const uint8 index, const uint8 value);
+        void setUInt16(const uint8 index, const uint16 value);
+        void setUInt32(const uint8 index, const uint32 value);
+        void setUInt64(const uint8 index, const uint64 value);
+        void setInt8(const uint8 index, const int8 value);
+        void setInt16(const uint8 index, const int16 value);
+        void setInt32(const uint8 index, const int32 value);
+        void setInt64(const uint8 index, const int64 value);
+        void setDouble(const uint8 index, const double value);
+        void setString(const uint8 index, const char* value);
+    
+    protected:
+        MYSQL_STMT* GetSTMT() { return m_Mstmt; }
+        MYSQL_BIND* GetBind() { return m_bind; }
+        PreparedStatement* m_stmt;
+        void ClearParameters();
+        bool CheckValidIndex(uint8 index);
+
+    private:
+        void setValue(MYSQL_BIND* param, enum_field_types type, const void* value, uint32 len, bool isUnsigned);
+
+    private:
+        MYSQL_STMT* m_Mstmt;
+        uint32 m_paramCount;
+        std::vector<bool> m_paramsSet;
+        MYSQL_BIND* m_bind;
+};
+
+//- Lower-level class, enqueuable operation
+class PreparedStatementTask : public SQLOperation
+{
+    public:
+        PreparedStatementTask(PreparedStatement* stmt);
+        ~PreparedStatementTask();
+
+        bool Execute();
+
+    protected:
+        PreparedStatement* m_stmt;
+};
+#endif