transactd 2.2.0 → 2.3.0

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

@@ -39,31 +39,49 @@
 #undef ERROR
 #endif
 
-#ifdef NOMINMAX
-#undef NOMINMAX
-#endif
 #ifdef _MSC_VER
 #pragma warning(disable : 4800)
 #pragma warning(disable : 4267)
 #pragma warning(disable : 4996)
 #pragma warning(disable : 4805)
+#pragma warning(disable : 4005)
+#define NOMINMAX 
 #endif
-
 #include <my_config.h>
 #include <mysql_version.h>
 #include <sql/sql_const.h>
 #include "my_global.h"
+#include <math.h>
+#if ((MYSQL_VERSION_ID > 50700) && !defined(MARIADB_BASE_VERSION))
+// Not use malloc service
+#define MYSQL_SERVICE_MYSQL_ALLOC_INCLUDED
+typedef unsigned int PSI_memory_key;
+typedef int myf_t;
+extern "C" {
+	extern void * my_malloc(PSI_memory_key key, size_t size, myf_t flags);
+	extern void * my_realloc(PSI_memory_key key, void *ptr, size_t size, myf_t flags);
+	extern void my_free(void *ptr);
+	extern void * my_memdup(PSI_memory_key key, const void *from, size_t length, myf_t flags);
+	extern char * my_strdup(PSI_memory_key key, const char *from, myf_t flags);
+	extern char * my_strndup(PSI_memory_key key, const char *from, size_t length, myf_t flags);
+}
+#include "sql/log.h"
+#endif //For MYSQL 5.7
+
 #include "sql/sql_class.h"
 #include <mysql/plugin.h>
 #include "sql/mysqld.h"
 
-#if ((MYSQL_VERSION_ID >= 50600) && !defined(MARIADB_BASE_VERSION))
+#if ((MYSQL_VERSION_ID >= 50600) && (MYSQL_VERSION_ID < 50700) && !defined(MARIADB_BASE_VERSION))
 #include "sql/global_threads.h"
 #endif
 
 #include "sql/sql_plugin.h"
 #include "sql/sql_cache.h"
+#if (MYSQL_VERSION_ID < 50700)
 #include "sql/structs.h"
+#endif
+
 #include "sql/sql_priv.h"
 #include "sql/unireg.h"
 #include "sql/lock.h"
@@ -82,13 +100,7 @@
 #define MYSQL_USER_FIELD_PASSWORD 2
 #endif
 
-
-#if ((MYSQL_VERSION_ID > 50700) && !defined(MARIADB_BASE_VERSION))
-#include "sql/log.h"
-#endif
-
 #undef test
-
 #undef sleep
 #ifdef ERROR
 #define ERROR 0
@@ -99,6 +111,7 @@
 #pragma warning(default : 4267)
 #pragma warning(default : 4800)
 #pragma warning(default : 4805)
+#pragma warning(default : 4005)
 #endif
 
 #undef min
@@ -152,12 +165,12 @@
 
 #if ((MYSQL_VERSION_NUM < 50600) || defined(MARIADB_BASE_VERSION))
 
-inline void cp_add_global_thread(THD* thd)
+inline void add_global_thread(THD* thd)
 {
     ;
 }
 
-inline void cp_remove_global_thread(THD* thd)
+inline void remove_global_thread(THD* thd)
 {
     ;
 }
@@ -173,12 +186,12 @@ inline void cp_restore_globals(THD* thd)
     my_pthread_setspecific_ptr(THR_MALLOC, 0);
 }
 
-inline void cp_thd_set_read_only(THD* thd)
+inline void cp_thd_set_read_only(THD* thd, bool v)
 {
     ;
 }
 
-inline bool cp_thd_get_read_only(THD* thd)
+inline bool cp_thd_get_global_read_only(THD* thd)
 {
     return false;
 }
