transactd 3.1.0 → 3.2.0

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

@@ -1,5 +1,5 @@
 /*=================================================================
-   Copyright (C) 2013 BizStation Corp All rights reserved.
+   Copyright (C) 2013-2016 BizStation Corp All rights reserved.
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
@@ -32,6 +32,104 @@ namespace tdap
 namespace client
 {
 
+static const _TCHAR* SYSVAR_NAME[TD_VAR_SIZE] =
+{
+    _T("database_version"),
+    _T("transactd_version"),
+    _T("address"),
+    _T("port"),
+    _T("hostcheck_username"),
+    _T("max_tcp_connections"),
+    _T("table_name_lowercase"),
+    _T("pool_threads"),
+    _T("tcp_server_type"),
+    _T("lock_wait_timeout"),
+    _T("transaction_isolation"),
+    _T("auth_type"),
+    _T("pipe_comm_sharemem_size"),
+    _T("max_pipe_connections"),
+    _T("use_piped_local"),
+    _T("hs_port"),
+    _T("use_handlersocket"),
+    _T("timestamp_always)")
+};
+
+static const _TCHAR* SLAVE_STATUS_NAME[SLAVE_STATUS_DEFAULT_SIZE] =
+{
+    _T("Slave_IO_State"),
+    _T("Master_Host"),
+    _T("Master_User"),
+    _T("Master_Port"),
+    _T("Connect_Retry"),
+    _T("Master_Log_File"),
+    _T("Read_Master_Log_Pos"),
+    _T("Relay_Log_File"),
+    _T("Relay_Log_Pos"),
+    _T("Relay_Master_Log_File"),
+    _T("Slave_IO_Running"),
+    _T("Slave_SQL_Running"),
+    _T("Replicate_Do_DB"),
+    _T("Replicate_Ignore_DB"),
+    _T("Replicate_Do_Table"),
+    _T("Replicate_Ignore_Table"),
+    _T("Replicate_Wild_Do_Table"),
+    _T("Replicate_Wild_Ignore_Table"),
+    _T("Last_Errno"),
+    _T("Last_Error"),
+    _T("Skip_Counter"),
+    _T("Exec_Master_Log_Pos"),
+    _T("Relay_Log_Space"),
+    _T("Until_Condition"),
+    _T("Until_Log_File"),
+    _T("Until_Log_Pos"),
+    _T("Master_SSL_Allowed"),
+    _T("Master_SSL_CA_File"),
+    _T("Master_SSL_CA_Path"),
+    _T("Master_SSL_Cert"),
+    _T("Master_SSL_Cipher"),
+    _T("Master_SSL_Key"),
+    _T("Seconds_Behind_Master"),
+    _T("Master_SSL_Verify_Server_Cert"),
+    _T("Last_IO_Errno"),
+    _T("Last_IO_Error"),
+    _T("Last_SQL_Errno"),
+    _T("Last_SQL_Error"),
+    _T("Replicate_Ignore_Server_Ids"),
+    _T("Master_Server_Id" ),
+};
+
+#pragma pack(push, 1)
+pragma_pack1
+struct oldRrecord
+{
+    __int64 conId;                      // 8 byte
+    unsigned int id;                    // 4 byte
+    unsigned short db;                  // 2 byte
+    short type;                         // 2 byte
+    char name[CON_REC_VALUE_SIZE];      // 67 byte
+    union
+    {
+        char status;                    // 1 byte
+        struct
+        {
+            char inTransaction : 1;
+            char inSnapshot : 1;
+            char openNormal : 1;
+            char openReadOnly : 1;
+            char openEx : 1;
+            char openReadOnlyEx : 1;
+            char dummy : 2;
+        };
+    };
+    unsigned int readCount;             // 4 byte
+    unsigned int updCount;              // 4 byte
+    unsigned int delCount;              // 4 byte    
+    unsigned int insCount;              // 4 byte 
+
+};                                      // 32 + 68 = 100
+#pragma pack(pop)
+pragma_pop
+
 connMgr::connMgr(database* db) : nstable(db)
 {
     m_db = db;
@@ -41,20 +139,54 @@ connMgr::connMgr(database* db) : nstable(db)
     m_keylen = sizeof(m_params);
 }
 
-connMgr::~connMgr()
-{
-}
+connMgr::~connMgr() {}
+
 database* connMgr::db() const
 {
     return m_db;
 }
 
-void connMgr::connect(const _TCHAR* uri)
+void connMgr::convertFromOldFormat(bool isInUseTable)
 {
-    m_db->connect(uri, true);
+    if (m_datalen >= sizeof(oldRrecord))
+    {
+        oldRrecord* rec = (oldRrecord*)m_pdata;
+        oldRrecord* end = rec + (m_datalen / sizeof(oldRrecord));
+        int i = 0;
+        while (rec != end)
+        {
+            oldRrecord tmp = *rec;
+            m_records[i].conId =  tmp.conId;
+            m_records[i].id =  tmp.id;
+            m_records[i].db =  tmp.db;
+            m_records[i].type =  tmp.type;
+            strncpy(m_records[i].name, tmp.name, CON_REC_VALUE_SIZE);
+            if (isInUseTable)
+            {
+                m_records[i].readCount =  tmp.readCount;
+                m_records[i].updCount =  tmp.updCount;
+                m_records[i].delCount =  tmp.delCount;
+                m_records[i].insCount =  tmp.insCount;
+            }
+            ++rec;
+            ++i;
+        }
+        m_datalen =  sizeof(connMgr::record) * i;
+    }
+}
+
+bool connMgr::connect(const _TCHAR* uri)
+{
+    bool ret = m_db->connect(uri, true);
     m_stat = m_db->stat();
     if (m_stat == 0)
+    {
         m_uri = uri;
+        btrVersions vs;
+        m_db->getBtrVersion(&vs);
+        m_pluginVer = vs.versions[VER_IDX_PLUGIN];
+    }
+    return ret;
 }
 
 void connMgr::disconnect()
@@ -77,44 +209,88 @@ void connMgr::allocBuffer()
     m_pdata = (void*)&m_records[0];
     memset(m_pdata, 0, m_datalen);
     setIsOpen(true);
-
 }
 
-const connMgr::records& connMgr::getRecords()
+const connMgr::records& connMgr::getRecords(bool isInUseTable)
 {
-    allocBuffer();
     tdap(TD_STASTISTICS);
+    if (m_stat == 0 && *((int*)m_keybuf) != (int)sizeof(connMgr::record))
+        convertFromOldFormat(isInUseTable);
     if (m_stat == 0)
         m_records.resize(m_datalen / sizeof(connMgr::record));
+    else
+        m_records.resize(0);
     return m_records;
 }
 
-const connMgr::records& connMgr::definedDatabases()
+const connMgr::records& connMgr::databases()
 {
     m_keynum = TD_STSTCS_DATABASE_LIST;
+    allocBuffer();
     return getRecords();
 }
 
-const connMgr::records& connMgr::schemaTables(const char* dbname)
+const connMgr::records& connMgr::doDefinedTables(const _TCHAR* dbname, int type)
 {
-    m_keynum = TD_STSTCS_SCHEMA_TABLE_LIST;
+    m_keynum = type;
     allocBuffer();
     char tmp[128];
+#ifdef _UNICODE
+    WideCharToMultiByte(CP_UTF8, 0, dbname,-1, tmp, 128, NULL, NULL);
+#else
     strcpy_s(tmp, 128, dbname);
+#endif
     m_keybuf = tmp;
     m_keylen = 128;
-    tdap(TD_STASTISTICS);
-    if (m_stat == 0)
-        m_records.resize(m_datalen / sizeof(connMgr::record));
+    getRecords();
     m_keybuf = &m_params[0];
     m_keylen = sizeof(m_params);
     return m_records;
+}
 
+const connMgr::records& connMgr::tables(const _TCHAR* dbname)
+{
+    if ((m_pluginVer.majorVersion >= 3) && (m_pluginVer.minorVersion >= 2))
+        return doDefinedTables(dbname, TD_STSTCS_TABLE_LIST);
+    m_stat = STATUS_NOSUPPORT_OP;
+    m_records.resize(0);
+    return m_records;
+}
+
+const connMgr::records& connMgr::views(const _TCHAR* dbname)
+{
+    if ((m_pluginVer.majorVersion >= 3) && (m_pluginVer.minorVersion >= 2))
+        return doDefinedTables(dbname, TD_STSTCS_VIEW_LIST);
+    m_stat = STATUS_NOSUPPORT_OP;
+    m_records.resize(0);
+    return m_records;
+}
+
+const connMgr::records& connMgr::schemaTables(const _TCHAR* dbname)
+{
+    return doDefinedTables(dbname, TD_STSTCS_SCHEMA_TABLE_LIST);
+}
+
+const connMgr::records& connMgr::slaveStatus()
+{
+    if ((m_pluginVer.majorVersion >= 3) && (m_pluginVer.minorVersion >= 2))
+    {
+        m_keynum = TD_STSTCS_SLAVE_STATUS;
+        allocBuffer();
+        getRecords();
+        if (m_records.size() > SLAVE_STATUS_DEFAULT_SIZE)
+            m_records.resize(SLAVE_STATUS_DEFAULT_SIZE);
+        return m_records;
+    }
+    m_stat = STATUS_NOSUPPORT_OP;
+    m_records.resize(0);
+    return m_records;
 }
 
 const connMgr::records& connMgr::sysvars()
 {
     m_keynum = TD_STSTCS_SYSTEM_VARIABLES;
+    allocBuffer();
     return getRecords();
 }
 
@@ -123,26 +299,29 @@ const connMgr::records& connMgr::connections()
     m_keynum = TD_STSTCS_READ;
     m_params[0] = 0;
     m_params[1] = 0;
+    allocBuffer();
     return getRecords();
 }
 
-const connMgr::records& connMgr::databases(__int64 connid)
+const connMgr::records& connMgr::inUseDatabases(__int64 connid)
 {
     m_keynum = TD_STSTCS_READ;
     m_params[0] = connid;
     m_params[1] = -1;
+    allocBuffer();
     return getRecords();
 }
 
-const connMgr::records& connMgr::tables(__int64 connid, int dbid)
+const connMgr::records& connMgr::inUseTables(__int64 connid, int dbid)
 {
     m_keynum = TD_STSTCS_READ;
     m_params[0] = connid;
     m_params[1] = dbid;
-    return getRecords();
+    allocBuffer();
+    return getRecords(true);
 }
 
-void connMgr::disconnectOne(__int64 connid)
+void connMgr::postDisconnectOne(__int64 connid)
 {
     allocBuffer();
     m_keynum = TD_STSTCS_DISCONNECT_ONE;
@@ -151,7 +330,7 @@ void connMgr::disconnectOne(__int64 connid)
     tdap(TD_STASTISTICS);
 }
 
-void connMgr::disconnectAll()
+void connMgr::postDisconnectAll()
 {
     m_keynum = TD_STSTCS_DISCONNECT_ALL;
     tdap(TD_STASTISTICS);
@@ -162,12 +341,37 @@ short_td connMgr::stat()
     return m_stat;
 }
 
-
 connMgr* connMgr::create(database* db)
 {
     return new connMgr(db);
 }
 
+void connMgr::removeSystemDb(connMgr::records& recs)
+{
+    for (int i=(int)recs.size() -1; i >= 0; --i)
+    {
+        if ((strcmp(recs[i].name, "mysql") == 0) ||
+            (strcmp(recs[i].name, "performance_schema")==0) ||
+            (strcmp(recs[i].name, "information_schema")==0) ||
+            (strcmp(recs[i].name, "sys")==0))
+        recs.erase(recs.begin() + i);
+    }
+}
+
+const _TCHAR* connMgr::sysvarName(uint_td index)
+{
+    if (index < TD_VAR_SIZE)
+        return SYSVAR_NAME[index];
+    return _T("");
+}
+
+const _TCHAR* connMgr::slaveStatusName(uint_td index)
+{
+    if (index < SLAVE_STATUS_DEFAULT_SIZE)
+        return SLAVE_STATUS_NAME[index];
+    return _T("");
+}
+
 } // namespace client
 } // namespace tdap
 } // namespace protocol

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

@@ -1,7 +1,7 @@
 #ifndef BZS_DB_PROTOCOL_TDAP_CLIENT_CTDCONNMGR_H
 #define BZS_DB_PROTOCOL_TDAP_CLIENT_CTDCONNMGR_H
 /*=================================================================
-   Copyright (C) 2013 BizStation Corp All rights reserved.
+   Copyright (C) 2013-2016 BizStation Corp All rights reserved.
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
@@ -20,7 +20,9 @@
 =================================================================*/
 #include "nsTable.h"
 #include <bzs/db/transactd/connectionRecord.h>
