transactd 2.0.1 → 2.1.0

data/source/bzs/db/engine/mysql/dbManager.h

@@ -18,7 +18,7 @@
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
  ================================================================= */
-
+#include <my_config.h>
 #include <boost/thread/mutex.hpp>
 #include <bzs/db/engine/mysql/database.h>
 
@@ -44,46 +44,10 @@ struct handle
     short cid;
 };
 
-class smartDbsReopen
-{
-    std::vector<boost::shared_ptr<database> >& m_dbs;
-
-public:
-    static std::string removeName;
-
-    smartDbsReopen(std::vector<boost::shared_ptr<database> >& dbs) : m_dbs(dbs)
-    {
-        for (size_t i = 0; i < m_dbs.size(); i++)
-        {
-            if (m_dbs[i])
-            {
-                m_dbs[i]->use();
-                m_dbs[i]->unUseTables(false);
-                m_dbs[i]->closeForReopen();
-            }
-        }
-    }
-
-    ~smartDbsReopen()
-    {
-        for (size_t i = 0; i < m_dbs.size(); i++)
-        {
-            if (m_dbs[i])
-            {
-                if (removeName != m_dbs[i]->name())
-                {
-                    m_dbs[i]->use();
-                    m_dbs[i]->reopen();
-                }
-            }
-        }
-    }
-};
-
-class dbManager;
 
 class dbManager
 {
+    // Lock for isSutdown(), called by another thread
     mutable boost::mutex m_mutex;
 
     int m_autoHandle;
@@ -101,7 +65,7 @@ protected:
     database* getDatabase(const char* dbname, short cid) const;
     database* getDatabaseCid(short cid) const;
     int getDatabaseID(short cid) const;
-    table* getTable(int handle, enum_sql_command cmd = SQLCOM_SELECT) const;
+    table* getTable(int handle, enum_sql_command cmd = SQLCOM_SELECT, engine::mysql::rowLockMode* lck=NULL) const;
     void checkNewHandle(int newHandle) const;
     int addHandle(int dbid, int tableid, int assignid = -1);
     database* useDataBase(int id) const;

data/source/bzs/db/engine/mysql/errorMessage.cpp

@@ -16,7 +16,7 @@
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
  ================================================================= */
-
+#include <my_config.h>
 #include "errorMessage.h"
 #undef PACKAGE
 #include "mysqlInternal.h"
@@ -38,7 +38,7 @@ const char* errorMessage(int errorCode)
     case STATUS_PROGRAM_ERROR:
         return "Program error";
     case STATUS_CANNOT_LOCK_TABLE:
-        return "Can not open the table Allrady locked";
+        return "Can not open the table already locked";
     case STATUS_TABLE_NOTOPEN:
         return "Can not open the table";
     case STATUS_INVALID_KEYNAME:
@@ -55,17 +55,21 @@ const char* errorMessage(int errorCode)
     return "";
 }
 
-void printErrorMessage(const int* errorCode, const std::string* message)
+void printWarningMessage(const int* errorCode, const std::string* message)
 {
     int code = errorCode ? *errorCode : 0;
     std::string msg = errorMessage(code);
     if (message)
-        msg += " :" + *message;
-
-    if ((code != STATUS_TABLE_NOTOPEN) && (code != STATUS_INVALID_BOOKMARK))
     {
-        sql_print_error("%s", msg.c_str());
+        if ((msg != "") && (*message != ""))
+            msg += ": " + *message;
+        else
+            msg += *message;
     }
+    if ((code != STATUS_TABLE_NOTOPEN) && 
+        (code != STATUS_INVALID_BOOKMARK) && 
+        (code != STATUS_CANNOT_LOCK_TABLE))
+        sql_print_warning("Transactd: %s", msg.c_str());
 }
 
 } // namespace mysql

data/source/bzs/db/engine/mysql/errorMessage.h