@@ -191,15 +204,6 @@ inline bool cp_open_table(THD* thd, TABLE_LIST* tables,
 #define set_mysys_var(A)
 #else
 
-inline void cp_add_global_thread(THD* thd)
-{
-    add_global_thread(thd);
-}
-
-inline void cp_remove_global_thread(THD* thd)
-{
-    remove_global_thread(thd);
-}
 
 inline void cp_thd_release_resources(THD* thd)
 {
@@ -208,7 +212,11 @@ inline void cp_thd_release_resources(THD* thd)
 
 inline void cp_set_mysys_var(st_my_thread_var* var)
 {
+#if(MYSQL_VERSION_NUM < 50700)
     set_mysys_var(var);
+#else
+	set_mysys_thread_var(var);
+#endif
 }
 
 inline void cp_restore_globals(THD* thd)
@@ -216,12 +224,12 @@ inline void cp_restore_globals(THD* thd)
     thd->restore_globals();
 }
 
-inline void cp_thd_set_read_only(THD* thd)
+inline void cp_thd_set_read_only(THD* thd, bool v)
 {
-    thd->tx_read_only = (thd->variables.tx_read_only != 0);
+    thd->tx_read_only = (v || thd->variables.tx_read_only);
 }
 
-inline bool cp_thd_get_read_only(THD* thd)
+inline bool cp_thd_get_global_read_only(THD* thd)
 {
     return (thd->variables.tx_read_only != 0);
 }
@@ -237,32 +245,114 @@ inline bool cp_open_table(THD* thd, TABLE_LIST* tables,
 #define ha_index_read_map index_read_map
 #endif
 
-/* memory management */
-#if ((MYSQL_VERSION_NUM > 50700) && !defined(MARIADB_BASE_VERSION))
+
+extern unsigned int g_openDatabases;
+#if((MYSQL_VERSION_NUM > 50700) && !defined(MARIADB_BASE_VERSION))
+#define OPEN_TABLE_FLAG_TYPE 0
+
 #define td_malloc(A, B) my_malloc(PSI_NOT_INSTRUMENTED, A, B)
 #define td_realloc(A, B, C) my_realloc(PSI_NOT_INSTRUMENTED, A, B, C)
 #define td_strdup(A, B) my_strdup(PSI_NOT_INSTRUMENTED, A, B)
 #define td_free(A) my_free(A)
 
 /* On Windows,
- "operator delete()" function is implemented in mysqld.
- But "operator new" operation implement in transactd.dll.
- Therefore, memory managers differ. */
+"operator delete()" function is implemented in mysqld.
+But "operator new" operation implement in transactd.dll.
+Therefore, memory managers differ. */
 #ifdef _WIN32
 
 inline void releaseTHD(THD* thd)
 {
-    thd->~THD();
-    operator delete((void*)thd);
+	thd->~THD();
+	operator delete((void*)thd);
 }
 #else
 
 inline void releaseTHD(THD* thd)
 {
-    delete thd;
+	delete thd;
 }
 #endif
-#else
+
+#include <boost/thread/mutex.hpp>
+extern boost::mutex g_db_count_mutex;
+extern void global_thd_manager_add_thd(THD *thd);
+extern void global_thd_manager_remove_thd(THD *thd);
+
+inline void  cp_set_new_thread_id(THD* thd) 
+{
+    thd->set_new_thread_id();
+	global_thd_manager_add_thd(thd);
+	boost::mutex::scoped_lock lck(g_db_count_mutex);
+    ++g_openDatabases;
+}
+
+inline void cp_dec_dbcount(THD* thd)
+{
+	{
+		boost::mutex::scoped_lock lck(g_db_count_mutex);
+		--g_openDatabases;
+	}
+	global_thd_manager_remove_thd(thd);
+}
+
+inline Security_context* cp_security_ctx(THD* thd)
+{
+	return thd->security_context();
+}
+
+inline int cp_record_count(handler* file, ha_rows* rows)
+{
+	return file->ha_records(rows);
+}
+
+#define cp_strdup(A, B) my_strdup(PSI_INSTRUMENT_ME, (A), (B))
+#define cp_set_mysys_var(A) set_mysys_thread_var(A)
+inline void cp_set_db(THD* thd, char* p)
+{
+	thd->set_db(to_lex_cstring(p));
+}
+
+
+inline THD* cp_thread_get_THR_THD()
+{
+	return my_thread_get_THR_THD();
+	return NULL;
+}
+
+inline int cp_thread_set_THR_THD(THD* thd)
+{
+	return my_thread_set_THR_THD(thd);
+	return 0;
+}
+
+inline void cp_set_transaction_duration_for_all_locks(THD* /*thd*/)
+{
+	;
+}
+
+inline void cp_set_mdl_request_types(TABLE_LIST& tables, short mode)
+{
+	if (mode == -2 /* TD_OPEN_READONLY */)
+		tables.mdl_request.set_type(MDL_SHARED_READ);
+	else if (mode == -4 /* TD_OPEN_EXCLUSIVE */)
+		tables.mdl_request.set_type(MDL_SHARED_NO_READ_WRITE);
+	else if (mode == -6 /* TD_OPEN_READONLY_EXCLUSIVE */)
+		tables.mdl_request.set_type(MDL_SHARED_READ_ONLY);
+	else
+		tables.mdl_request.set_type(MDL_SHARED_WRITE);
+	
+	tables.mdl_request.duration = MDL_TRANSACTION;
+}
+
+inline void cp_open_error_release(THD* /*thd*/, TABLE_LIST& /*tables*/)
+{
+    ;
+}
+
+#else //Not MySQL 5.7
+#define OPEN_TABLE_FLAG_TYPE MYSQL_OPEN_GET_NEW_TABLE
+
 #define td_malloc(A, B) my_malloc(A, B)
 #define td_realloc(A, B, C) my_realloc(A, B, C)
 #define td_strdup(A, B) my_strdup(A, B)
@@ -270,8 +360,70 @@ inline void releaseTHD(THD* thd)
 
 inline void releaseTHD(THD* thd)
 {
-    delete thd;
+	delete thd;
+}
+inline  void cp_set_new_thread_id(THD* thd)
+{
+    mysql_mutex_lock(&LOCK_thread_count);
+    ++g_openDatabases;
+    thd->variables.pseudo_thread_id = thread_id++;
+	add_global_thread(thd);
+    mysql_mutex_unlock(&LOCK_thread_count);
+    thd->thread_id = thd->variables.pseudo_thread_id;
 }
+inline void cp_dec_dbcount(THD* thd)
+{
+    mysql_mutex_lock(&LOCK_thread_count);
+    --g_openDatabases;
+    mysql_mutex_unlock(&LOCK_thread_count);
+	remove_global_thread(thd);
+}
+inline Security_context* cp_security_ctx(THD* thd)
+{
+	return thd->security_ctx;
+}
+
+inline int cp_record_count(handler* file, ha_rows* rows)
+{
+	*rows = file->records();
+	return 0;
+}
+#define cp_strdup(A, B) my_strdup((A), (B))
+#define cp_set_mysys_var(A) set_mysys_var(A)
+
+inline void cp_set_db(THD* thd, char* p)
+{
+	td_free(thd->db);
+	thd->db = p;
+}
+
+inline THD* cp_thread_get_THR_THD()
+{
+	return (THD*)my_pthread_getspecific(THD*, THR_THD);
+}
+
+inline int cp_thread_set_THR_THD(THD* thd)
+{
+	my_pthread_setspecific_ptr(THR_THD, thd);
+	return 0;
+}
+
+inline void cp_set_transaction_duration_for_all_locks(THD* thd)
+{
+	thd->mdl_context.set_transaction_duration_for_all_locks();
+}
+
+inline void cp_set_mdl_request_types(TABLE_LIST& tables, short mode)
+{
+	tables.mdl_request.set_type(MDL_SHARED_READ);
+    tables.mdl_request.duration = MDL_EXPLICIT;
+}
+
+inline void cp_open_error_release(THD* thd, TABLE_LIST& tables)
+{
+    thd->mdl_context.release_lock(tables.mdl_request.ticket);
+}
+
 #endif
 
 #endif // BZS_DB_ENGINE_MYSQL_MYSQLINTERNAL_H

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

@@ -25,7 +25,13 @@ unsigned int g_openDatabases = 0;
 
 extern unsigned int g_lock_wait_timeout;
 extern char* g_transaction_isolation;
-static unsigned int transaction_isolation_cache = -1;
+static int transaction_isolation_cache = -1;
+
+#if((MYSQL_VERSION_NUM > 50700) && !defined(MARIADB_BASE_VERSION))
+boost::mutex g_db_count_mutex;
+LEX_CSTRING NULL_CSTR = { NULL, 0 };
+#endif
+
 
 #ifdef USETLS
 tls_key g_tlsiID;
@@ -101,7 +107,7 @@ void waitForServerStart()
     mysql_mutex_unlock(&LOCK_server_started);
 }
 
-unsigned int getTransactdIsolation()
+int getTransactdIsolation()
 {
     if (transaction_isolation_cache != -1) 
         return transaction_isolation_cache;
@@ -125,22 +131,19 @@ THD* buildTHD()
         waitForServerStart();
 
     THD* thd = new THD();
-    mysql_mutex_lock(&LOCK_thread_count);
-    thd->variables.pseudo_thread_id = thread_id++;
-    ++g_openDatabases;
-    cp_add_global_thread(thd);
-    mysql_mutex_unlock(&LOCK_thread_count);
-    thd->thread_id = thd->variables.pseudo_thread_id;
+    
+    cp_set_new_thread_id(thd);
+    
     thd->thread_stack = reinterpret_cast<char*>(&thd);
     thd->store_globals();
     assert(thd->mysys_var);
-    set_mysys_var(thd->mysys_var);
+	cp_set_mysys_var(thd->mysys_var);
     thd->system_thread = NON_SYSTEM_THREAD;
     const NET v = { 0 };
     thd->net = v;
 
     thd->variables.option_bits |= OPTION_BIN_LOG;
-    thd->variables.tx_isolation = getTransactdIsolation();
+    thd->variables.tx_isolation = (ulong)getTransactdIsolation();
 
     thd->clear_error();
     char tmp[256];
@@ -148,8 +151,8 @@ THD* buildTHD()
               g_lock_wait_timeout);
     dispatch_command(COM_QUERY, thd, tmp, (uint)strlen(tmp));
 
-    td_free(thd->db);
-    thd->db = td_strdup("bizstation", MYF(0));
+	
+	cp_set_db(thd, td_strdup("bizstation", MYF(0)));
     if (thd->variables.sql_log_bin)
         thd->set_current_stmt_binlog_format_row();
     return thd;
@@ -157,10 +160,10 @@ THD* buildTHD()
 
 THD* attachThd(THD* thd)
 {
-    THD* curThd = my_pthread_getspecific(THD*, THR_THD);
+	THD* curThd = cp_thread_get_THR_THD();
 
-    if (!thd)
-        my_pthread_setspecific_ptr(THR_THD, thd);
+	if (!thd)
+		cp_thread_set_THR_THD(thd);
     else
     {
         initThread(thd);
@@ -168,7 +171,7 @@ THD* attachThd(THD* thd)
         if (curThd != thd)
         {
             thd->store_globals();
-            set_mysys_var(thd->mysys_var);
+			cp_set_mysys_var(thd->mysys_var);
         }
     }
     return curThd;
@@ -186,10 +189,7 @@ THD* createThdForThread()
 void deleteThdForThread(THD* thd)
 {
     cp_restore_globals(thd);
-    mysql_mutex_lock(&LOCK_thread_count);
-    --g_openDatabases;
-    mysql_mutex_unlock(&LOCK_thread_count);
-    cp_thd_release_resources(thd);
-    cp_remove_global_thread(thd);
+	cp_thd_release_resources(thd);
+	cp_dec_dbcount(thd);
     releaseTHD(thd);
 }

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

@@ -147,26 +147,37 @@ pq_handle activeTable::prepare(queryBase& q, bool serverPrepare)
     return m_imple->prepare(q, serverPrepare);
 }
 
+activeTable& activeTable::readMore(recordset& rs)
+{
+    rs.clear();
+    m_imple->readMore(*rs.m_imple);
+    return *this;
+}
+
 activeTable& activeTable::read(recordset& rs, queryBase& q)
 {
+    rs.clear();
     m_imple->read(*rs.m_imple, q);
     return *this;
 }
 
 activeTable& activeTable::read(recordset& rs, queryBase& q, validationFunc func)
 {
+    rs.clear();
     m_imple->read(*rs.m_imple, q, func);
     return *this;
 }
 
 activeTable& activeTable::read(recordset& rs, pq_handle& q)
 {
+    rs.clear();
     m_imple->read(*rs.m_imple, q);
     return *this;
 }
 
 activeTable& activeTable::read(recordset& rs, pq_handle& q, validationFunc func)
 {
+    rs.clear();
     m_imple->read(*rs.m_imple, q, func);
     return *this;
 }

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

@@ -139,7 +139,7 @@ public:
     activeTable& read(recordset& rs, queryBase& q, validationFunc func);
     activeTable& read(recordset& rs, pq_handle& q);
     activeTable& read(recordset& rs, pq_handle& q, validationFunc func);
-
+    activeTable& readMore(recordset& rs);
     /** @cond INTERNAL */
     template<class T0>
     activeTable& read(recordset& rs, pq_handle& q, const T0 v0)

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

@@ -94,9 +94,10 @@ public:
     typedef mdlsHandler<map_orm, recordsetImple> collection_orm_typename;
 };
 
