transactd 3.4.1 → 3.5.0

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

@@ -36,7 +36,9 @@
 #include <pthread.h>
 #endif
 
-extern bzs::netsvc::client::connections* m_cons;
+namespace bnet = bzs::netsvc::client;
+
+extern bnet::connections* m_cons;
 
 namespace bzs
 {
@@ -96,16 +98,16 @@ class client
         return true;
     }
 
-    inline bzs::netsvc::client::connection* con() { return m_req.cid->con; };
+    inline bnet::connection* con() { return m_req.cid->con; };
 
-    inline void setCon(bzs::netsvc::client::connection* con)
+    inline void setCon(bnet::connection* con)
     {
         m_req.cid->con = con;
     }
 
     inline void disconnect()
     {
-        bzs::netsvc::client::connection* c = con();
+        bnet::connection* c = con();
         if (!c)
             m_req.result = 1;
         else
@@ -151,7 +153,7 @@ class client
     static void addSecondCharsetData(unsigned int destCodePage,
                                      std::string& src);
 
-    bool handshake(bzs::netsvc::client::connection* c)
+    bool handshake(bnet::connection* c)
     {
         //Implements handshake here
         handshale_t* hst  = (handshale_t*)c->read();
@@ -170,6 +172,17 @@ class client
             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 (c->userOptions() & CL_OPTION_CHECK_ROLE)
+            {
+                bool clRoleMaster = (c->userOptions() & HST_OPTION_ROLE_MASTER) != 0; 
+                bool srvRoleMaster = (hst->options & HST_OPTION_ROLE_MASTER) != 0;
+  
+                if (clRoleMaster != srvRoleMaster)
+                {
+                    m_preResult = ERROR_TD_INVALID_SERVER_ROLE; 
+                    return false;
+                }
+            }
         }
         if (auth)
         {
@@ -194,7 +207,7 @@ class client
         return true;
     }
 
-    static bool handshakeCallback(bzs::netsvc::client::connection* c, void* data)
+    static bool handshakeCallback(bnet::connection* c, void* data)
     {
         return ((client*)data)->handshake(c);
     }
@@ -275,26 +288,51 @@ public:
         return false;
     }
 
-    inline void connect()
+    inline bnet::connection* doConnect(endpoint_t& ep, bool newConnection, bool clearNRCache)
+    {
+        bnet::connection* c = 
+            m_cons->connect(ep.host, ep.port,
+                client::handshakeCallback, this, newConnection, clearNRCache);
+        if (c)
+        {
+            setCon(c);
+            m_connecting = true;
+        }
+        return c;
+    }
+
+    bnet::connection* connect(bool newConnection = false)
     {
+        bnet::connection* c = NULL;
+        short errorOffset = 0;
         if (!m_req.cid->con)
         {
             m_preResult = 0;
+            m_connecting = false;
             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(ep.host, ep.port,
-                                                  client::handshakeCallback, this);
-            if (c)
+                return c;
+            }
+            c = doConnect(ep, newConnection, false);
+            if (!c)
             {
-                setCon(c);
-                m_connecting = true;
+                if (m_cons->haNameResolver() && 
+                    (m_preResult == 0 || m_preResult == ERROR_TD_INVALID_SERVER_ROLE))
+                {
+                    m_preResult = 0;
+                    c = doConnect(ep, newConnection, true);
+                    errorOffset = ERROR_TD_RECONNECTED_OFFSET;
+                }
             }
-            else if (m_preResult == 0)
-                m_preResult = ERROR_TD_HOSTNAME_NOT_FOUND;
+            if (!c && (m_preResult == 0))
+                m_preResult = errorCode(m_cons->connectError());
+            if (m_preResult) m_preResult += errorOffset; 
         }
         m_disconnected = !m_req.cid->con;
+        return c;
     }
 
     inline void createIndex()