@@ -32,7 +32,7 @@ namespace mysql
 {
 
 const char* errorMessage(int errorCode);
-void printErrorMessage(const int* errorCode, const std::string* msg);
+void printWarningMessage(const int* errorCode, const std::string* msg);
 
 } // namespace mysql
 } // namespace engine

data/source/bzs/db/engine/mysql/mydebuglog.cpp

@@ -16,9 +16,8 @@
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
  ================================================================= */
-
+#include <my_config.h>
 #include "mydebuglog.h"
-#include "dbManager.h"
 #include <bzs/db/protocol/tdap/mysql/tdapCommandExecuter.h>
 #include <bzs/env/crosscompile.h>
 #include <bzs/env/fileopen.h>

data/source/bzs/db/engine/mysql/mysqlInternal.h

@@ -166,14 +166,14 @@ inline void cp_restore_globals(THD* thd)
     my_pthread_setspecific_ptr(THR_MALLOC, 0);
 }
 
-inline bool cp_is_write_lock(handler* file)
+inline void cp_thd_set_read_only(THD* thd)
 {
-    return true;
+    ;
 }
 
-inline void cp_thd_set_read_only(THD* thd)
+inline bool cp_thd_get_read_only(THD* thd)
 {
-    ;
+    return false;
 }
 
 inline bool cp_open_table(THD* thd, TABLE_LIST* tables,
@@ -209,14 +209,14 @@ inline void cp_restore_globals(THD* thd)
     thd->restore_globals();
 }
 
-inline bool cp_is_write_lock(handler* file)
+inline void cp_thd_set_read_only(THD* thd)
 {
-    return (file->get_lock_type() == F_WRLCK);
+    thd->tx_read_only = (thd->variables.tx_read_only != 0);
 }
 
-inline void cp_thd_set_read_only(THD* thd)
+inline bool cp_thd_get_read_only(THD* thd)
 {
-    thd->tx_read_only = (thd->variables.tx_read_only != 0);
+    return (thd->variables.tx_read_only != 0);
 }
 
 inline bool cp_open_table(THD* thd, TABLE_LIST* tables,

data/source/bzs/db/engine/mysql/mysqlThd.cpp

@@ -92,8 +92,19 @@ void endThread()
     setStackaddr(0);
 }
 
+void waitForServerStart()
+{
+    mysql_mutex_lock(&LOCK_server_started);
+    while (!mysqld_server_started)
+        mysql_cond_wait(&COND_server_started, &LOCK_server_started);
+    mysql_mutex_unlock(&LOCK_server_started);
+}
+
 THD* buildTHD()
 {
+    if (!mysqld_server_started)
+        waitForServerStart();
+
     THD* thd = new THD();
     mysql_mutex_lock(&LOCK_thread_count);
     thd->variables.pseudo_thread_id = thread_id++;

data/source/bzs/db/protocol/hs/hsCommandExecuter.cpp

@@ -365,7 +365,7 @@ int dbExecuter::commandExec(std::vector<request>& requests,
                 writeError(1, buf, "");
             sql_print_error("%s", boost::diagnostic_information(e).c_str());
         }
-        printErrorMessage(code, msg);
+        printWarningMessage(code, msg);
     }
 
     catch (...)

data/source/bzs/db/protocol/tdap/client/activeTable.cpp