+#define FIXED_VALUE_BUF_SIZE 256
 struct joinInfo
 {
-    std::_tstring fixedValue;
+    unsigned char fixedValue[FIXED_VALUE_BUF_SIZE];
     ushort_td len;
     ushort_td type;
 };
@@ -152,9 +153,15 @@ class activeTableImple : public activeObject<map_orm>
             if (s[0] == '[')
             {
                 fieldIndexes[i] = -1;
+                const fielddef& f = td->fieldDefs[kd->segments[i].fieldNum];
+                if (f.len > FIXED_VALUE_BUF_SIZE)
+                    THROW_BZS_ERROR_WITH_MSG(_T("Join fixed key field is too long")
+                                     _T(" field.\n This field can not use join."));
+                field fd(joinFields[i].fixedValue, f, fds);
+                fd = s.c_str() +1;
+                joinFields[i].len = f.len;
                 joinFields[i].type = JOIN_KEYVALUE_TYPE_PTR;
-                joinFields[i].len = (ushort_td)(s.size() - 2);
-                joinFields[i].fixedValue = s.substr(1, s.size() - 2);
+
             }
             else
             {
@@ -212,7 +219,7 @@ class activeTableImple : public activeObject<map_orm>
         {
             if (fieldIndexes[i] == -1)
             {
-                ptr[i] = (const uchar_td*)joinFields[i].fixedValue.c_str();
+                ptr[i] = joinFields[i].fixedValue;
                 len[i] = joinFields[i].len;
             }
             else if (joinFields[i].type == JOIN_KEYVALUE_TYPE_PTR)

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

@@ -76,7 +76,7 @@ class client
 
     bool checkVersion(trdVersiton& ver)
     {
-        if ((ver.srvMajor < 2) || ((ver.srvMajor == 2) && (ver.srvMinor < 1)))
+        if ((ver.srvMajor < 2) || ((ver.srvMajor == 2) && (ver.srvMinor < 3)))
             return false;
         return true;
     }
@@ -307,6 +307,30 @@ public:
         }
     }
 
