transactd 2.1.0 → 2.2.0

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

@@ -74,7 +74,7 @@ public:
 std::string smartDbsReopen::removeName = "";
 
 
-dbManager::dbManager() : m_autoHandle(0)
+dbManager::dbManager() : m_autoHandle(0), m_authChecked(false)
 {
 }
 
@@ -139,7 +139,13 @@ database* dbManager::useDataBase(int id) const
 
 database* dbManager::createDatabase(const char* dbname, short cid) const
 {
-    return new database(dbname, cid);
+    database* db = new database(dbname, cid);
+    if (m_authChecked)
+    {
+        if (m_host != "")
+            db->setGrant(m_host.c_str(), m_user.c_str());
+    }
+    return db;
 }
 
 handle* dbManager::getHandle(int handle) const
@@ -149,7 +155,9 @@ handle* dbManager::getHandle(int handle) const
         if (m_handles[i].id == handle)
             return &m_handles[i];
     }
-    THROW_BZS_ERROR_WITH_CODEMSG(1, "Invalid handle.");
+    char tmp[256];
+    sprintf(tmp, "Invalid handle. handle = %d", handle);
+    THROW_BZS_ERROR_WITH_CODEMSG(1, tmp);
 }
 
 int dbManager::getDatabaseID(short cid) const
@@ -166,21 +174,26 @@ database* dbManager::getDatabaseCid(short cid) const
 {
     int id = getDatabaseID(cid);
     if (id == -1)
-        THROW_BZS_ERROR_WITH_CODEMSG(1, "Can not create database object.");
-
+    {
+        char tmp[256];
+        sprintf(tmp, "Can not get database object. cid = %d", cid);
+        THROW_BZS_ERROR_WITH_CODEMSG(1, tmp);
+    }
     return useDataBase(id);
 }
 
-database* dbManager::getDatabase(const char* dbname, short cid) const
+database* dbManager::getDatabase(const char* dbname, short cid, bool& created) const
 {
+    created = false;
     int id = getDatabaseID(cid);
     if (id == -1)
     {
         boost::shared_ptr<database> db(createDatabase(dbname, cid));
         if (db == NULL)
             THROW_BZS_ERROR_WITH_CODEMSG(1, "Can not create database object.");
+        id = (int)m_dbs.size();
         m_dbs.push_back(db);
-        id = (int)m_dbs.size() - 1;
+        created = true;
     }
     return useDataBase(id);
 }
@@ -188,10 +201,12 @@ database* dbManager::getDatabase(const char* dbname, short cid) const
 table* dbManager::getTable(int hdl, enum_sql_command cmd, engine::mysql::rowLockMode* lck) const
 {
     handle* h = getHandle(hdl);
-    if (h && (h->db < (int)m_dbs.size()))
+    if ((h->db < (int)m_dbs.size()))
         return useDataBase(h->db)->useTable(h->tb, cmd, lck);
 
-    THROW_BZS_ERROR_WITH_CODEMSG(1, "Invalid handle.");
+    char tmp[256];
+    sprintf(tmp, "Invalid handle. handle = %d db = %d tb = %d", hdl, h->db, h->tb);
+    THROW_BZS_ERROR_WITH_CODEMSG(1, tmp);
 }
 
 int dbManager::addHandle(int dbid, int tableid, int assignid)
@@ -210,8 +225,8 @@ int dbManager::ddl_execSql(THD* thd, const std::string& sql_stmt)
     thd->clear_error();
     int result = dispatch_command(COM_QUERY, thd, (char*)sql_stmt.c_str(),
                                   (uint)sql_stmt.size());
-    if (!thd->cp_isOk())
-        result = 1;
+    //if (!thd->cp_isOk())
+    //    result = 1;
     if (thd->is_error())
         result = errorCode(thd->cp_get_sql_error());
     return result;
@@ -270,6 +285,13 @@ int dbManager::ddl_dropTable(database* db, const std::string& tbname,
     return ddl_execSql(db->thd(), cmd);
 }
 
