transactd 2.3.0 → 2.4.0

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

@@ -49,6 +49,10 @@
 #endif
 #include <my_config.h>
 #include <mysql_version.h>
+#if defined(MARIADB_BASE_VERSION) && (MYSQL_VERSION_ID > 100000)
+#define MARIADDB_10_0 MYSQL_VERSION_ID
+#endif
+
 #include <sql/sql_const.h>
 #include "my_global.h"
 #include <math.h>
@@ -80,9 +84,8 @@ extern "C" {
 #include "sql/sql_cache.h"
 #if (MYSQL_VERSION_ID < 50700)
 #include "sql/structs.h"
-#endif
-
 #include "sql/sql_priv.h"
+#endif
 #include "sql/unireg.h"
 #include "sql/lock.h"
 #include "sql/key.h"
@@ -92,6 +95,7 @@ extern "C" {
 #include "sql/sql_table.h"
 #include "sql/sql_db.h"
 #include "sql_acl.h"
+#include "sql/sql_show.h"
 #include "mysqld_error.h"
 #include <password.h>
 
@@ -135,25 +139,25 @@ extern "C" {
 #define THD_NOT_KILLED NOT_KILLED
 #endif
 
-#if (MYSQL_VERSION_ID < 50600) // MySQL and MariaDB both
+#if (MYSQL_VERSION_ID < 50600) // MySQL and MariaDB both  5.5
 #define user_defined_key_parts key_parts
 #define MDL_SHARED_UPGRADABLE MDL_SHARED_WRITE
 #define cp_get_sql_error() stmt_da->sql_errno()
 #define cp_isOk() stmt_da->is_ok()
 #define cp_set_overwrite_status(A) stmt_da->can_overwrite_status = A
-#elif((MYSQL_VERSION_NUM > 50700) && !defined(MARIADB_BASE_VERSION))
+#elif((MYSQL_VERSION_NUM > 50700) && !defined(MARIADB_BASE_VERSION)) // MySQL 5.7
 #define cp_get_sql_error() get_stmt_da()->mysql_errno()
 #define query_cache_invalidate3(A, B, C) query_cache.invalidate(A, B, C)
 #define cp_isOk() get_stmt_da()->is_ok()
 #define cp_set_overwrite_status(A) get_stmt_da()->set_overwrite_status(A)
-#else
+#else                                                               // MySQL 5.6 Mariadb 10.0
 #define cp_get_sql_error() get_stmt_da()->sql_errno()
 #define cp_isOk() get_stmt_da()->is_ok()
 #define cp_set_overwrite_status(A) get_stmt_da()->set_overwrite_status(A)
 
 #endif
 
-#if (MYSQL_VERSION_NUM < 50600) // MySQL Only
+#if (MYSQL_VERSION_NUM < 50600) // MySQL 5.5 Only
 #define ha_index_next index_next
 #define ha_index_prev index_prev
 #define ha_index_first index_first
@@ -161,6 +165,15 @@ extern "C" {
 #define ha_index_next_same index_next_same
 #define ha_rnd_next rnd_next
 #define ha_rnd_pos rnd_pos
+#   if (MYSQL_VERSION_NUM >= 50544)
+#       define FINDFILE_6PRAMS
+#   endif
+#endif // MySQL 5.5 Only
+
+#if ((MYSQL_VERSION_NUM > 50600) && (MYSQL_VERSION_NUM < 50700)) // MySQL 5.6 Only
+#   if (MYSQL_VERSION_NUM >= 50625)
+#       define FINDFILE_6PRAMS
+#   endif
 #endif
 
 #if ((MYSQL_VERSION_NUM < 50600) || defined(MARIADB_BASE_VERSION))
@@ -407,7 +420,7 @@ 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();
@@ -423,7 +436,66 @@ inline void cp_open_error_release(THD* thd, TABLE_LIST& tables)
 {
     thd->mdl_context.release_lock(tables.mdl_request.ticket);
 }
+*/
+
+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);
+	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)
+{
+   
+}
+
+
+#endif
+
+/* find_files is static function in maridb. 
+   make_db_list function is not static, but it is not list in sql_show.h.  
+*/
+
+#ifdef MARIADDB_10_0
+    typedef Dynamic_array<LEX_STRING*> SQL_Strings;
+    typedef struct st_lookup_field_values
+    {
+        LEX_STRING db_value, table_value;
+        bool wild_db_value, wild_table_value;
+    } LOOKUP_FIELD_VALUES;
+
+    extern int make_db_list(THD *thd, Dynamic_array<LEX_STRING*> *files,
+                 LOOKUP_FIELD_VALUES *lookup_field_vals);
+    inline int db_list(THD *thd, SQL_Strings *files)
+    {
+        LOOKUP_FIELD_VALUES lv;
+        memset(&lv, 0 ,sizeof(LOOKUP_FIELD_VALUES));
+        return make_db_list(thd, files, &lv);
+    }
+#else
+    typedef List<LEX_STRING> SQL_Strings;
+    inline int db_list(THD *thd, SQL_Strings *files)
+    {
+#ifdef FINDFILE_6PRAMS
+        MEM_ROOT tmp_mem_root;
+        init_sql_alloc(&tmp_mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
+        return find_files(thd, files, NullS,  mysql_data_home, "", true, &tmp_mem_root);
+#else
+        return find_files(thd, files, NullS,  mysql_data_home, "", true);
+#endif        
+    }
 #endif
 
 #endif // BZS_DB_ENGINE_MYSQL_MYSQLINTERNAL_H

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

@@ -213,8 +213,12 @@ public:
         return m_dbExec->commandExec(m_requests, nw);
     }
     void cleanup(){};
+
     bool isShutDown() { return m_dbExec->isShutDown(); }
-    const engine::mysql::databases& dbs() const { return m_dbExec->dbs(); };
+    
+    const engine::mysql::databases& dbs() const { return m_dbExec->dbs(); }
+    
+    boost::mutex& mutex() { return m_dbExec->mutex(); }
 };
 
 } // namespace hs

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