+#include <boost/shared_ptr.hpp>
 #include <vector>
+#pragma warning(disable : 4251)
 
 namespace bzs
 {
@@ -34,52 +36,76 @@ namespace client
 {
 
 class database;
-#pragma warning(disable : 4251)
+class connMgr;
+typedef boost::shared_ptr<connMgr> connMgr_ptr;
 
-class /*DLLLIB*/ connMgr : private nstable
+class DLLLIB connMgr : private nstable  // no copyable
 {
 public:
     typedef bzs::db::transactd::connection::record record;
     typedef std::vector<record> records;
-
-protected:
 private:
     std::vector<record> m_records;
     __int64 m_params[2];
     database* m_db;
     std::_tstring m_uri;
+    btrVersion m_pluginVer;
     void allocBuffer();
     void writeRecordData(){};
     void onReadAfter(){};
-    const records& getRecords();
+    const records& getRecords(bool isInUseTable = false);
+    void convertFromOldFormat(bool isInUseTable);
     ~connMgr();
+    explicit connMgr(const connMgr& r);  //no copyable
+    connMgr& operator=(const connMgr& r); //no copyable
+    const connMgr::records& doDefinedTables(const _TCHAR* dbname, int type);
+    explicit connMgr(database* db);
 
 public:
-    explicit connMgr(database* db);
 
-    void connect(const _TCHAR* uri);
+    bool connect(const _TCHAR* uri);
     void disconnect();
-    const records& definedDatabases();
-    const records& schemaTables(const char* dbname);
+    const records& databases();
+    const records& tables(const _TCHAR* dbname);
+    const records& views(const _TCHAR* dbname);
+    const records& schemaTables(const _TCHAR* dbname);
+    const records& slaveStatus();
     const records& sysvars();
     const records& connections();
-    const records& databases(__int64 connid);
-    const records& tables(__int64 connid, int dbid);
-    void disconnectOne(__int64 connid);
-    void disconnectAll();
+    const records& inUseDatabases(__int64 connid);
+    const records& inUseTables(__int64 connid, int dbid);
+    void postDisconnectOne(__int64 connid);
+    void postDisconnectAll();
     short_td stat();
-
     database* db() const;
     using nstable::tdapErr;
     using nstable::release;
+    static void removeSystemDb(records& recs);
+    static const _TCHAR* sysvarName(uint_td index);
+    static const _TCHAR* slaveStatusName(uint_td index);
     static connMgr* create(database* db);
 };
 
-#pragma warning(default : 4251)
+/**
+   Releaser for boost shared_ptr.
+   ex : boost::shared_ptr<connMgr> mgr(connMgr::create(), releaseConnMgr);
+*/
+inline void releaseConnMgr(connMgr* p)
+{
+    if (p) p->release();
+}
+
+inline connMgr_ptr createConnMgr(database* db)
+{
+    return connMgr_ptr(connMgr::create(db), releaseConnMgr);
+}
+
 
 } // namespace client
 } // namespace tdap
 } // namespace protocol
 } // namespace db
 } // namespace bzs