@@ -306,15 +344,18 @@ public:
         }
         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 = sqlBuilder::sqlCreateIndex((tabledef*)m_req.data, keynum, 
-                            specifyKeyNum, charsetIndexServer, ver());
-        m_req.data = (ushort_td*)m_sql.c_str();
-        m_tmplen = (uint_td)(m_sql.size() + 1);
-        m_req.datalen = &m_tmplen;
+        if (charsetIndexServer != -1)
+        {
+            unsigned char keynum = m_req.keyNum;
+            bool specifyKeyNum = (keynum >= 0x80);
+            if (keynum >= 0x80)
+                keynum -= 0x80;
+            m_sql = sqlBuilder::sqlCreateIndex((tabledef*)m_req.data, keynum, 
+                                specifyKeyNum, charsetIndexServer, ver());
+            m_req.data = (ushort_td*)m_sql.c_str();
+            m_tmplen = (uint_td)(m_sql.size() + 1);
+            m_req.datalen = &m_tmplen;
+        }
     }
 
     inline void getSqlCreate(int charsetIndex = -1)
@@ -327,18 +368,20 @@ public:
         _TCHAR tmp[MAX_PATH*2]={0};
         stripAuth((const char*)m_req.keybuf, tmp, MAX_PATH);
         std::string name = getTableName(tmp);
-        if (charsetIndex == -1)
-            charsetIndex =  getServerCharsetIndex();
-        std::string sql = sqlBuilder::sqlCreateTable(name.c_str(), (tabledef*)m_req.data,
-                                       charsetIndex, ver());
-        uint_td  datalen = *m_req.datalen;
-        *m_req.datalen = (uint_td)(sql.size() + 1);
-        if (datalen <= sql.size())
+        charsetIndex =  getServerCharsetIndex();
+        if (charsetIndex != -1)
         {
-            m_req.result = STATUS_BUFFERTOOSMALL;
-            return;
+            std::string sql = sqlBuilder::sqlCreateTable(name.c_str(), (tabledef*)m_req.data,
+                                           charsetIndex, ver());
+            uint_td  datalen = *m_req.datalen;
+            *m_req.datalen = (uint_td)(sql.size() + 1);
+            if (datalen <= sql.size())
+            {
+                m_req.result = STATUS_BUFFERTOOSMALL;
+                return;
+            }
+            strcpy_s((char*)m_req.data, *m_req.datalen, sql.c_str());
         }
-        strcpy_s((char*)m_req.data, *m_req.datalen, sql.c_str());
     }
 
     inline void create()
@@ -353,51 +396,52 @@ public:
             stripAuth((const char*)m_req.keybuf, tmp, MAX_PATH);
             m_req.paramMask &= ~P_MASK_POSBLK;
             std::string name = getTableName(tmp);
-            int charsetIndexServer =  getServerCharsetIndex();
-            if (!ver())
-            {
-                m_preResult = ERROR_TD_NOT_CONNECTED;
-                return; 
-            }
-            if ((m_req.keyNum == CR_SUBOP_BY_TABLEDEF) || 
-                    (m_req.keyNum == CR_SUBOP_BY_TABLEDEF_NOCKECK)) // make by tabledef
+            int charsetIndexServer = getServerCharsetIndex();
+            if (charsetIndexServer != -1)
             {
-                m_sql = sqlBuilder::sqlCreateTable(name.c_str(), (tabledef*)m_req.data,
-                                       charsetIndexServer, ver());
-                m_req.keyNum -= 2; // -1= exists check 0 = no exists check
-            }
-            else if ((m_req.keyNum == CR_SUBOP_BY_SQL) || 
-                    (m_req.keyNum == CR_SUBOP_BY_SQL_NOCKECK)) // make by sql
-            {
-                m_req.keyNum -= 4; // -1= exists check 0 = no exists check
-                if (charsetIndexServer != CHARSET_UTF8 && charsetIndexServer != CHARSET_UTF8B4)
-                    m_sql = sqlBuilder::convertString(mysql::codePage(charsetIndexServer), 65001,
-                          (const char*)m_req.data);
+                if ((m_req.keyNum == CR_SUBOP_BY_TABLEDEF) || 
+                        (m_req.keyNum == CR_SUBOP_BY_TABLEDEF_NOCKECK)) // make by tabledef
+                {
+                    m_sql = sqlBuilder::sqlCreateTable(name.c_str(), (tabledef*)m_req.data,
+                                           charsetIndexServer, ver());
+                    m_req.keyNum -= 2; // -1= exists check 0 = no exists check
+                }
+                else if ((m_req.keyNum == CR_SUBOP_BY_SQL) || 
+                        (m_req.keyNum == CR_SUBOP_BY_SQL_NOCKECK)) // make by sql
+                {
+                    m_req.keyNum -= 4; // -1= exists check 0 = no exists check
+                    if (charsetIndexServer != CHARSET_UTF8 && charsetIndexServer != CHARSET_UTF8B4)
+                        m_sql = sqlBuilder::convertString(mysql::codePage(charsetIndexServer), 65001,
+                              (const char*)m_req.data);
+                    else
+                        m_sql = (const char*)m_req.data;
+                }
                 else
-                    m_sql = (const char*)m_req.data;
+                    m_sql = sqlBuilder::sqlCreateTable(name.c_str(), (fileSpec*)m_req.data,
+                                           charsetIndexServer, ver());
+                m_req.data = (ushort_td*)m_sql.c_str();
+                m_tmplen = (uint_td)(m_sql.size() + 1);
+                m_req.datalen = &m_tmplen;
             }