@@ -90,8 +90,7 @@ activeTable& activeTable::join(recordset& rs, queryBase& q, const _TCHAR* name1,
                                const _TCHAR* name2, const _TCHAR* name3,
                                const _TCHAR* name4, const _TCHAR* name5,
                                const _TCHAR* name6, const _TCHAR* name7,
-                               const _TCHAR* name8, const _TCHAR* name9,
-                               const _TCHAR* name10, const _TCHAR* name11)
+                               const _TCHAR* name8)
 {
     m_imple->join(*rs.m_imple, q, name1, name2, name3, name4, name5, name6,
                   name7, name8);
@@ -102,9 +101,29 @@ activeTable& activeTable::outerJoin(recordset& rs, queryBase& q,
                                     const _TCHAR* name1, const _TCHAR* name2,
                                     const _TCHAR* name3, const _TCHAR* name4,
                                     const _TCHAR* name5, const _TCHAR* name6,
-                                    const _TCHAR* name7, const _TCHAR* name8,
-                                    const _TCHAR* name9, const _TCHAR* name10,
-                                    const _TCHAR* name11)
+                                    const _TCHAR* name7, const _TCHAR* name8)
+{
+    m_imple->outerJoin(*rs.m_imple, q, name1, name2, name3, name4, name5, name6,
+                       name7, name8);
+    return *this;
+}
+
+activeTable& activeTable::join(recordset& rs, pq_handle& q, const _TCHAR* name1,
+                               const _TCHAR* name2, const _TCHAR* name3,
+                               const _TCHAR* name4, const _TCHAR* name5,
+                               const _TCHAR* name6, const _TCHAR* name7,
+                               const _TCHAR* name8)
+{
+    m_imple->join(*rs.m_imple, q, name1, name2, name3, name4, name5, name6,
+                  name7, name8);
+    return *this;
+}
+
+activeTable& activeTable::outerJoin(recordset& rs, pq_handle& q,
+                                    const _TCHAR* name1, const _TCHAR* name2,
+                                    const _TCHAR* name3, const _TCHAR* name4,
+                                    const _TCHAR* name5, const _TCHAR* name6,
+                                    const _TCHAR* name7, const _TCHAR* name8)
 {
     m_imple->outerJoin(*rs.m_imple, q, name1, name2, name3, name4, name5, name6,
                        name7, name8);
@@ -123,9 +142,13 @@ activeTable& activeTable::option(int v)
     return *this;
 }
 
-activeTable& activeTable::read(recordset& rs, queryBase& q)
+pq_handle activeTable::prepare(queryBase& q, bool serverPrepare)
 {
+    return m_imple->prepare(q, serverPrepare);
+}
 
+activeTable& activeTable::read(recordset& rs, queryBase& q)
+{
     m_imple->read(*rs.m_imple, q);
     return *this;
 }
@@ -136,6 +159,18 @@ activeTable& activeTable::read(recordset& rs, queryBase& q, validationFunc func)
     return *this;
 }
 