+
+#pragma warning(default : 4251)
 #endif // BZS_DB_PROTOCOL_TDAP_CLIENT_CTDCONNMGR_H

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

@@ -56,11 +56,13 @@ struct dbimple
         bool lockReadOnly : 1;
         bool autoSchemaUseNullkey : 1;
         bool noPreloadSchema : 1;
+        bool createExistNoCheck : 1;
     };
     dbimple()
         : dbDef(NULL), optionalData(NULL), m_deleteRecordFn(NULL),
           m_copyDataFn(NULL), openBuflen(0), isOpened(false), isTableReadOnly(false),
-          lockReadOnly(false), autoSchemaUseNullkey(false), noPreloadSchema(false)
+          lockReadOnly(false), autoSchemaUseNullkey(false), noPreloadSchema(false),
+          createExistNoCheck(false)
     {
         rootDir[0] = 0x00;
         memset(&vers, 0 , sizeof(btrVersions));
@@ -121,6 +123,25 @@ void database::release()
     }
 }
 
+database* database::createAssociate()
+{
+    if (isOpened() && !enableTrn())
+    {
+        database* db = database::create();
+        //Copy id
+        memcpy(db->clientID() + 14,  clientID() + 14, 2);
+        db->setAssociate();
+        db->m_btrcallid = m_btrcallid;
+        //Set same connection and connection->addref() in tdclc
+        m_stat = m_btrcallid(TD_CONNECT, NULL, NULL, NULL, (void*)clientID(),
+                         16, LG_SUBOP_ASSOCIATE, db->clientID());
+        if (m_stat == 0)
+            return db;
+        database::destroy(db);
+    }
+    return NULL;
+}
+
 dbdef* database::dbDef() const
 {
     return m_impl->dbDef;
@@ -200,7 +221,7 @@ void database::setAutoSchemaUseNullkey(bool v)
 void database::create(const _TCHAR* uri, short type)
 {
     bool dbdefCreated = false;
-    short stat = 0;
+    short stat;
     if (!m_impl->dbDef)
     {
         m_impl->dbDef = new dbdef(this, type); // Create TabelDef here.
@@ -409,7 +430,6 @@ void database::doOpen(const _TCHAR* uri, short type, short mode,
                       const _TCHAR* ownername)
 {
     m_stat = STATUS_SUCCESS;
-    m_impl->dbDef->setDefType(type);
     m_impl->dbDef->open(uri, (char_td)mode, ownername);
 
     if ((m_stat == STATUS_SUCCESS) &&
@@ -447,23 +467,32 @@ bool database::open(const _TCHAR* _uri, short type, short mode,
             if (m_stat)
                 return false;
         }
-        if (!m_impl->dbDef)
-            m_impl->dbDef = new dbdef(this, type);
 
         if (type == TYPE_SCHEMA_BDF)
         {// BDF
             if (isTransactdUri(_uri))
             {
-                _TCHAR scmtable[256];
-                schemaTable(_uri, scmtable, 256);
-                m_impl->noPreloadSchema = (scmtable[0] == 0x00);
+                _TCHAR name[128];
+                schemaTable(_uri, name, 128);
+                m_impl->noPreloadSchema = (name[0] == 0x00);
+                if (m_impl->noPreloadSchema)
+                    type = TYPE_SCHEMA_BDF_NOPRELOAD;
+                dbname(_uri, name, 128);
+                if (name[0] == 0x00)
+                {
+                    m_stat = ERROR_NO_DATABASE;
+                    return false;
+                }
             }
         }
+        if (!m_impl->dbDef)
+            m_impl->dbDef = new dbdef(this, type);
+
         if (m_impl->noPreloadSchema)
         {
             if ((compatibleMode() & CMP_MODE_MYSQL_NULL) == 0)
                 m_stat = STATUS_INVALID_NULLMODE;
-            else if (connect(_uri))
+            else if (isAssociate() || connect(_uri))
             {
                 m_impl->dbDef->allocDatabuffer();
                 m_stat = m_impl->dbDef->stat();
@@ -777,8 +806,13 @@ struct openTablePrams
             }
             else
                 _tcscpy(uri, path);
-        }else if (path) 
-            db->getTableUri(uri, path);
+        }else if (path)
+        {
+            if (_tcsstr(path, _T("://")))
+                 _tcscpy(uri, path); // another database
+            else
+                db->getTableUri(uri, path);
+        }
     }
 };
 
@@ -981,7 +1015,9 @@ bool database::createTable(const char* utf8Sql)
             const char* p = toServerUri(buf2, MAX_PATH, rootDir(), true);
             uint_td len = (uint_td)strlen(utf8Sql);
             m_stat = m_btrcallid(TD_CREATETABLE, posblk, (void*)utf8Sql, &len,
-                 (void*)p, (uchar_td)strlen(p), CR_SUBOP_BY_SQL , clientID());
+                 (void*)p, (uchar_td)strlen(p),
+                 (m_impl->createExistNoCheck) ?
+                 CR_SUBOP_BY_SQL : CR_SUBOP_BY_SQL_NOCKECK, clientID());
         }
     }
     else