-            else
-                m_sql = sqlBuilder::sqlCreateTable(name.c_str(), (fileSpec*)m_req.data,
-                                       charsetIndexServer, ver());
-            m_req.data = (ushort_td*)m_sql.c_str();
-            m_tmplen = (uint_td)(m_sql.size() + 1);
-            m_req.datalen = &m_tmplen;
         }
         else if ((m_req.keyNum == CR_SUBOP_SWAPNAME) ||
                  (m_req.keyNum == CR_SUBOP_RENAME))
         {
             int charsetIndexServer =  getServerCharsetIndex();
-            m_sql = (char*)m_req.data;
-            addSecondCharsetData(mysql::codePage(charsetIndexServer), m_sql);
-            m_req.data = (ushort_td*)m_sql.c_str();
-            m_tmplen = (uint_td)(m_sql.size() + 1);
-            m_req.datalen = &m_tmplen;
+            if (charsetIndexServer != -1)
+            {
+                m_sql = (char*)m_req.data;
+                addSecondCharsetData(mysql::codePage(charsetIndexServer), m_sql);
+                m_req.data = (ushort_td*)m_sql.c_str();
+                m_tmplen = (uint_td)(m_sql.size() + 1);
+                m_req.datalen = &m_tmplen;
+            }
         }
     }
 
     inline void reconnect()
     {
-        bzs::netsvc::client::connection* c = con();
+        bnet::connection* c = con();
         if (!c)
         {
             m_preResult = ERROR_TD_NOT_CONNECTED;
@@ -406,21 +450,25 @@ public:
         endpoint_t ep;
         endPoint((const char*)m_req.keybuf, &ep);
      
-        m_preResult = ERROR_TD_HOSTNAME_NOT_FOUND;
-        if (ep.host[0] == 0x00) return;
-
+        if (ep.host[0] == 0x00)
+        {
+            m_preResult = ERROR_TD_HOSTNAME_NOT_FOUND;
+            return;
+        }
+        //request req = m_req;
         if (!m_cons->reconnect(c, ep.host, ep.port, handshakeCallback, this))
         {
-            m_preResult = errorCode(m_cons->connectError());
+            if (m_preResult == 0)
+                m_preResult = errorCode(m_cons->connectError());
             return;
         }
+        //m_req = req;
         m_connecting = true;
-        if (getServerCharsetIndex() == -1)
-            m_preResult = SERVER_CLIENT_NOT_COMPATIBLE;
-        else
+        if (getServerCharsetIndex() != -1)
         {
             m_preResult = 0;
             buildDualChasetKeybuf();
+            m_disconnected = false;
         }
         m_req.paramMask = P_MASK_KEYONLY;
     }
@@ -436,34 +484,17 @@ public:
         else if ((m_req.keyNum == LG_SUBOP_CONNECT) ||
             (m_req.keyNum == LG_SUBOP_NEWCONNECT))
         {
-            if (con())
-                disconnect();
-            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(
-                ep.host, ep.port, handshakeCallback, this,
-                (m_req.keyNum == LG_SUBOP_NEWCONNECT));
+            if (con()) disconnect();
+            bnet::connection* c = 
+                    connect((m_req.keyNum == LG_SUBOP_NEWCONNECT));
             if (c)
             {
-                setCon(c); // if error throw exception
-                m_connecting = true;
-                if (getServerCharsetIndex() == -1)
-                {
-                    if (c->error() || (m_req.resultLen == 0))
-                        m_preResult = ERROR_TD_INVALID_CLINETHOST;
-                    else
-                        m_preResult = SERVER_CLIENT_NOT_COMPATIBLE;
-                }
-                else
+                if (getServerCharsetIndex() != -1)
                 {
                     buildDualChasetKeybuf();
                     m_disconnected = false;
                 }
             }
-            else
-                m_preResult = errorCode(m_cons->connectError());
         }
         else if (m_req.keyNum == LG_SUBOP_DISCONNECT)
         {
@@ -485,7 +516,7 @@ public:
     {
         if (result() == 0)
         {
-            bzs::netsvc::client::connection* c = con();
+            bnet::connection* c = con();
             if (!c)
                 m_preResult = ERROR_TD_NOT_CONNECTED;
             else

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

@@ -51,10 +51,11 @@ static const _TCHAR* SYSVAR_NAME[TD_VAR_SIZE] =
     _T("use_piped_local"),
     _T("hs_port"),
     _T("use_handlersocket"),
-    _T("timestamp_always)")
+    _T("timestamp_always"),
+    _T("startup_ha")
 };
 
-static const _TCHAR* STATUSVAR_NAME[TD_VAR_SIZE] =
+static const _TCHAR* STATUSVAR_NAME[TD_SVAR_SIZE] =
 {
     _T("tcp_connections"),
     _T("tcp_wait_threads"),
@@ -63,6 +64,7 @@ static const _TCHAR* STATUSVAR_NAME[TD_VAR_SIZE] =
     _T("pipe_connections"),
     _T("pipe_wait_threads"),
     _T("cur_open_databases"),
+    _T("ha"),
 };
 
 static const _TCHAR* SLAVE_STATUS_NAME[SLAVE_STATUS_DEFAULT_SIZE] =
@@ -146,6 +148,14 @@ static const _TCHAR* SLAVE_STATUS_NAME_EX_MA[SLAVE_STATUS_EX_MA_SIZE] =
     _T("Gtid_Slave_Pos"),
 };
 
+static const _TCHAR* EXTENDED_VAR_NAME[TD_EXTENDED_VAR_SIZE] =
+{
+    _T("MySQL_Gtid_Mode"),
+    _T("Binlog_File"),
+    _T("Binlog_Position"),
+    _T("Executed_Gtid_Set/Gtid_Cur_Pos")
+};
+
 class stringBuffer
 {
 	friend class connMgr;
@@ -176,12 +186,12 @@ connRecords& connRecords::operator=(const connRecords& r)
 
 void connRecords::clear() { m_records.clear(); m_buf.reset(); }
 
-const connRecords::record& connRecords::operator[] (int index) const
+const connRecords::record& connRecords::operator[] (size_t index) const
 {
     return m_records[index];
 }
 
-connRecords::record& connRecords::operator[] (int index)
+connRecords::record& connRecords::operator[] (size_t index)
 {
     return m_records[index];
 }
@@ -190,6 +200,8 @@ size_t connRecords::size() const { return m_records.size(); }
 
 connRecords* connRecords::create(){ return new connRecords();}
 
+connRecords* connRecords::create(const connRecords& r){ return new connRecords(r);}
+
 void connRecords::release(){ delete this;}
 
 //-----------------------------------------------------------------------------
@@ -233,9 +245,10 @@ connMgr::connMgr(database* db) : nstable(db)
     m_params[0] = 0;
     m_params[1] = 0;
     m_keylen = sizeof(m_params);
+    m_datalen = m_buflen = 0;
 }
 
-connMgr::~connMgr() {}
+connMgr::~connMgr() {setIsOpen(false);}
 
 database* connMgr::db() const
 {
@@ -277,6 +290,7 @@ bool connMgr::connect(const _TCHAR* uri)
     m_stat = m_db->stat();
     if (m_stat == 0)
     {
+        setIsOpen(true);
         m_uri = uri;
         btrVersions vs;
         m_db->getBtrVersion(&vs);
@@ -290,10 +304,13 @@ void connMgr::disconnect()
 {
     if (m_uri != _T(""))
     {
-        m_db->disconnect(m_uri.c_str());
+        m_db->disconnect();
         m_stat = m_db->stat();
         if (m_stat == 0)
+        {
             m_uri = _T("");
+            setIsOpen(false);
+        }
     }
 }
 
@@ -311,8 +328,11 @@ void connMgr::allocBuffer()
 const connMgr::records& connMgr::getRecords(bool isInUseTable)
 {
     tdap(TD_STASTISTICS);
-    if (m_stat == 0 && *((int*)m_keybuf) != (int)sizeof(connMgr::record))
-        convertFromOldFormat(isInUseTable);
+    if (m_keynum < TD_STSTCS_SLAVE_STATUS)
+    {
+        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
@@ -388,22 +408,63 @@ void connMgr::setBlobFieldPointer(const blobHeader* hd)
     }
 }
 
-const connMgr::records& connMgr::slaveStatus()
+const connMgr::records& connMgr::blobOperation(int op)
 {
     if ((m_pluginVer.majorVersion >= 3) && (m_pluginVer.minorVersion >= 2))
     {
-        m_keynum = TD_STSTCS_SLAVE_STATUS;
+        m_keynum = op;
         allocBuffer();
         getRecords();
         // set blob pointers
         setBlobFieldPointer(getBlobHeader());
         return m_records;
-   }
+    }
     m_stat = STATUS_NOSUPPORT_OP;
     m_records.resize(0);
     return m_records;
 }
 
+const connMgr::records& connMgr::slaveStatus(const char* channel)
+{
+    char ch[65] = {0};
+    if (channel)
+        strcpy_s(ch, 65, channel);
+    m_keybuf = (void*)ch;
+    m_keylen = 65;
+    blobOperation(TD_STSTCS_SLAVE_STATUS);
+    m_keybuf = &m_params[0];
+    m_keylen = sizeof(m_params);
+    return m_records;
+}
+#ifdef _UNICODE
+const connMgr::records& connMgr::slaveStatus(const wchar_t* channel)
+{
+    char tmp[128] = {0};
+    if (channel)
+        WideCharToMultiByte(CP_UTF8, 0, channel,-1, tmp, 128, NULL, NULL);
+    return slaveStatus(tmp);
+}
+#endif
+
+
+const connMgr::records& connMgr::channels(bool withLock )
+{
+    m_keynum = withLock ? 
+                TD_STSTCS_SLAVE_CHANNELS_LOCK :TD_STSTCS_SLAVE_CHANNELS;
+    allocBuffer();
+    return getRecords();
+}
+
+const connMgr::records& connMgr::slaveHosts()
+{
+    return blobOperation(TD_STSTCS_SLAVE_HOSTS);
+}
+
+const connMgr::records& connMgr::extendedvars()
+{
+    return blobOperation(TD_STSTCS_EXTENDED_VARIABLES);
+}
+
 const connMgr::records& connMgr::sysvars()
 {
     m_keynum = TD_STSTCS_SYSTEM_VARIABLES;
@@ -449,18 +510,59 @@ void connMgr::postDisconnectOne(__int64 connid)
 {
     m_keynum = TD_STSTCS_DISCONNECT_ONE;
     m_params[0] = connid;
+    m_datalen = 0;
     tdap(TD_STASTISTICS);
 }
 
 void connMgr::postDisconnectAll()
 {
     m_keynum = TD_STSTCS_DISCONNECT_ALL;
+    m_datalen = 0;
+    tdap(TD_STASTISTICS);
+}
+
+bool connMgr::haLock()
+{
+    m_keynum = TD_STSTCS_HA_LOCK;
+    m_datalen = 0;
+    tdap(TD_STASTISTICS);
+    return stat() == 0;
+}
+
+void connMgr::haUnlock()
+{
+    m_keynum = TD_STSTCS_HA_UNLOCK;
+    m_datalen = 0;
+    tdap(TD_STASTISTICS);
+
+}
+
+bool connMgr::setRole(int v)
+{
+    m_keynum = (v == HA_ROLE_MASTER) ? TD_STSTCS_HA_SET_ROLEMASTER :
+                (v == HA_ROLE_SLAVE) ? TD_STSTCS_HA_SET_ROLESLAVE :
+                                        TD_STSTCS_HA_SET_ROLENONE;
+    m_datalen = 0;
     tdap(TD_STASTISTICS);
+    return stat() == 0;
 }
 
-short_td connMgr::stat()
+bool connMgr::setTrxBlock(bool v)
 {
-    return m_stat;
+    m_keynum = v ? TD_STSTCS_HA_SET_TRXBLOCK :
+                          TD_STSTCS_HA_SET_TRXNOBLOCK;
+    m_datalen = 0;
+    tdap(TD_STASTISTICS);
+    return stat() == 0;
+}
+
+bool connMgr::setEnableFailover(bool v)
+{
+    m_keynum = v ? TD_STSTCS_HA_ENABLE_FO :
+                          TD_STSTCS_HA_DISBLE_FO;
+    m_datalen = 0;
+    tdap(TD_STASTISTICS);
+    return stat() == 0;
 }
 
 connMgr* connMgr::create(database* db)
@@ -480,37 +582,44 @@ void connMgr::removeSystemDb(connMgr::records& recs)
     }
 }
 
-const _TCHAR* connMgr::sysvarName(uint_td index)
+const _TCHAR* connMgr::sysvarName(uint_td id)
 {
-    if (index < TD_VAR_SIZE)
-        return SYSVAR_NAME[index];
+    if (id < TD_VAR_SIZE)
+        return SYSVAR_NAME[id];
     return _T("");
 }
 
-const _TCHAR* connMgr::statusvarName(uint_td index)
+const _TCHAR* connMgr::statusvarName(uint_td id)
 {
-    if (index < TD_SVAR_SIZE)
-        return STATUSVAR_NAME[index];
+    if (id < TD_SVAR_SIZE)
+        return STATUSVAR_NAME[id];
     return _T("");
 }
 
-const _TCHAR* slaveStatusName1(uint_td index)
+const _TCHAR* slaveStatusName1(uint_td id)
 {
-    if (index < SLAVE_STATUS_DEFAULT_SIZE)
-        return SLAVE_STATUS_NAME[index];
+    if (id < SLAVE_STATUS_DEFAULT_SIZE)
+        return SLAVE_STATUS_NAME[id];
     return _T("");
 }
 
-const _TCHAR* connMgr::slaveStatusName(uint_td index) const
+const _TCHAR* connMgr::slaveStatusName(uint_td id) const
 {
     bool mariadb = m_serverVer.isMariaDB();
-    if (index < SLAVE_STATUS_DEFAULT_SIZE)
-        return slaveStatusName1(index);
-    index -= SLAVE_STATUS_DEFAULT_SIZE;
-    if(mariadb &&  (index < SLAVE_STATUS_EX_MA_SIZE))
-        return SLAVE_STATUS_NAME_EX_MA[index];
-    else if(!mariadb &&  (index < SLAVE_STATUS_EX_SIZE))
-        return SLAVE_STATUS_NAME_EX[index];
+    if (id < SLAVE_STATUS_DEFAULT_SIZE)
+        return slaveStatusName1(id);
+    id -= SLAVE_STATUS_DEFAULT_SIZE;
+    if(mariadb &&  (id < SLAVE_STATUS_EX_MA_SIZE))
+        return SLAVE_STATUS_NAME_EX_MA[id];
+    else if(!mariadb &&  (id < SLAVE_STATUS_EX_SIZE))
+        return SLAVE_STATUS_NAME_EX[id];
+    return _T("");
+}
+
+const _TCHAR* connMgr::extendedVarName(uint_td id)
+{
+    if (id < TD_EXTENDED_VAR_SIZE)
+        return EXTENDED_VAR_NAME[id];
     return _T("");
 }