+int dbManager::ddl_addIndex(database* db, const std::string& tbname,
+                        const std::string& cmd)
+{
+    std::string c = "ALTER TABLE `" + db->name() + "`." + cmd;
+    return ddl_execSql(db->thd(), c);
+}
+
 int dbManager::ddl_renameTable(database* db, const std::string& oldName,
                                const std::string& dbSqlName,
                                const std::string& oldSqlName,

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

@@ -58,11 +58,14 @@ protected:
     mutable std::vector<handle> m_handles;
 
     table* m_tb;
+    std::string m_user;
+    std::string m_host;
+    bool m_authChecked;
 
     database* createDatabase(const char* dbname, short cid) const;
     void releaseDatabase(short cid);
     handle* getHandle(int handle) const;
-    database* getDatabase(const char* dbname, short cid) const;
+    database* getDatabase(const char* dbname, short cid, bool& created) const;
     database* getDatabaseCid(short cid) const;
     int getDatabaseID(short cid) const;
     table* getTable(int handle, enum_sql_command cmd = SQLCOM_SELECT, engine::mysql::rowLockMode* lck=NULL) const;
@@ -78,6 +81,8 @@ protected:
     int ddl_dropTable(database* db, const std::string& tbname,
                       const std::string& sqldbname,
                       const std::string& sqltbname);
+    int ddl_addIndex(database* db, const std::string& tbname,
+                        const std::string& cmd);
     int ddl_renameTable(database* db, const std::string& oldName,
                         const std::string& dbSqlName,
                         const std::string& oldSqlName,

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

@@ -89,6 +89,18 @@ extern char msg[1024];
 #define DEBUG_RECORDS_END(WRITER)
 #endif
 
+
+#ifdef DEBUG_LOG_ERR
+#define DEBUG_ERROR_MEMDUMP(RESULT, MSG, PTR, SIZE)                            \
+    if (RESULT)                                                                \
+    {                                                                          \
+        char tmp[50];                                                          \
+        sprintf(tmp, "error %d", RESULT);                                      \
+        ((debugdb*)debuglog::get())->writeDump(tmp, (const char*)PTR, SIZE);   \
+    }
+#else
+#define DEBUG_ERROR_MEMDUMP(RESULT, MSG, PTR, SIZE)
+#endif
 } // namespace mysql
 } // namespace engine
 } // namespace db

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

@@ -50,9 +50,11 @@
 #endif
 
 #include <my_config.h>
-#include <mysql/plugin.h>
 #include <mysql_version.h>
 #include <sql/sql_const.h>
+#include "my_global.h"
+#include "sql/sql_class.h"
+#include <mysql/plugin.h>
 #include "sql/mysqld.h"
 
 #if ((MYSQL_VERSION_ID >= 50600) && !defined(MARIADB_BASE_VERSION))
@@ -63,11 +65,9 @@
 #include "sql/sql_cache.h"
 #include "sql/structs.h"
 #include "sql/sql_priv.h"
-#include "sql/sql_class.h"
 #include "sql/unireg.h"
 #include "sql/lock.h"
 #include "sql/key.h"
-#include "my_global.h"
 #include "sql/transaction.h"
 #include "sql/sql_base.h"
 #include "sql/sql_parse.h"
@@ -75,6 +75,13 @@
 #include "sql/sql_db.h"
 #include "sql_acl.h"
 #include "mysqld_error.h"
+#include <password.h>
+
+/* mysql.user password field index */
+#ifndef MYSQL_USER_FIELD_PASSWORD
+#define MYSQL_USER_FIELD_PASSWORD 2
+#endif
+
 
 #if ((MYSQL_VERSION_ID > 50700) && !defined(MARIADB_BASE_VERSION))
 #include "sql/log.h"

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

@@ -25,6 +25,7 @@ unsigned int g_openDatabases = 0;
 
 extern unsigned int g_lock_wait_timeout;
 extern char* g_transaction_isolation;