@@ -49,13 +49,27 @@ activeTable::activeTable(dbmanager_ptr& mgr, const _TCHAR* tableName)
 {
 }
 
-activeTable::activeTable(database_ptr& db, const _TCHAR* tableName)
-    : m_imple(new activeTableImple(db, tableName))
+activeTable::activeTable(database_ptr& db, const _TCHAR* tableName,
+                                            short mode)
+    : m_imple(new activeTableImple(db, tableName, mode))
 {
 }
 
-activeTable::activeTable(database* db, const _TCHAR* tableName)
-    : m_imple(new activeTableImple(db, tableName))
+activeTable::activeTable(database* db, const _TCHAR* tableName,
+                                            short mode)
+    : m_imple(new activeTableImple(db, tableName, mode))
+{
+}
+
+activeTable::activeTable(database_ptr& db, short tableIndex,
+                                            short mode)
+    : m_imple(new activeTableImple(db, tableIndex, mode))
+{
+}
+
+activeTable::activeTable(database* db, short tableIndex,
+                                            short mode)
+    : m_imple(new activeTableImple(db, tableIndex, mode))
 {
 }
 
@@ -192,14 +206,24 @@ activeTable* activeTable::create(dbmanager_ptr& mgr, const _TCHAR* tableName)
     return new activeTable(mgr, tableName);
 }
 
-activeTable* activeTable::create(database_ptr& db, const _TCHAR* tableName)
+activeTable* activeTable::create(database_ptr& db, const _TCHAR* tableName, short mode)
+{
+    return new activeTable(db, tableName, mode);
+}
+
+activeTable* activeTable::create(database* db, const _TCHAR* tableName, short mode)
+{
+    return new activeTable(db, tableName, mode);
+}
+
+activeTable* activeTable::create(database_ptr& db, short tableIndex, short mode)
 {
-    return new activeTable(db, tableName);
+    return new activeTable(db, tableIndex, mode);
 }
 
-activeTable* activeTable::create(database* db, const _TCHAR* tableName)
+activeTable* activeTable::create(database* db, short tableIndex, short mode)
 {
-    return new activeTable(db, tableName);
+    return new activeTable(db, tableIndex, mode);
 }
 
 void activeTable::release()

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

@@ -94,8 +94,14 @@ class DLLLIB activeTable
 public:
     explicit activeTable(idatabaseManager* mgr, const _TCHAR* tableName);
     explicit activeTable(dbmanager_ptr& mgr, const _TCHAR* tableName);