+    inline void reconnect()
+    {
+        bzs::netsvc::client::connection* c = con();
+        if (!c)
+        {
+            m_preResult = ERROR_TD_NOT_CONNECTED;
+            return;
+        }
+        std::string host = getHostName((const char*)m_req.keybuf);
+        m_preResult = ERROR_TD_HOSTNAME_NOT_FOUND;
+        if (host == "") return;
+        if (!m_cons->reconnect(c, host, handshakeCallback, this))
+            return;
+        m_connecting = true;
+        if (getServerCharsetIndex() == -1)
+            m_preResult = SERVER_CLIENT_NOT_COMPATIBLE;
+        else
+        {
+            m_preResult = 0;
+            buildDualChasetKeybuf();
+        }
+        m_req.paramMask = P_MASK_KEYONLY;
+    }
+
     inline void cmdConnect()
     {
         if ((m_req.keyNum == LG_SUBOP_CONNECT) ||
@@ -338,7 +362,12 @@ public:
                 m_logout = true;
             else if (m_op == TD_CONNECT)
                 m_preResult = 1;
+        }else if (m_req.keyNum == LG_SUBOP_DISCONNECT_EX)
+        {
+            if (con())
+                con()->cleanup();
         }
+            
         m_req.paramMask = P_MASK_KEYONLY;
     }
 

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