@@ -1011,7 +1047,9 @@ bool database::createTable(short fileNum, const _TCHAR* uri)
         m_stat = m_btrcallid(
             TD_CREATETABLE, posblk, td,
             &m_impl->dbDef->m_datalen, (void*)p, (uchar_td)strlen(p),
-            CR_SUBOP_BY_TABLEDEF /* exists check */, clientID());
+            (m_impl->createExistNoCheck) ?
+                 CR_SUBOP_BY_TABLEDEF : CR_SUBOP_BY_TABLEDEF_NOCKECK,
+                clientID());
     }
     else
     {
@@ -1028,7 +1066,9 @@ bool database::createTable(short fileNum, const _TCHAR* uri)
             buf = uri;
         else
             buf = td->fileName();
-        nsdatabase::createTable(fs, 1024, buf, CR_SUBOP_BY_FILESPEC);
+        nsdatabase::createTable(fs, 1024, buf,
+            (m_impl->createExistNoCheck) ?
+                CR_SUBOP_BY_FILESPEC : CR_SUBOP_BY_FILESPEC_NOCKECK);
         free(fs);
     }
     return (m_stat == 0);
@@ -1042,12 +1082,13 @@ short database::assignSchemaData(const dbdef* src)
     dbdef* defDest = dbDef();
     int recordCount = src->tableCount();
 