-    explicit activeTable(database_ptr& db, const _TCHAR* tableName);
-    explicit activeTable(database* db, const _TCHAR* tableName);
+    explicit activeTable(database_ptr& db, const _TCHAR* tableName,
+                                            short mode = TD_OPEN_NORMAL);
+    explicit activeTable(database* db, const _TCHAR* tableName,
+                                            short mode = TD_OPEN_NORMAL);
+    explicit activeTable(database_ptr& db, short tableIndex,
+                                            short mode = TD_OPEN_NORMAL);
+    explicit activeTable(database* db, short tableIndex,
+                                            short mode = TD_OPEN_NORMAL);
 
     ~activeTable();
 
@@ -319,8 +325,15 @@ public:
 
     static activeTable* create(idatabaseManager* mgr, const _TCHAR* tableName);
     static activeTable* create(dbmanager_ptr& mgr, const _TCHAR* tableName);
-    static activeTable* create(database_ptr& db, const _TCHAR* tableName);
-    static activeTable* create(database* db, const _TCHAR* tableName);
+    static activeTable* create(database_ptr& db, const _TCHAR* tableName,
+                                                short mode = TD_OPEN_NORMAL);
+    static activeTable* create(database* db, const _TCHAR* tableName,
+                                                short mode = TD_OPEN_NORMAL);
+    static activeTable* create(database_ptr& db, short tableIndex,
+                                                short mode = TD_OPEN_NORMAL);
+    static activeTable* create(database* db, short tableIndex,
+                                                short mode = TD_OPEN_NORMAL);
+
     void release();
     void releaseTable();
 };

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

@@ -360,11 +360,17 @@ public:
     explicit activeTableImple(idatabaseManager* mgr, const _TCHAR* tableName)
         : baseClass_type(mgr, tableName), m_record(NULL){};
 
-    explicit activeTableImple(database_ptr& db, const _TCHAR* tableName)
-        : baseClass_type(db, tableName), m_record(NULL){};
+    explicit activeTableImple(database_ptr& db, const _TCHAR* tableName, short mode)
+        : baseClass_type(db, tableName, mode), m_record(NULL){};
 
-    explicit activeTableImple(database* db, const _TCHAR* tableName)
-        : baseClass_type(db, tableName), m_record(NULL){};
+    explicit activeTableImple(database* db, const _TCHAR* tableName, short mode)
+        : baseClass_type(db, tableName, mode), m_record(NULL){};
+
+    explicit activeTableImple(database_ptr& db, short tableIndex, short mode)
+        : baseClass_type(db, tableIndex, mode), m_record(NULL){};
+
+    explicit activeTableImple(database* db, short tableIndex, short mode)
+        : baseClass_type(db, tableIndex, mode), m_record(NULL){};
 
     ~activeTableImple()
     {

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

@@ -41,6 +41,48 @@ tls_key g_tlsiID;
 __THREAD client* __THREAD_BCB g_client = NULL;
 #endif
 
+#if defined(__BCPLUSPLUS__)
+#pragma warn -8004
+#endif
+short errorCode(const boost::system::error_code& e)
+{
+    short ret = 0;
+    switch (e.value())
+    {
+    case 11004:
+    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:
+    case 1:
+        ret = ERROR_TD_INVALID_CLINETHOST;
+        break;
+    default:
+        ret = ERROR_TD_NET_OTHER;
+    }
+    return ret;
+}
+#if defined(__BCPLUSPLUS__)
+#pragma warn .8004
+#endif
 
 int client::getServerCharsetIndex()
 {
@@ -68,13 +110,16 @@ int client::getServerCharsetIndex()
     char* p = con()->sendBuffer(m_req.sendLenEstimate());
     unsigned int size = req.serialize(p);
     p = con()->asyncWriteRead(size);
-    req.parse(p, false);
-    if (req.result == 0)
+    if (!con()->error())
     {
-        if (!checkVersion(ver))
-            return -1;
-        c->setCharsetServer(mysql::charsetIndex(ver.cherserServer));
-        return  c->charsetServer();
+        req.parse(p, false);
+        if (req.result == 0 && req.resultLen)
+        {
+            if (!checkVersion(ver))
+                return -1;
+            c->setCharsetServer(mysql::charsetIndex(ver.cherserServer));
+            return  c->charsetServer();
+        }
     }
     return -1;
 }

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

@@ -53,6 +53,14 @@ namespace client
 class client;
 void setClientThread(client* v);
 
+#define PORT_BUFSIZE 16
+
+struct endpoint_t
+{
+    char host[MAX_PATH];
+    char port[PORT_BUFSIZE];
+};
+
 /* client class 
 This instance is created for each thread.
 */
@@ -107,6 +115,12 @@ class client
         return hostName(uri, tmp, MAX_PATH);
     }
 