@@ -228,7 +228,7 @@ void dbdef::updateTableDef(short TableIndex, bool forPsqlDdf)
     uchar_td type;
 
     td->optionFlags.bitA = false; // reset valiable type
-
+    td->optionFlags.bitB = false;
     for (i = 0; i < td->fieldCount; ++i)
     {
         ret = fieldNumByName(TableIndex, td->fieldDefs[i].name());
@@ -593,6 +593,7 @@ fielddef* dbdef::insertField(short TableIndex, short InsertIndex)
     fielddef* fd = &(td->fieldDefs[InsertIndex]);
     fd->setCharsetIndex(td->charsetIndex);
     fd->setSchemaCodePage(td->schemaCodePage);
+    fd->setPadCharSettings(false, true);
     return fd;
 }
 

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

@@ -335,7 +335,17 @@ extern "C" PACKAGE_OSX short_td __STDCALL
             break;
         case TD_CONNECT:
         {
-            client_t->cmdConnect();
+            if (client_t->req().keyNum == LG_SUBOP_RECONNECT)
+                client_t->reconnect();
+            else
+                client_t->cmdConnect();
+            if (client_t->req().keyNum == LG_SUBOP_DISCONNECT_EX)
+                return 0;
+            break;
+        }
+        case TD_RECONNECT:
+        {
+            client_t->req().paramMask = P_MASK_ALL;
             break;
         }
         case TD_STASTISTICS:
@@ -367,9 +377,22 @@ extern "C" PACKAGE_OSX short_td __STDCALL
         case 11001:
             ret = ERROR_TD_HOSTNAME_NOT_FOUND;
             break;
+        case 10060:
+        case 10057: //blocking fire wall
+        case 110:   //connect: Connection timed out
+        case 121:   //timeout sema
+        case 11:    //EAGAIN
+            ret = ERROR_TD_NET_TIMEOUT;
+            break;
+        case 32:    //write:brokn pipe
+        case 111:   //connect: Connection refused
         case 10061:
             ret = ERROR_TD_CONNECTION_FAILURE;
             break;
+        case 104:   //write: Connection reset by peer
+        case 10054:
+            ret = ERROR_TD_NET_REMOTE_DISCONNECT;
+            break;
         case 232:
         case 109:
         case 2:
@@ -377,10 +400,12 @@ extern "C" PACKAGE_OSX short_td __STDCALL
             ret = ERROR_TD_INVALID_CLINETHOST;
             break;
         default:
-            ret = e.code().value() + 20000;
+            ret = ERROR_TD_NET_OTHER;
         }
         OutputDebugString(e.what());
-        writeErrorLog(ret, e.what());
+        char tmp[512];
+        sprintf_s(tmp, 512, "%d %s", e.code().value(), e.what());
+        writeErrorLog(ret, tmp);
     }
     catch (bzs::netsvc::client::exception& e)
     {
@@ -390,9 +415,14 @@ extern "C" PACKAGE_OSX short_td __STDCALL
     }
     catch (std::exception& e)
     {
-        ret = 1;
+        ret = ERROR_TD_C_CLIENT_UNKNOWN;
         OutputDebugString(e.what());
-        writeErrorLog(30000, e.what());
+        writeErrorLog(ret, e.what());
+    }
+    catch (...)
+    {
+        ret = ERROR_TD_C_CLIENT_UNKNOWN;
+        writeErrorLog(ret, "Unknown error");
     }
     return ret;
 }