+activeTable& activeTable::read(recordset& rs, pq_handle& q)
+{
+    m_imple->read(*rs.m_imple, q);
+    return *this;
+}
+
+activeTable& activeTable::read(recordset& rs, pq_handle& q, validationFunc func)
+{
+    m_imple->read(*rs.m_imple, q, func);
+    return *this;
+}
+
 activeTable* activeTable::create(idatabaseManager* mgr, const _TCHAR* tableName)
 {
     return new activeTable(mgr, tableName);

data/source/bzs/db/protocol/tdap/client/activeTable.h

@@ -32,6 +32,51 @@ namespace tdap
 namespace client
 {
 
+/* For php use */
+class preparedQuery
+{
+    pq_handle m_filter;
+    int m_index;
+public:
+    preparedQuery(pq_handle filter) : m_filter(filter),m_index(0){}
+    
+    inline bool supplyValue(int index, const _TCHAR* v)
+    {
+        return client::supplyValue(m_filter, index, v);
+    }
+    
+    inline bool supplyValue(int index, __int64 v)
+    {
+        return client::supplyValue(m_filter, index, v);
+    }
+
+    inline bool supplyValue(int index, double v)
+    {
+        return client::supplyValue(m_filter, index, v);
+    }
+
+    inline bool addValue(const _TCHAR* v)
+    {
+        return client::supplyValue(m_filter, m_index++, v);
+    }
+    
+    inline bool addValue(__int64 v)
+    {
+        return client::supplyValue(m_filter, m_index++, v);
+    }
+
+    inline bool addValue(double v)
+    {
+        return client::supplyValue(m_filter, m_index++, v);
+    }
+
+    inline void resetAddIndex() { m_index = 0; }
+/** @cond INTERNAL */
+    inline pq_handle& getFilter() { return m_filter; };
+/** @endcond */
+};
+
+
 class DLLLIB activeTable
 {
     class activeTableImple* m_imple;
@@ -39,6 +84,13 @@ class DLLLIB activeTable
     activeTable(const activeTable& r);
     activeTable& operator=(const activeTable& r);
 
+    template<class T> 
+    inline void _supplyValue(pq_handle& q, int index, const T v)
+    {
+        if (!supplyValue(q, index, v))
+            THROW_BZS_ERROR_WITH_MSG(_T("Prepared query : supply value error."));
+    }
+
 public:
     explicit activeTable(idatabaseManager* mgr, const _TCHAR* tableName);
     explicit activeTable(dbmanager_ptr& mgr, const _TCHAR* tableName);
@@ -53,26 +105,143 @@ public:
 
     writableRecord& getWritableRecord();
 
-    activeTable& join(recordset& mdls, queryBase& q, const _TCHAR* name1,
+    activeTable& join(recordset& rs, queryBase& q, const _TCHAR* name1,
                       const _TCHAR* name2 = NULL, const _TCHAR* name3 = NULL,
                       const _TCHAR* name4 = NULL, const _TCHAR* name5 = NULL,
                       const _TCHAR* name6 = NULL, const _TCHAR* name7 = NULL,
-                      const _TCHAR* name8 = NULL, const _TCHAR* name9 = NULL,
-                      const _TCHAR* name10 = NULL, const _TCHAR* name11 = NULL);
+                      const _TCHAR* name8 = NULL);
 
     activeTable&
-    outerJoin(recordset& mdls, queryBase& q, const _TCHAR* name1,
+    outerJoin(recordset& rs, queryBase& q, const _TCHAR* name1,
               const _TCHAR* name2 = NULL, const _TCHAR* name3 = NULL,
               const _TCHAR* name4 = NULL, const _TCHAR* name5 = NULL,
               const _TCHAR* name6 = NULL, const _TCHAR* name7 = NULL,
-              const _TCHAR* name8 = NULL, const _TCHAR* name9 = NULL,
-              const _TCHAR* name10 = NULL, const _TCHAR* name11 = NULL);
+              const _TCHAR* name8 = NULL);
+
+    activeTable& join(recordset& rs, pq_handle& q, const _TCHAR* name1,
+                      const _TCHAR* name2 = NULL, const _TCHAR* name3 = NULL,
+                      const _TCHAR* name4 = NULL, const _TCHAR* name5 = NULL,
+                      const _TCHAR* name6 = NULL, const _TCHAR* name7 = NULL,
+                      const _TCHAR* name8 = NULL);
+
+    activeTable&
+    outerJoin(recordset& rs, pq_handle& q, const _TCHAR* name1,
+              const _TCHAR* name2 = NULL, const _TCHAR* name3 = NULL,
+              const _TCHAR* name4 = NULL, const _TCHAR* name5 = NULL,
+              const _TCHAR* name6 = NULL, const _TCHAR* name7 = NULL,
+              const _TCHAR* name8 = NULL);
 
     activeTable& index(int v);
     table_ptr table() const;
     activeTable& option(int v);
-    activeTable& read(recordset& mdls, queryBase& q);
-    activeTable& read(recordset& mdls, queryBase& q, validationFunc func);
+    pq_handle prepare(queryBase& q, bool serverPrepare = false);
+    activeTable& read(recordset& rs, queryBase& q);
+    activeTable& read(recordset& rs, queryBase& q, validationFunc func);
+    activeTable& read(recordset& rs, pq_handle& q);
+    activeTable& read(recordset& rs, pq_handle& q, validationFunc func);
+
+    /** @cond INTERNAL */
+    template<class T0>
+    activeTable& read(recordset& rs, pq_handle& q, const T0 v0)
+    {
+        _supplyValue(q, 0, v0);
+        read(rs, q);
+        return *this;
+    }
+
+    template<class T0, class T1>
+    activeTable& read(recordset& rs, pq_handle& q, const T0 v0, const T1 v1)
+    {
+        _supplyValue(q, 0, v0);
+        _supplyValue(q, 1, v1);
+        read(rs, q);
+        return *this;
+    }
+
+    template<class T0, class T1, class T2>
+    activeTable& read(recordset& rs, pq_handle& q, const T0 v0, const T1 v1,
+                        const T2 v2)
+    {
+        _supplyValue(q, 0, v0);
+        _supplyValue(q, 1, v1);
+        _supplyValue(q, 2, v2);
+        read(rs, q);
+        return *this;
+    }
+
+    template<class T0, class T1, class T2, class T3>
+    activeTable& read(recordset& rs, pq_handle& q, const T0 v0, const T1 v1,
+                        const T2 v2, const T3 v3)
+    {
+        _supplyValue(q, 0, v0);
+        _supplyValue(q, 1, v1);
+        _supplyValue(q, 2, v2);
+        _supplyValue(q, 3, v3);
+        read(rs, q);
+        return *this;
+    }
+
+    template<class T0, class T1, class T2, class T3, class T4>
+    activeTable& read(recordset& rs, pq_handle& q, const T0 v0, const T1 v1,
+                        const T2 v2, const T3 v3, const T4 v4)
+    {
+        _supplyValue(q, 0, v0);
+        _supplyValue(q, 1, v1);
+        _supplyValue(q, 2, v2);
+        _supplyValue(q, 3, v3);
+        _supplyValue(q, 4, v4);
+        read(rs, q);
+        return *this;
+    }
+
+    template<class T0, class T1, class T2, class T3, class T4, class T5>
+    activeTable& read(recordset& rs, pq_handle& q, const T0 v0, const T1 v1,
+                        const T2 v2, const T3 v3, const T4 v4, const T5 v5)
+    {
+        _supplyValue(q, 0, v0);
+        _supplyValue(q, 1, v1);
+        _supplyValue(q, 2, v2);
+        _supplyValue(q, 3, v3);
+        _supplyValue(q, 4, v4);
+        _supplyValue(q, 5, v5);
+        read(rs, q);
+        return *this;
+    }
+
+    template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
+    activeTable& read(recordset& rs, pq_handle& q, const T0 v0, const T1 v1,
+                        const T2 v2, const T3 v3, const T4 v4, const T5 v5,
+                        const T6 v6)
+    {
+        _supplyValue(q, 0, v0);
+        _supplyValue(q, 1, v1);
+        _supplyValue(q, 2, v2);
+        _supplyValue(q, 3, v3);
+        _supplyValue(q, 4, v4);
+        _supplyValue(q, 5, v5);
+        _supplyValue(q, 6, v6);
+        read(rs, q);
+        return *this;
+    }
+
+    template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+                class T7>
+    activeTable& read(recordset& rs, pq_handle& q, const T0 v0, const T1 v1,
+                        const T2 v2, const T3 v3, const T4 v4, const T5 v5,
+                        const T6 v6, const T7 v7)
+    {
+        _supplyValue(q, 0, v0);
+        _supplyValue(q, 1, v1);
+        _supplyValue(q, 2, v2);
+        _supplyValue(q, 3, v3);
+        _supplyValue(q, 4, v4);
+        _supplyValue(q, 5, v5);
+        _supplyValue(q, 6, v6);
+        _supplyValue(q, 7, v7);
+        read(rs, q);
+        return *this;
+    }
+    /** @endcond */
 
     /** @cond INTERNAL */