+static unsigned int transaction_isolation_cache = -1;
 
 #ifdef USETLS
 tls_key g_tlsiID;
@@ -100,6 +101,24 @@ void waitForServerStart()
     mysql_mutex_unlock(&LOCK_server_started);
 }
 
+unsigned int getTransactdIsolation()
+{
+    if (transaction_isolation_cache != -1) 
+        return transaction_isolation_cache;
+    else if (strcmp(g_transaction_isolation, "READ-COMMITTED") == 0)
+        return transaction_isolation_cache = ISO_READ_COMMITTED;
+    else if (strcmp(g_transaction_isolation, "REPEATABLE-READ") == 0)
+        return transaction_isolation_cache = ISO_REPEATABLE_READ;
+    else if (strcmp(g_transaction_isolation, "SERIALIZABLE") == 0)
+        return transaction_isolation_cache = ISO_SERIALIZABLE;
+    return transaction_isolation_cache = ISO_READ_UNCOMMITTED;
+}
+
+unsigned int getTransactdLockWaitTimeout()
+{
+    return g_lock_wait_timeout;
+}
+
 THD* buildTHD()
 {
     if (!mysqld_server_started)
@@ -121,14 +140,7 @@ THD* buildTHD()
     thd->net = v;
 
     thd->variables.option_bits |= OPTION_BIN_LOG;
-    if (strcmp(g_transaction_isolation, "READ-COMMITTED") == 0)
-        thd->variables.tx_isolation = ISO_READ_COMMITTED;
-    else if (strcmp(g_transaction_isolation, "REPEATABLE-READ") == 0)
-        thd->variables.tx_isolation = ISO_REPEATABLE_READ;
-    else if (strcmp(g_transaction_isolation, "READ-UNCOMMITTED") == 0)
-        thd->variables.tx_isolation = ISO_READ_UNCOMMITTED;
-    else if (strcmp(g_transaction_isolation, "SERIALIZABLE") == 0)
-        thd->variables.tx_isolation = ISO_SERIALIZABLE;
+    thd->variables.tx_isolation = getTransactdIsolation();
 
     thd->clear_error();
     char tmp[256];

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

@@ -305,13 +305,18 @@ int dbExecuter::commandExec(std::vector<request>& requests,
         case HS_OP_OPEN:
         {
             checkNewHandle(req.handle);
-            database* db = getDatabase(req.db.name, 0 /*cid*/);
+            bool created;
+            database* db = getDatabase(req.db.name, 0 /*cid*/, created);
             m_tb = db->openTable(req.table.name, req.table.openMode, NULL);
-            addHandle(getDatabaseID(0 /*cid*/), m_tb->id(), req.handle);
-            m_tb = getTable(req.handle);
-            m_tb->setUseFieldList(req.table.fields);
-            m_tb->setKeyNum(req.table.key.name);
-            writeStatus(m_tb->stat(), buf, 1);
+            if (m_tb)
+            {
+                addHandle(getDatabaseID(0 /*cid*/), m_tb->id(), req.handle);
+                m_tb = getTable(req.handle);
+                m_tb->setUseFieldList(req.table.fields);
+                m_tb->setKeyNum(req.table.key.name);
+                writeStatus(m_tb->stat(), buf, 1);
+            }else
+                writeStatus(db->stat(), buf, 1);
             break;
         }
         case HS_OP_INSERT:
@@ -565,7 +570,7 @@ inline void setFilterVal(const std::string& src, int& parseMode, request* req)
     parseMode = PARSEREAD_FL_TYPE;
 }
 
-commandExecuter::commandExecuter(__int64 /*parent*/)
+commandExecuter::commandExecuter(netsvc::server::IAppModule* /*mod*/)
     : m_dbExec(new dbExecuter())
 {
 }

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

@@ -203,7 +203,7 @@ class commandExecuter : public ICommandExecuter,
     mutable std::vector<request> m_requests;
 
 public:
-    commandExecuter(__int64 parent);
+    commandExecuter(netsvc::server::IAppModule* mod);
     ~commandExecuter();
     size_t perseRequestEnd(const char* p, size_t size, bool& comp) const;
     size_t getAcceptMessage(char* message, size_t size) { return 0; };

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

@@ -258,6 +258,7 @@ class activeTableImple : public activeObject<map_orm>
     template <class Container>
     void doJoin(bool innner, Container& mdls, pq_handle& stmt, const _TCHAR* fns[8], int fnsCount)
     {
+        if (mdls.size() == 0) return;
         stmt->clearSeeks();
         mraResetter mras(m_tb);
         typename Container::iterator it = mdls.begin(), ite = mdls.end();

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

@@ -41,12 +41,6 @@ tls_key g_tlsiID;
 __THREAD client* __THREAD_BCB g_client = NULL;
 #endif
 
-bool checkVersion(trdVersiton& ver)
-{
-    if ((ver.srvMajor < 2) || ((ver.srvMajor == 2) && (ver.srvMinor < 1)))
-        return false;
-    return true;
-}
 
 int client::getServerCharsetIndex()
 {
@@ -65,7 +59,6 @@ int client::getServerCharsetIndex()
     ver.clMajor = (ushort_td)atoi(C_INTERFACE_VER_MAJOR);
     ver.clMinor = (ushort_td)atoi(C_INTERFACE_VER_MINOR);
     ver.clRelease = (ushort_td)atoi(C_INTERFACE_VER_RELEASE);
-
     uint_td len = sizeof(trdVersiton);
     req.op = TD_GETSERVER_CHARSET;
     req.data = &ver;
@@ -79,7 +72,7 @@ int client::getServerCharsetIndex()
     if (req.result == 0)
     {
         if (!checkVersion(ver))
-            return false;
+            return -1;
         c->setCharsetServer(mysql::charsetIndex(ver.cherserServer));
         return  c->charsetServer();
     }
@@ -104,15 +97,24 @@ bool client::buildDualChasetKeybuf()
     if (charsetIndexServer == -1)
         return false;
 
-    m_serverCharData = (char*)m_req.keybuf;
-    if (CHARSET_UTF8 != charsetIndexServer)
-        addSecondCharsetData(mysql::codePage(charsetIndexServer),
-                             m_serverCharData);
-    else
-        m_serverCharData += std::string("\t") + (char*)m_req.keybuf;
+    // remove auth info
+    {
+        _TCHAR tmp[MAX_KEYLEN+128]={0};
+        m_serverCharData = stripAuth((const char*)m_req.keybuf, tmp, MAX_KEYLEN);
+
+        if (CHARSET_UTF8 != charsetIndexServer)
+            addSecondCharsetData(mysql::codePage(charsetIndexServer),
+                                 m_serverCharData);
+        else
+            m_serverCharData += std::string("\t") + tmp;
+    }
+    //Add  Auth infomation
+    if (m_cryptPwd)
+        m_serverCharData += std::string("\t") +
+           std::string(m_cryptPwd, strlen(m_cryptPwd + 20) + MYSQL_SCRAMBLE_LENGTH);
 
     m_req.keybuf = (void_td*)m_serverCharData.c_str();
-    m_req.keylen = (keylen_td)m_serverCharData.size() + 1;
+    m_req.keylen = (keylen_td)m_serverCharData.size();
     return true;
 }
 

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

@@ -25,6 +25,7 @@
 #include <bzs/db/protocol/tdap/tdapSchema.h>
 #include <bzs/netsvc/client/tcpClient.h>
 #include <bzs/db/protocol/tdap/tdapcapi.h>
+#include <bzs/db/protocol/tdap/uri.h>
 #include <bzs/db/protocol/tdap/mysql/characterset.h>
 #include <bzs/env/compiler.h>
 #include <bzs/rtl/stl_uty.h>
@@ -64,7 +65,7 @@ class client
     ushort_td m_preResult;
     std::string m_sql;
     std::string m_serverCharData;
-    std::string m_serverCharData2;
+    char* m_cryptPwd;
     blobBuffer m_blobBuffer;
     uint_td m_tmplen;
     bool m_logout;
@@ -73,6 +74,13 @@ class client
 
     std::vector<char> m_sendbuf;
 
+    bool checkVersion(trdVersiton& ver)
+    {
+        if ((ver.srvMajor < 2) || ((ver.srvMajor == 2) && (ver.srvMinor < 1)))
+            return false;
+        return true;
+    }
+
     inline bzs::netsvc::client::connection* con() { return m_req.cid->con; };
 
     inline void setCon(bzs::netsvc::client::connection* con)
@@ -82,22 +90,21 @@ class client
 
     inline void disconnect()
     {
-        if (!con())
+        bzs::netsvc::client::connection* c = con();
+        if (!c)
             m_req.result = 1;
         else
         {
-            m_disconnected = m_cons->disconnect(con());
             setCon(NULL);
+            //Release connection refCount
+            m_disconnected = m_cons->disconnect(c);
         }
     }
 
     std::string getHostName(const char* uri)
     {
-        std::vector<std::string> ss;
-        split(ss, uri, "/"); /* btrv://serverName/dbName?dbfile=xxx */
-        if (ss.size() < 3)
-            return "";
-        return ss[2];
+        _TCHAR tmp[MAX_PATH];
+        return hostName(uri, tmp, MAX_PATH);
     }
 
     std::string getTableName(const char* uri)
@@ -123,8 +130,57 @@ class client
     static void addSecondCharsetData(unsigned int destCodePage,
                                      std::string& src);
 
+    bool handshake(bzs::netsvc::client::connection* c)
+    {
+        //Implements handshake here
+        handshale_t* hst  = (handshale_t*)c->read();
+        bool auth = (hst->size == sizeof(handshale_t));
+        bool min = (hst->size == (sizeof(handshale_t) 
+         									-  sizeof(hst->scramble)));
+        
+        if (min || auth)
+        {
+            if (!checkVersion(hst->ver))
+                return false;
+            c->setCharsetServer(mysql::charsetIndex(hst->ver.cherserServer));
+            m_req.cid->lock_wait_timeout = hst->lock_wait_timeout;
+            m_req.cid->transaction_isolation = hst->transaction_isolation;
+        }
+        if (auth)
+        {
+            char user[50];
+            char pwd[MAX_PATH];
+            char* p = (char*)m_req.keybuf;
+            userName(p, user, 50);
+            if (m_cryptPwd == NULL)
+                m_cryptPwd = new char[70];
+            passwd((const char*)m_req.keybuf, pwd, MAX_PATH);
+            if (pwd[0])
+                mysqlCryptPwd(m_cryptPwd, pwd, hst->scramble);
+            else
+                memset(m_cryptPwd, 0, MYSQL_SCRAMBLE_LENGTH);
+            strcpy_s(m_cryptPwd + MYSQL_SCRAMBLE_LENGTH, 50, user);
+        }else
+        {   // No auth
+            if (m_cryptPwd)
+                delete [] m_cryptPwd;
+            m_cryptPwd = NULL;
+        }
+        return true;
+    }
+
+    static bool handshakeCallback(bzs::netsvc::client::connection* c, void* data)
+    {
+        return ((client*)data)->handshake(c);
+    }
+
 public:
-    client() : m_disconnected(true), m_connecting(false) {}
+    client() : m_cryptPwd(NULL), m_disconnected(true), m_connecting(false) {}
+    ~client()
+    {
+        if (m_cryptPwd)
+            delete [] m_cryptPwd;
+    }
 
     void cleanup()
     {
@@ -182,11 +238,11 @@ public:
     {
         if (!m_req.cid->con)
         {
-           
             std::string host = getHostName((const char*)m_req.keybuf);
             if (host == "")
                 m_preResult = ERROR_TD_HOSTNAME_NOT_FOUND;
-            bzs::netsvc::client::connection* c = m_cons->connect(host);
+            bzs::netsvc::client::connection* c = m_cons->connect(host, 
+                                                  client::handshakeCallback, this);
             if (c)
             {
                 setCon(c);
@@ -198,6 +254,21 @@ public:
         m_disconnected = !m_req.cid->con;
     }
 
+    inline void createIndex()
+    {
+        m_req.paramMask = P_MASK_NOKEYBUF;
+        int charsetIndexServer =  getServerCharsetIndex();
+        unsigned char keynum = m_req.keyNum;
+        bool specifyKeyNum = (keynum >= 0x80);
+        if (keynum >= 0x80)
+            keynum -= 0x80;
+        m_sql = sqlCreateIndex((tabledef*)m_req.data, keynum, 
+                            specifyKeyNum, charsetIndexServer);
+        m_req.data = (ushort_td*)m_sql.c_str();
+        m_tmplen = (uint_td)(m_sql.size() + 1);
+        m_req.datalen = &m_tmplen;
+    }
+
     inline void create()
     {
         m_req.paramMask = P_MASK_ALL;
@@ -206,8 +277,10 @@ public:
         else if (m_req.keyNum >
                  CR_SUBOP_SWAPNAME) // -126 swap -127 is rename. -128 is drop.
         {
+             _TCHAR tmp[MAX_PATH*2]={0};
+            stripAuth((const char*)m_req.keybuf, tmp, MAX_PATH);
             m_req.paramMask &= ~P_MASK_POSBLK;
-            std::string name = getTableName((const char*)m_req.keybuf);
+            std::string name = getTableName(tmp);
             int charsetIndexServer =  getServerCharsetIndex();
             if ((m_req.keyNum == 1) || (m_req.keyNum == 2)) // make by tabledef
             {
@@ -239,26 +312,25 @@ public:
         if ((m_req.keyNum == LG_SUBOP_CONNECT) ||
             (m_req.keyNum == LG_SUBOP_NEWCONNECT))
         {
-            if (con() && con()->isConnected())
-                m_preResult = 1;
-            else
+            if (con())
+                disconnect();
+            std::string host = getHostName((const char*)m_req.keybuf);
+            if (host == "")
+                m_preResult = ERROR_TD_HOSTNAME_NOT_FOUND;
+            bzs::netsvc::client::connection* c = m_cons->connect(
+                host, handshakeCallback, this,
+                (m_req.keyNum == LG_SUBOP_NEWCONNECT));
+            if (c)
             {
-                std::string host = getHostName((const char*)m_req.keybuf);
-                if (host == "")
-                    m_preResult = ERROR_TD_HOSTNAME_NOT_FOUND;
-                bzs::netsvc::client::connection* c = m_cons->connect(
-                    host, (m_req.keyNum == LG_SUBOP_NEWCONNECT));
-                if (c)
-                {
-                    setCon(c); // if error throw exception
-                    if (getServerCharsetIndex() == -1)
-                        m_preResult = SERVER_CLIENT_NOT_COMPATIBLE;
-                    else
-                        buildDualChasetKeybuf();
-                }
+                setCon(c); // if error throw exception
+                m_connecting = true;
+                if (getServerCharsetIndex() == -1)
+                    m_preResult = SERVER_CLIENT_NOT_COMPATIBLE;
                 else
-                    m_preResult = ERROR_TD_HOSTNAME_NOT_FOUND;
+                    buildDualChasetKeybuf();
             }
+            else
+                m_preResult = ERROR_TD_HOSTNAME_NOT_FOUND;
         }
         else if (m_req.keyNum == LG_SUBOP_DISCONNECT)
         {
@@ -301,13 +373,13 @@ public:
                         p = c->asyncWriteRead(size);
                         m_req.parse(p, ex);
                     }
-                      
                 }
                 else
                     m_req.result = stat;
                 if (m_logout || (m_connecting && m_req.result))
                     disconnect();
                 m_preResult = m_req.result;
+                m_connecting = false;
             }
         }
         return result();

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

@@ -239,7 +239,7 @@ bool connectionPool<Database_Ptr>::reset(int waitSec)
                 flag = true;
         if (!flag)
             break;
-        Sleep(100 * MCRTOMM);
+        Sleep(100);
     }
     m_dbs.clear();
     return flag;

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

@@ -24,6 +24,7 @@
 #include <stdio.h>
 #include <vector>
 #include "stringConverter.h"
+#include <bzs/db/protocol/tdap/uri.h>
 
 #pragma package(smart_init)
 
@@ -218,7 +219,17 @@ void database::dropTable(const _TCHAR* TableName)
         m_stat = STATUS_TABLENAME_NOTFOUND;
     else
         _tcscat(FullPath, m_impl->dbDef->tableDefs(index)->fileName());
-    nsdatabase::dropTable(FullPath);
+
+    int i = 0;
+    while (1)
+    {
+        nsdatabase::dropTable(FullPath);
+        if (m_stat != STATUS_LOCK_ERROR)
+            break;
+        if (++i == 10) 
+            break;
+        Sleep(50);
+    } 
 }
 
 void database::setDir(const _TCHAR* directory)
@@ -287,7 +298,7 @@ bool database::open(const _TCHAR* _uri, short type, short mode,
                     const _TCHAR* dir, const _TCHAR* ownername)
 {
 
-    _TCHAR buf[MAX_PATH];
+    _TCHAR buf[MAX_PATH+50];
     m_stat = STATUS_SUCCESS;
     if (!m_impl->isOpened)
     {
@@ -304,13 +315,10 @@ bool database::open(const _TCHAR* _uri, short type, short mode,
         }
         else
         {
-            if (m_impl->rootDir[0] == 0x00)
-            {
-                nstable::getDirURI(uri(), buf);
-                setDir(buf);
-                if (m_stat)
-                    return false;
-            }
+            nstable::getDirURI(uri(), buf);
+            setDir(buf);
+            if (m_stat)
+                return false;
         }
         if (!m_impl->dbDef)
             m_impl->dbDef = new dbdef(this, type);
@@ -347,6 +355,20 @@ bool database::open(const _TCHAR* _uri, short type, short mode,
     return false;
 }
 
+short database::aclReload()
+{
+    if (!m_impl->isOpened)
+        return STATUS_DB_YET_OPEN;
+    _TCHAR buf[MAX_PATH];
+    const _TCHAR* p = dbname(rootDir(), buf, MAX_PATH);
+    if (_tcscmp(p, _T("mysql")) != 0)
+        return m_stat = STATUS_DB_YET_OPEN; 
+    _TCHAR posblk[128] = { 0x00 };
+    uint_td buflen = 0;
+    return m_stat =
+        m_btrcallid(TD_ACL_RELOAD, posblk, NULL, &buflen, 0, 0, 0, clientID());
+}
+
 char* database::getContinuousList(int option)
 {
     char* fileList = (char*)malloc(64000);
@@ -533,7 +555,7 @@ table* database::openTable(short FileNum, short mode, bool AutoCreate,
         }
     }
     if (tb->m_stat == 0)
-        tb->init(td, FileNum, regularDir);
+        tb->init(m_impl->dbDef->tableDefPtr(FileNum), FileNum, regularDir);
 
     if ((m_stat != 0) || (tb->m_stat != 0) ||
         !onTableOpened(tb, FileNum, mode, NewFile))

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

@@ -112,6 +112,7 @@ public:
     void drop();
     void dropTable(const _TCHAR* tableName);
     void close();
+    short aclReload();
     short continuous(char_td op = TD_BACKUP_START, bool inclideRepfile = false);
     short assignSchemaData(dbdef* src);
     short copyTableData(table* dest, table* src, bool turbo, int offset = 0,