-    for (int i = 0; i <= src->tableCount(); i++)
+    for (int i = 1; i <= src->tableCount(); i++)
     {
         const tabledef* td = const_cast<dbdef*>(src)->tableDefs(i);
         if (td)
         {
             tabledef tdtmp = *td;
+            tdtmp.m_inUse = false;
             tdtmp.fieldCount = 0;
             tdtmp.keyCount = 0;
             defDest->insertTable(&tdtmp);
@@ -1148,6 +1189,8 @@ inline void database::copyEachFieldData(table* dest, table* src, fieldChnageInfo
                 int len = fds.len;
                 if (fds.len > fdd.len)
                     len = fdd.len;
+                /* Move 2 byte automaticaly by tabledef::pack() and unpack()
+                   when field type is ft_myfixedbinary  */
                 memcpy(dest->fieldPtr(dindex), src->fieldPtr(i), len);
             }
             else

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

@@ -66,7 +66,7 @@ class DLLLIB database : public nsdatabase
     bool defaultImageCopy(const void* data, short& tableIndex);
     short checkOpened();
     table* doOpenTable(struct openTablePrams* pm, const _TCHAR* ownerName);
-    void* getExtendBufferForOpen(uint_td& size); // orverload
+    void* getExtendBufferForOpen(uint_td& size); // orverride
     _TCHAR* getTableUri(_TCHAR* buf, short fileNum);
     _TCHAR* getTableUri(_TCHAR* buf, const _TCHAR* filename);
     inline void copyEachFieldData(table* dest, table* src, struct fieldChnageInfo* fci);
@@ -130,11 +130,11 @@ public:
                       const _TCHAR* ownerName = NULL);
     bool existsTableFile(short tableIndex, const _TCHAR* ownerName = NULL);
     void getBtrVersion(btrVersions* versions);
-    bool isOpened() const;
+    bool isOpened() const; // orverride
     char_td mode() const;
     bool autoSchemaUseNullkey() const;
     void setAutoSchemaUseNullkey(bool v);
-
+    database* createAssociate();
     virtual int defaultAutoIncSpace() const { return 0; };
     static database* create();
     /* For C++ direct only. don't use by wrapper class for COM or SWIG