transactd 2.1.0 → 2.2.0

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

@@ -313,7 +313,6 @@ public:
         moveBlobRow(m_row);
        
         m_tb->m_fddefs->strBufs()->clear();
-        multiRecordAlocator* mra = m_tb->m_impl->mraPtr;
         const tabledef* td = m_tb->tableDef();
         ushort_td fieldCount = m_filter->fieldCount();
 
@@ -432,7 +431,7 @@ multiRecordAlocator* table::mra() const
 
 uchar_td table::charset() const
 {
-    return m_tableDef->charsetIndex;
+    return (*m_tableDef)->charsetIndex;
 }
 
 bool table::trimPadChar() const
@@ -830,12 +829,12 @@ void table::btrvSeekMulti()
     int rowOffset = 0;
     for (int i = 0; i < (int)seeks.size(); ++i)
     {
-        // 100% need allocate each row
-        m_impl->mraPtr->init(1, recordLen, type, this);
-        type = mra_nextrows;
+
         seeks[i].writeBuffer((uchar_td*)m_impl->keybuf, true, transactd);
         if (hasManyJoin)
         {
+            m_impl->mraPtr->init(1, recordLen, type, this);
+            type = mra_nextrows;
             tdap((ushort_td)(TD_KEY_OR_AFTER));
             if (!checkStatus(m_stat))
                 return;
@@ -1137,19 +1136,19 @@ void table::getKeySpec(keySpec* ks, bool SpecifyKeyNum)
     keydef* KeyDef;
     short FieldNum;
     int j;
-
-    KeyDef = &m_tableDef->keyDefs[m_keynum];
+    tabledef* td = (*m_tableDef);
+    KeyDef = &td->keyDefs[m_keynum];
     for (j = 0; j < KeyDef->segmentCount; j++)
     {
         FieldNum = KeyDef->segments[j].fieldNum;
-        ks[j].keyPos = (ushort_td)(m_tableDef->fieldDefs[FieldNum].pos + 1);
-        ks[j].keyLen = m_tableDef->fieldDefs[FieldNum].len;
+        ks[j].keyPos = (ushort_td)(td->fieldDefs[FieldNum].pos + 1);
+        ks[j].keyLen = td->fieldDefs[FieldNum].len;
         ks[j].keyFlag.all = KeyDef->segments[j].flags.all;
         ks[j].keyCount = 0;
-        ks[j].keyType = m_tableDef->fieldDefs[FieldNum].type;
+        ks[j].keyType = td->fieldDefs[FieldNum].type;
 
         if (ks[j].keyFlag.bit3 == true)
-            ks[j].nullValue = m_tableDef->fieldDefs[FieldNum].nullValue;
+            ks[j].nullValue = td->fieldDefs[FieldNum].nullValue;
         else
             ks[j].nullValue = 0;
         ks[j].reserve2[0] = 0;
@@ -1166,25 +1165,40 @@ void table::getKeySpec(keySpec* ks, bool SpecifyKeyNum)
 
 void table::doCreateIndex(bool SpecifyKeyNum)
 {
-    int segmentCount = m_tableDef->keyDefs[m_keynum].segmentCount;
-
-    keySpec* ks = (keySpec*)malloc(sizeof(keySpec) * segmentCount);
-    memset(ks, 0, sizeof(keySpec) * segmentCount);
-    getKeySpec(ks, SpecifyKeyNum);
-    m_pdata = ks;
-    m_datalen = sizeof(keySpec) * segmentCount;
-    nstable::doCreateIndex(SpecifyKeyNum);
-    m_pdata = m_impl->dataBak;
-    free(ks);
+    SpecifyKeyNum = false;
+    if (isUseTransactd())
+    {
+        uint_td len = m_datalen;
+        m_pdata = (*m_tableDef);  
+        m_datalen = (*m_tableDef)->varSize + 4;
+        // tdclc check datalen, m_pdata is tabledef if bigger than sizeof(keySpec) * 8 
+        if (m_datalen <= sizeof(keySpec) * 8)
+            m_datalen = sizeof(keySpec) * 8 + 10; 
+        nstable::doCreateIndex(SpecifyKeyNum);
+        m_pdata = m_impl->dataBak;
+        m_datalen = len;
+    }
+    else
+    {
+        int segmentCount = (*m_tableDef)->keyDefs[m_keynum].segmentCount;
+        keySpec* ks = (keySpec*)malloc(sizeof(keySpec) * segmentCount);
+        memset(ks, 0, sizeof(keySpec) * segmentCount);
+        getKeySpec(ks, SpecifyKeyNum);
+        m_pdata = ks;
+        m_datalen = sizeof(keySpec) * segmentCount;//max 16 * 8 =128byte
+        nstable::doCreateIndex(SpecifyKeyNum);
+        m_pdata = m_impl->dataBak;
+        free(ks);
+    }
 }
 
 void table::smartUpdate()
 {
     if (!m_impl->smartUpDate)
-        m_impl->smartUpDate = malloc(m_tableDef->maxRecordLen);
+        m_impl->smartUpDate = malloc((*m_tableDef)->maxRecordLen);
     if (m_impl->smartUpDate)
     {
-        memcpy(m_impl->smartUpDate, data(), m_tableDef->maxRecordLen);
+        memcpy(m_impl->smartUpDate, data(), (*m_tableDef)->maxRecordLen);
         m_impl->smartUpDateFlag = true;
     }
     else
@@ -1193,9 +1207,9 @@ void table::smartUpdate()
 
 bool table::isUniqeKey(char_td keynum)
 {
-    if ((keynum >= 0) && (keynum < m_tableDef->keyCount))
+    if ((keynum >= 0) && (keynum < (*m_tableDef)->keyCount))
     {
-        keydef* kd = &m_tableDef->keyDefs[m_keynum];
+        keydef* kd = &(*m_tableDef)->keyDefs[m_keynum];
         return !(kd->segments[0].flags.bit0);
     }
     return false;
@@ -1228,7 +1242,7 @@ bool table::onUpdateCheck(eUpdateType type)
     else if (m_impl->smartUpDateFlag)
     {
         m_stat = 0;
-        if (memcmp(m_impl->smartUpDate, data(), m_tableDef->maxRecordLen) == 0)
+        if (memcmp(m_impl->smartUpDate, data(), (*m_tableDef)->maxRecordLen) == 0)
         {
             m_impl->smartUpDateFlag = false;
             return false;
@@ -1291,7 +1305,7 @@ void* table::attachBuffer(void* NewPtr, bool unpack, size_t size)
         m_impl->bfAtcPtr = m_pdata;
     oldptr = m_pdata;
     m_pdata = NewPtr;
-    ushort_td len = m_tableDef->maxRecordLen; 
+    ushort_td len = (*m_tableDef)->maxRecordLen; 
     if (unpack)
         len = unPack((char*)m_pdata, size);
     m_datalen = len;
@@ -1305,27 +1319,28 @@ void table::dettachBuffer()
     m_impl->bfAtcPtr = NULL;
 }
 
-void table::init(tabledef* Def, short fnum, bool regularDir)
+void table::init(tabledef** Def, short fnum, bool regularDir)
 {
     doInit(Def, fnum, regularDir);
 }
 
-void table::doInit(tabledef* Def, short fnum, bool /*regularDir*/)
+void table::doInit(tabledef** Def, short fnum, bool /*regularDir*/)
 {
     m_tableDef = Def;
-    m_fddefs->addAllFileds(m_tableDef);
-    m_fddefs->cv()->setCodePage(mysql::codePage(m_tableDef->charsetIndex));
-    ushort_td len = m_tableDef->maxRecordLen;
+    tabledef* td = *m_tableDef; 
+    m_fddefs->addAllFileds(td);
+    m_fddefs->cv()->setCodePage(mysql::codePage(td->charsetIndex));
+    ushort_td len = td->maxRecordLen;
     if (len == 0)
     {
         m_stat = STATUS_INVALID_RECLEN;
         return;
     }
 
-    for (short i = 0; i < m_tableDef->keyCount; i++)
+    for (short i = 0; i < td->keyCount; i++)
     {
-        if (m_tableDef->flags.bitA == true)
-            m_impl->keyNumIndex[m_tableDef->keyDefs[i].keyNumber] = (char)i;
+        if (td->flags.bitA == true)
+            m_impl->keyNumIndex[td->keyDefs[i].keyNumber] = (char)i;
         else
             m_impl->keyNumIndex[i] = (char)i;
     }
@@ -1337,10 +1352,10 @@ void table::doInit(tabledef* Def, short fnum, bool /*regularDir*/)
 
 keylen_td table::writeKeyDataTo(uchar_td* to, int keySize)
 {
-    if (m_tableDef->keyCount)
+    if ((*m_tableDef)->keyCount)
     {
         keydef& keydef =
-            m_tableDef->keyDefs[(short)m_impl->keyNumIndex[m_keynum]];
+            (*m_tableDef)->keyDefs[(short)m_impl->keyNumIndex[m_keynum]];
         uchar_td* start = to;
         if (keySize == 0)
             keySize = keydef.segmentCount;
@@ -1348,7 +1363,7 @@ keylen_td table::writeKeyDataTo(uchar_td* to, int keySize)
         for (int j = 0; j < keySize; j++)
         {
             int fdnum = keydef.segments[j].fieldNum;
-            fielddef& fd = m_tableDef->fieldDefs[fdnum];
+            fielddef& fd = (*m_tableDef)->fieldDefs[fdnum];
             uchar_td* from = (uchar_td*)m_pdata + fd.pos;
             to = fd.keyCopy(to, from);
         }
@@ -1367,9 +1382,9 @@ uint_td table::pack(char* ptr, size_t size)
     char* pos = ptr;
     char* end = pos + size;
     int movelen;
-    for (int i = 0; i < m_tableDef->fieldCount; i++)
+    for (int i = 0; i < (*m_tableDef)->fieldCount; i++)
     {
-        fielddef& fd = m_tableDef->fieldDefs[i];
+        fielddef& fd = (*m_tableDef)->fieldDefs[i];
         if (fd.type == ft_myfixedbinary)
         {
             memmove(pos + 2, pos, fd.len - 2); // move as size pace in the field
@@ -1398,15 +1413,16 @@ uint_td table::pack(char* ptr, size_t size)
 
 uint_td table::doGetWriteImageLen()
 {
+    tabledef* td = (*m_tableDef);
     if (!blobFieldUsed() && !valiableFormatType() &&
-        (m_tableDef->flags.bit0 == false))
-        return m_tableDef->maxRecordLen;
+        (td->flags.bit0 == false))
+        return td->maxRecordLen;
     // Make blob pointer list
     if (blobFieldUsed())
     {
-        for (ushort_td i = 0; i < m_tableDef->fieldCount; i++)
+        for (ushort_td i = 0; i < td->fieldCount; i++)
         {
-            fielddef& fd = m_tableDef->fieldDefs[i];
+            fielddef& fd = td->fieldDefs[i];
             uint_td bytes = fd.blobLenBytes();
             if (bytes)
             {
@@ -1421,21 +1437,21 @@ uint_td table::doGetWriteImageLen()
         addSendBlob(NULL);
 
     if (valiableFormatType())
-        return pack((char*)m_pdata, m_tableDef->maxRecordLen);
+        return pack((char*)m_pdata, td->maxRecordLen);
     else
     {
-        fielddef* fd = &m_tableDef->fieldDefs[m_tableDef->fieldCount - 1];
+        fielddef* fd = &td->fieldDefs[td->fieldCount - 1];
         size_t len = 0;
         short* pos;
 
         if (fd->type == ft_note)
-            len = strlen((char*)fieldPtr((short)(m_tableDef->fieldCount - 1))) +
+            len = strlen((char*)fieldPtr((short)(td->fieldCount - 1))) +
                   1;
         else if (fd->type == ft_lvar)
         {
             // xx................xx.............00
             // ln--data----------ln-----data----00
-            pos = (short*)fieldPtr((short)(m_tableDef->fieldCount - 1));
+            pos = (short*)fieldPtr((short)(td->fieldCount - 1));
             while (*pos)
             {
                 len += 2; // size
@@ -1457,11 +1473,12 @@ uint_td table::unPack(char* ptr, size_t size)
 {
     char* pos = ptr;
     const char* end = pos + size;
-    const char* max = pos + m_tableDef->maxRecordLen;
+    tabledef* td = *m_tableDef;
+    const char* max = pos + td->maxRecordLen;
     int movelen;
-    for (int i = 0; i < m_tableDef->fieldCount; i++)
+    for (int i = 0; i < td->fieldCount; i++)
     {
-        fielddef& fd = m_tableDef->fieldDefs[i];
+        fielddef& fd = td->fieldDefs[i];
         if (fd.type == ft_myfixedbinary)
         {
             int dl = *((unsigned short*)(pos));
@@ -1547,7 +1564,7 @@ void table::setBlobFieldPointer(char* ptr, const blobHeader* hd)
         const blobField* f = hd->nextField;
         for (int i = 0; i < hd->fieldCount; i++)
         {
-            fielddef& fd = m_tableDef->fieldDefs[f->fieldNum];
+            fielddef& fd = (*m_tableDef)->fieldDefs[f->fieldNum];
             char* fdptr = ptr + fd.pos;
             int sizeByte = fd.blobLenBytes();
             memcpy(fdptr, &f->size, sizeByte);
@@ -1574,8 +1591,8 @@ void table::onReadAfter()
         const blobHeader* hd = getBlobHeader();
         setBlobFieldPointer((char*)m_pdata, hd);
     }
-    if (m_tableDef->maxRecordLen - m_datalen > 0)
-        memset((char*)m_pdata + m_datalen, 0, m_tableDef->maxRecordLen - m_datalen);
+    if ((*m_tableDef)->maxRecordLen - m_datalen > 0)
+        memset((char*)m_pdata + m_datalen, 0, (*m_tableDef)->maxRecordLen - m_datalen);
 }
 
 short table::fieldNumByName(const _TCHAR* name)
@@ -1849,7 +1866,7 @@ void* table::getFVbin(short index, uint_td& size)
 
 bool table::checkIndex(short index) const
 {
-    if ((index >= m_tableDef->fieldCount) || (index < 0))
+    if ((index >= (*m_tableDef)->fieldCount) || (index < 0))
     {
         m_stat = STATUS_INVARID_FIELD_IDX;
         return false;
@@ -1881,7 +1898,7 @@ void table::moveBookmarksId(long id)
 
 short_td table::doBtrvErr(HWND hWnd, _TCHAR* retbuf)
 {
-    return nstable::tdapErr(hWnd, m_stat, m_tableDef->tableName(), retbuf);
+    return nstable::tdapErr(hWnd, m_stat, (*m_tableDef)->tableName(), retbuf);
 }
 
 /* For keyValueDescription */

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

@@ -87,7 +87,7 @@ class DLLLIB table : public nstable
 
     struct tbimpl* m_impl;
     class fielddefs* m_fddefs;
-    tabledef* m_tableDef;
+    tabledef** m_tableDef;
 
     uchar_td charset() const;
     bool checkIndex(short index) const;
@@ -138,12 +138,12 @@ protected:
 
     void onInsertAfter(int beforeResult); // orverride
     bool isUniqeKey(char_td keynum); // orverride
-    void init(tabledef* def, short filenum, bool regularDir);
+    void init(tabledef** def, short filenum, bool regularDir);
     void* attachBuffer(void* newPtr, bool unpack = false, size_t size = 0);
     void dettachBuffer();
     bool doPrepare();
 
-    virtual void doInit(tabledef* def, short filenum, bool regularDir);
+    virtual void doInit(tabledef** def, short filenum, bool regularDir);
 
     virtual void onRecordCounting(size_t count, bool& complate){};
 
@@ -152,18 +152,18 @@ protected:
 public:
     using nstable::eFindType;
 
-    inline const tabledef* tableDef() const { return m_tableDef; };
+    inline const tabledef* tableDef() const { return *m_tableDef; };
     inline const tabledef** tableDefPtr() const
     {
-        return const_cast<const tabledef**>(&m_tableDef);
-    };
+        return const_cast<const tabledef**>(m_tableDef);
+    }
 
     inline bool valiableFormatType() const
     {
-        return m_tableDef->optionFlags.bitA;
+        return (*m_tableDef)->optionFlags.bitA;
     }
 
-    inline bool blobFieldUsed() const { return m_tableDef->optionFlags.bitB; }
+    inline bool blobFieldUsed() const { return (*m_tableDef)->optionFlags.bitB; }
 
     bool logicalToString() const;
     void setLogicalToString(bool v);

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

@@ -23,6 +23,7 @@
 #include <boost/noncopyable.hpp>
 #include <iterator>
 #include <stdio.h>
+#include <bzs/db/protocol/tdap/uri.h>
 
 #if defined(__GNUC__)
 #if (!defined(__clang__) &&                                                    \
@@ -74,14 +75,27 @@ class connectParams
 
 public:
     inline connectParams(const _TCHAR* protocol, const _TCHAR* hostOrIp,
-                         const _TCHAR* dbname, const _TCHAR* schemaTable)
+                         const _TCHAR* dbname, const _TCHAR* schemaTable
+                         ,const _TCHAR* userName=NULL, const _TCHAR* passwd=NULL)
         : m_type(TYPE_SCHEMA_BDF), m_mode(TD_OPEN_READONLY)
     {
-        const _TCHAR* ext = _T(".bdf");
-        if (_tcscmp(schemaTable, TRANSACTD_SCHEMANAME)==0)
-            ext = _T("");
-        _stprintf_s(m_buf, MAX_PATH, _T("%s://%s/%s?dbfile=%s%s"), protocol,
-                    hostOrIp, dbname, schemaTable, ext);
+        _TCHAR dbf[MAX_PATH]={0x00};
+        if (schemaTable && schemaTable[0])
+        {
+            const _TCHAR* ext = _T(".bdf");
+            if (_tcscmp(schemaTable, TRANSACTD_SCHEMANAME)==0)
+                ext = _T("");
+            _stprintf_s(dbf, MAX_PATH, _T("dbfile=%s%s"), schemaTable, ext);   
+        }
+        if (userName == NULL || (userName[0] == 0x00))
+            _stprintf_s(m_buf, MAX_PATH, _T("%s://%s/%s?%s"), protocol,
+                    hostOrIp, dbname, dbf);
+        else
+        {
+            if (!passwd) passwd = _T("");
+            _stprintf_s(m_buf, MAX_PATH, _T("%s://%s@%s/%s?%s&pwd=%s"),
+                protocol, userName, hostOrIp, dbname, dbf, passwd);
+        }
     }
     inline explicit connectParams(const _TCHAR* uri)
         : m_type(TYPE_SCHEMA_BDF), m_mode(TD_OPEN_READONLY)
@@ -106,65 +120,16 @@ public:
         m_type = v;
     }
 
-    inline const _TCHAR* uri() const { return m_buf; }
+    inline const _TCHAR* uri(bool noPasswd=false) const 
+    { 
+        return m_buf; 
+    }
 
     inline char_td mode() const { return m_mode; };
 
     inline short type() const { return m_type; };
 };
 
-inline const _TCHAR* host(const _TCHAR* uri, _TCHAR* buf, size_t size)
-{
-    buf[0] = 0x00;
-    const _TCHAR* st = _tcsstr(uri, _T("://"));
-    if (st)
-    {
-        const _TCHAR* en = _tcsstr(st + 3, _T("/"));
-        if (en)
-        {
-            _tcsncpy_s(buf, size, st + 3, en - (st + 3));
-            buf[en - (st + 3)] = 0x00;
-        }
-    }
-    return buf;
-}
-
-inline const _TCHAR* dbname(const _TCHAR* uri, _TCHAR* buf, size_t size)
-{
-    buf[0] = 0x00;
-    const _TCHAR* st = _tcsstr(uri, _T("://"));
-    if (st)
-    {
-        st = _tcsstr(st + 3, _T("/"));
-        if (st)
-        {
-            const _TCHAR* en = _tcsstr(st + 1, _T("?"));
-            if (en)
-            {
-                _tcsncpy_s(buf, size, st + 1, en - (st + 1));
-                buf[en - (st + 1)] = 0x00;
-            }
-        }
-    }
-    return buf;
-}
-
-inline const _TCHAR* schemaTable(const _TCHAR* uri, _TCHAR* buf, size_t size)
-{
-    buf[0] = 0x00;
-    const _TCHAR* st = _tcsrchr(uri, _T('='));
-    if (st)
-    {
-        const _TCHAR* en = _tcsrchr(uri, _T('.'));
-        if (en)
-        {
-            _tcsncpy_s(buf, size, st + 1, en - (st + 1));
-            buf[en - (st + 1)] = 0x00;
-        }
-    }
-    return buf;
-}
-
 /* databaseManager interface
    If use some databases, implemnt a this interface and set the activeTable
    constructor
@@ -206,7 +171,7 @@ class tableIterator
     ushort_td m_lockBias;
 
 public:
-    inline tableIterator(table& tb, ushort_td lockBias = 0) : m_tb(tb), m_fds(tb),m_lockBias(lockBias)
+    inline tableIterator(table& tb, ushort_td lockBias = LOCK_BIAS_DEFAULT) : m_tb(tb), m_fds(tb),m_lockBias(lockBias)
     {
         readStatusCheck(tb, _T("tableIterator"));
     }
@@ -312,7 +277,7 @@ typedef filterdIterator<indexRvIterator> filterdIndexRvIterator;
 typedef filterdIterator<stepRvIterator> filterdStepRvIterator;
 typedef filterdIterator<findRvIterator> filterdFindRvIterator;
 
-inline indexIterator readIndex(table_ptr tb, eIndexOpType op, ushort_td lockBias = 0)
+inline indexIterator readIndex(table_ptr tb, eIndexOpType op, ushort_td lockBias = LOCK_BIAS_DEFAULT)
 {
 
     switch (op)
@@ -336,7 +301,7 @@ inline indexIterator readIndex(table_ptr tb, eIndexOpType op, ushort_td lockBias
     return indexIterator(*tb, lockBias);
 }
 
-inline indexRvIterator readIndexRv(table_ptr tb, eIndexOpType op, ushort_td lockBias = 0)
+inline indexRvIterator readIndexRv(table_ptr tb, eIndexOpType op, ushort_td lockBias = LOCK_BIAS_DEFAULT)
 {
 
     switch (op)
@@ -362,7 +327,7 @@ inline indexRvIterator readIndexRv(table_ptr tb, eIndexOpType op, ushort_td lock
 
 template <class T>
 inline indexIterator readIndex(table_ptr tb, eIndexOpType op, char_td keynum,
-                               T func, ushort_td lockBias = 0)
+                               T func, ushort_td lockBias = LOCK_BIAS_DEFAULT)
 {
     tb->setKeyNum(keynum);
     if (&func)
@@ -375,7 +340,7 @@ inline indexIterator readIndex(table_ptr tb, eIndexOpType op, char_td keynum,
 
 template <class T>
 inline indexRvIterator readIndexRv(table_ptr tb, eIndexOpType op,
-                                   char_td keynum, T func, ushort_td lockBias = 0)
+                                   char_td keynum, T func, ushort_td lockBias = LOCK_BIAS_DEFAULT)
 {
     tb->setKeyNum(keynum);
     if (&func)
@@ -550,13 +515,13 @@ inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op,
 }
 /** @endcond */
 
-inline stepIterator readStep(table_ptr tb, ushort_td lockBias = 0)
+inline stepIterator readStep(table_ptr tb, ushort_td lockBias = LOCK_BIAS_DEFAULT)
 {
     tb->stepFirst(lockBias);
     return stepIterator(*tb, lockBias);
 }
 
-inline stepRvIterator readStepRv(table_ptr tb, ushort_td lockBias = 0)
+inline stepRvIterator readStepRv(table_ptr tb, ushort_td lockBias = LOCK_BIAS_DEFAULT)
 {
     tb->stepLast(lockBias);
     return stepRvIterator(*tb, lockBias);
@@ -826,28 +791,6 @@ inline database_ptr createDatabaseObject()
     return p;
 }
 
-template <class Database_Ptr, class ConnectParam_type>
-inline void connect(Database_Ptr db, const ConnectParam_type& connPrams,
-                    bool newConnection)
-{
-    db->connect(connPrams.uri(), newConnection);
-    if (db->stat())
-        nstable::throwError(
-            (std::_tstring(_T("Connect database ")) + connPrams.uri()).c_str(),
-            db->stat());
-}
-
-/*template <>
-inline void connect(idatabaseManager* db,  const connectParams& connPrams, bool
-newConnection)
-{
-        db->connect(connPrams, newConnection);
-        if (db->stat())
-                nstable::throwError((std::_tstring(_T("Connect database ")) +
-connPrams.uri()).c_str(), db->stat());
-
-}*/
-
 template <class Database_Ptr>
 inline void disconnect(Database_Ptr db, const connectParams& connPrams)
 {
@@ -865,14 +808,29 @@ template <class Database_Ptr> inline void disconnect(Database_Ptr db)
         nstable::throwError(_T("Disconnect database "), db->stat());
 }
 
+template <class Database_Ptr>
+inline void throwDbError(Database_Ptr db,  const _TCHAR* caption, const _TCHAR* uri)
+{
+    TCHAR tmp[MAX_PATH];
+    tdap::stripPasswd(uri, tmp, MAX_PATH);
+    nstable::throwError((std::_tstring(caption) + tmp).c_str(), db->stat());
+}
+
+template <class Database_Ptr, class ConnectParam_type>
+inline void connect(Database_Ptr db, const ConnectParam_type& connPrams,
+                    bool newConnection)
+{
+    db->connect(connPrams.uri(), newConnection);
+    if (db->stat())
+        throwDbError(db, _T("Connect database : "), connPrams.uri());
+}
+
 template <class Database_Ptr>
 inline void createDatabase(Database_Ptr db, const connectParams& connPrams)
 {
     db->create(connPrams.uri());
     if (db->stat())
-        nstable::throwError(
-            (std::_tstring(_T("Create database ")) + connPrams.uri()).c_str(),
-            db->stat());
+        throwDbError(db, _T("Create database : "), connPrams.uri());
 }
 
 template <class Database_Ptr>
@@ -880,8 +838,7 @@ inline void createDatabase(Database_Ptr db, const _TCHAR* uri)
 {
     db->create(uri);
     if (db->stat())
-        nstable::throwError(
-            (std::_tstring(_T("Create database ")) + uri).c_str(), db->stat());
+        throwDbError(db, _T("Create database : "), uri);
 }
 
 template <class Database_Ptr, class ConnectParam_type>
@@ -889,9 +846,7 @@ inline void openDatabase(Database_Ptr db, const ConnectParam_type& connPrams)
 {
     db->open(connPrams.uri(), connPrams.type(), connPrams.mode());
     if (db->stat())
-        nstable::throwError(
-            (std::_tstring(_T("Open database ")) + connPrams.uri()).c_str(),
-            db->stat());
+        throwDbError(db, _T("Open database : "), connPrams.uri());
 }
 
 template <class Database_Ptr>
@@ -902,9 +857,7 @@ inline void openDatabase(Database_Ptr db, const _TCHAR* uri,
 {
     db->open(uri, schemaType, mode, dir, ownername);
     if (db->stat())
-        nstable::throwError(
-            (std::_tstring(_T("Open database ")) + std::_tstring(uri)).c_str(),
-            db->stat());
+        throwDbError(db, _T("Open database : "), uri);
 }
 
 template <class Database_Ptr>
@@ -1002,7 +955,6 @@ inline void insertTable(dbdef* def, short id, const _TCHAR* name,
 inline fielddef* insertField(dbdef* def, short tableid, short fieldNum,
                              const _TCHAR* name, uchar_td type, ushort_td len)
 {
-
     fielddef* fd = def->insertField(tableid, fieldNum);
     if (def->stat() != 0)
         nstable::throwError(

data/source/bzs/db/protocol/tdap/mysql/databaseSchema.cpp

@@ -104,6 +104,10 @@ uchar_td convFieldType(enum enum_field_types type, uint flags, bool binary,
         if ((flags & UNSIGNED_FLAG) || (type == MYSQL_TYPE_YEAR))
             return ft_uinteger;
         return ft_integer;
+    case MYSQL_TYPE_ENUM:
+        return ft_integer;
+    case MYSQL_TYPE_SET:
+        return ft_uinteger;
     case MYSQL_TYPE_FLOAT:
     case MYSQL_TYPE_DOUBLE:
         return ft_float;
@@ -187,9 +191,10 @@ short schemaBuilder::insertMetaRecord(table* mtb, table* src, int id)
             fd.setName(src->fieldName(i));
             fd.len = src->fieldLen(i); // filed->pack_length();
             fd.pos = pos;
-            fd.type = convFieldType(src->fieldType(i), src->fieldFlags(i),
+            fd.type = convFieldType(src->fieldRealType(i), src->fieldFlags(i),
                                     isBinary(src->fieldCharset(i)),
                                     isUnicode(src->fieldCharset(i)));
+            fd.setCharsetIndex(charsetIndex(src->fieldCharset(i).csname));
             pos += fd.len;
             datalen =
                 copyToRecordImage(rec.get(), &fd, sizeof(fielddef), datalen);
@@ -281,6 +286,8 @@ short schemaBuilder::execute(database* db, table* mtb)
                 filename_to_tablename(it->path().stem().string().c_str(), path,
                                       FN_REFLEN);
                 table* tb = db->openTable(path, TD_OPEN_READONLY, NULL);
+                if (!tb)
+                    return db->stat();
                 if (!tb->isView())
                 {
                     if ((stat = insertMetaRecord(mtb, tb, ++id)) != 0)

data/source/bzs/db/protocol/tdap/mysql/request.h

@@ -43,6 +43,9 @@ class request : public bzs::db::protocol::tdap::request
 {
 public:
     ushort_td cid;
+#ifdef DEBUG_LOG_ERR
+    const char* m_readBuffer;
+#endif
     void clear()
     {
         bzs::db::protocol::tdap::request::clear();
@@ -131,6 +134,9 @@ public:
     inline void parse(const char* p)
     {
         clear();
+#ifdef DEBUG_LOG_ERR
+        m_readBuffer = p;
+#endif
         p += sizeof(unsigned int);
         paramMask = *((ushort_td*)p);
         p += sizeof(ushort_td);