+    endpoint_t* endPoint(const char* uri, endpoint_t* ep)
+    {
+        tdap::endPoint(uri, ep->host, MAX_PATH, ep->port, PORT_BUFSIZE);
+        return ep;
+    }
+
     std::string getTableName(const char* uri)
     {
         if (uri)
@@ -134,6 +148,7 @@ class client
     {
         //Implements handshake here
         handshale_t* hst  = (handshale_t*)c->read();
+        if (c->error()) return false;
         bool auth = (hst->size == sizeof(handshale_t));
         bool min = (hst->size == (sizeof(handshale_t) 
          									-  sizeof(hst->scramble)));
@@ -238,10 +253,11 @@ public:
     {
         if (!m_req.cid->con)
         {
-            std::string host = getHostName((const char*)m_req.keybuf);
-            if (host == "")
+            endpoint_t ep;
+            endPoint((const char*)m_req.keybuf, &ep);
+            if (ep.host[0] == 0x00)
                 m_preResult = ERROR_TD_HOSTNAME_NOT_FOUND;
-            bzs::netsvc::client::connection* c = m_cons->connect(host, 
+            bzs::netsvc::client::connection* c = m_cons->connect(ep.host, ep.port,
                                                   client::handshakeCallback, this);
             if (c)
             {
@@ -315,11 +331,17 @@ public:
             m_preResult = ERROR_TD_NOT_CONNECTED;
             return;
         }
-        std::string host = getHostName((const char*)m_req.keybuf);
+        endpoint_t ep;
+        endPoint((const char*)m_req.keybuf, &ep);
+     
         m_preResult = ERROR_TD_HOSTNAME_NOT_FOUND;
-        if (host == "") return;
-        if (!m_cons->reconnect(c, host, handshakeCallback, this))
+        if (ep.host[0] == 0x00) return;
+
+        if (!m_cons->reconnect(c, ep.host, ep.port, handshakeCallback, this))
+        {
+            m_preResult = errorCode(m_cons->connectError());
             return;
+        }
         m_connecting = true;
         if (getServerCharsetIndex() == -1)
             m_preResult = SERVER_CLIENT_NOT_COMPATIBLE;
@@ -338,23 +360,29 @@ public:
         {
             if (con())
                 disconnect();
-            std::string host = getHostName((const char*)m_req.keybuf);
-            if (host == "")
+            endpoint_t ep;
+            endPoint((const char*)m_req.keybuf, &ep);
+            if (ep.host[0] == 0x00)
                 m_preResult = ERROR_TD_HOSTNAME_NOT_FOUND;
             bzs::netsvc::client::connection* c = m_cons->connect(
-                host, handshakeCallback, this,
+                ep.host, ep.port, handshakeCallback, this,
                 (m_req.keyNum == LG_SUBOP_NEWCONNECT));
             if (c)
             {
                 setCon(c); // if error throw exception
                 m_connecting = true;
                 if (getServerCharsetIndex() == -1)
-                    m_preResult = SERVER_CLIENT_NOT_COMPATIBLE;
+                {
+                    if (c->error() || (m_req.resultLen == 0))
+                        m_preResult = ERROR_TD_INVALID_CLINETHOST;
+                    else
+                        m_preResult = SERVER_CLIENT_NOT_COMPATIBLE;
+                }
                 else
                     buildDualChasetKeybuf();
             }
             else
-                m_preResult = ERROR_TD_HOSTNAME_NOT_FOUND;
+                m_preResult = errorCode(m_cons->connectError());
         }
         else if (m_req.keyNum == LG_SUBOP_DISCONNECT)
         {
@@ -395,11 +423,13 @@ public:
                         c->setDirectReadHandler(&m_req);
                         p = c->asyncWriteRead(size);
                         c->setDirectReadHandler(NULL);
+                        if (c->error()) return errorCode(c->error());
                     }else
                     {
                         if (m_req.paramMask & P_MASK_DATALEN)
                             c->setReadBufferSizeIf(*m_req.datalen);
                         p = c->asyncWriteRead(size);
+                        if (c->error()) return errorCode(c->error());
                         m_req.parse(p, ex);
                     }
                 }

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

@@ -35,6 +35,10 @@ namespace client
 connMgr::connMgr(database* db) : nstable(db)
 {
     m_db = db;
+    m_keybuf = &m_params[0];
+    m_params[0] = 0;
+    m_params[1] = 0;
+    m_keylen = sizeof(m_params);
 }
 
 connMgr::~connMgr()
@@ -73,48 +77,74 @@ void connMgr::allocBuffer()
     m_pdata = (void*)&m_records[0];
     memset(m_pdata, 0, m_datalen);
     setIsOpen(true);
-    m_keybuf = &m_params[0];
-    m_params[0] = 0;
-    m_params[1] = 0;
-    m_keylen = sizeof(m_params);
+
 }
 
-const connMgr::records& connMgr::connections()
+const connMgr::records& connMgr::getRecords()
 {
     allocBuffer();
-    m_keynum = TD_STSTCS_READ;
     tdap(TD_STASTISTICS);
     if (m_stat == 0)
         m_records.resize(m_datalen / sizeof(connMgr::record));
     return m_records;
 }
 
-const connMgr::records& connMgr::databases(__int64 connid)
+const connMgr::records& connMgr::definedDatabases()
 {
+    m_keynum = TD_STSTCS_DATABASE_LIST;
+    return getRecords();
+}
+
+const connMgr::records& connMgr::schemaTables(const char* dbname)
+{
+    m_keynum = TD_STSTCS_SCHEMA_TABLE_LIST;
     allocBuffer();
-    m_keynum = TD_STSTCS_READ;
-    m_params[0] = connid;
-    m_params[1] = -1;
+    char tmp[128];
+    strcpy_s(tmp, 128, dbname);
+    m_keybuf = tmp;
+    m_keylen = 128;
     tdap(TD_STASTISTICS);
     if (m_stat == 0)
         m_records.resize(m_datalen / sizeof(connMgr::record));
+    m_keybuf = &m_params[0];
+    m_keylen = sizeof(m_params);
     return m_records;
+
+}
+
+const connMgr::records& connMgr::sysvars()
+{
+    m_keynum = TD_STSTCS_SYSTEM_VARIABLES;
+    return getRecords();
+}
+
+const connMgr::records& connMgr::connections()
+{
+    m_keynum = TD_STSTCS_READ;
+    m_params[0] = 0;
+    m_params[1] = 0;
+    return getRecords();
+}
+
+const connMgr::records& connMgr::databases(__int64 connid)
+{
+    m_keynum = TD_STSTCS_READ;
+    m_params[0] = connid;
+    m_params[1] = -1;
+    return getRecords();
 }
 
 const connMgr::records& connMgr::tables(__int64 connid, int dbid)
 {
-    allocBuffer();
     m_keynum = TD_STSTCS_READ;
     m_params[0] = connid;
     m_params[1] = dbid;
-    tdap(TD_STASTISTICS);
-    if (m_stat == 0)
-        m_records.resize(m_datalen / sizeof(connMgr::record));
-    return m_records;
+    return getRecords();
 }
 
 void connMgr::disconnectOne(__int64 connid)
 {
+    allocBuffer();
     m_keynum = TD_STSTCS_DISCONNECT_ONE;
     record& rec = m_records[0];
     rec.conId = connid;
@@ -132,6 +162,12 @@ short_td connMgr::stat()
     return m_stat;
 }
 
+
+connMgr* connMgr::create(database* db)
+{
+    return new connMgr(db);
+}
+
 } // namespace client
 } // namespace tdap
 } // namespace protocol

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

@@ -51,7 +51,7 @@ private:
     void allocBuffer();
     void writeRecordData(){};
     void onReadAfter(){};
-
+    const records& getRecords();
     ~connMgr();
 
 public:
@@ -59,6 +59,9 @@ public:
 
     void connect(const _TCHAR* uri);
     void disconnect();
+    const records& definedDatabases();
+    const records& schemaTables(const char* dbname);
+    const records& sysvars();
     const records& connections();
     const records& databases(__int64 connid);
     const records& tables(__int64 connid, int dbid);
@@ -68,6 +71,8 @@ public:
 
     database* db() const;
     using nstable::tdapErr;
+    using nstable::release;
+    static connMgr* create(database* db);
 };
 
 #pragma warning(default : 4251)