transactd 1.2.0 → 2.0.0

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

@@ -16,9 +16,6 @@
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
  ================================================================= */
-#include <bzs/env/tstring.h>
-#pragma hdrstop
-
 #include "dbDef.h"
 #include "database.h"
 #include <bzs/rtl/strtrim.h>
@@ -42,60 +39,64 @@ namespace tdap
 namespace client
 {
 
-static const _TUCHAR BDFFORMAT_VERSION[] = _T("2.000.00");
-static const _TUCHAR ow0[11] = {46, 46, 83, 67, 46, 46, 46, 46, 93, 4, 0};
-static const _TUCHAR ow1[11] = {46, 46, 83, 67, 46, 46, 46, 46, 66, 5, 0};
-static const _TUCHAR ow2[11] = {46, 46, 83, 67, 46, 46, 46, 46, 212, 5, 0};
+#define FORMAT_VERSON_BTRV_DEF 0
+#define FORMAT_VERSON_CURRENT 1
+
+static const _TCHAR BDFFORMAT_VERSION[] = _T("2.000.00");
+static const _TCHAR ow0[11] = { 46, 46, 83, 67, 46, 46, 46, 46, 93, 4, 0 };
+static const _TCHAR ow1[11] = { 46, 46, 83, 67, 46, 46, 46, 46, 66, 5, 0 };
+static const _TCHAR ow2[11] = { 46, 46, 83, 67, 46, 46, 46, 46, -44, 5, 0 };
 using namespace bzs::rtl;
 
 class ownerNameSetter : public nstable
 {
-   void onReadAfter(){};
-   void writeRecordData(){};
+    void onReadAfter(){};
+    void writeRecordData(){};
+
 public:
-   ownerNameSetter(nsdatabase *pbe):nstable(pbe){};
-   using nstable::open;
+    ownerNameSetter(nsdatabase* pbe) : nstable(pbe){};
+    using nstable::open;
 };
 
 static const int BDFMAXBUFFER = 32384;
 
 struct dbdimple
 {
+    tabledef* tableDefs[TABLE_NUM_TMP + 1];
     char keybuf[128];
     tabledef* bdf;
-    int bdfLen;
-    bool noWriteMode;
-    short deftype;
-    _TCHAR userName[20];
-    tabledef* tableDefs[TABLE_NUM_TMP+1];
-    _TCHAR version[9];
+    void* relateData;
     ushort_td maxid;
     short tableCount;
-    void* relateData;
     short openMode;
+    short deftype;
+    _TCHAR userName[20];
+    int bdfLen;
+    _TCHAR version[9];
+    bool noWriteMode;
 
-    dbdimple() : bdf(NULL), bdfLen(BDFMAXBUFFER), noWriteMode(false), tableCount(0),
-        relateData(NULL), openMode(1), maxid(0)
+    dbdimple()
+        : bdf(NULL), relateData(NULL), maxid(0), tableCount(0), openMode(1),
+          deftype(TYPE_SCHEMA_BDF), bdfLen(BDFMAXBUFFER), noWriteMode(false)
     {
-        memset(tableDefs, 0, (TABLE_NUM_TMP+1)*sizeof(tabledef*));
+        memset(tableDefs, 0, (TABLE_NUM_TMP + 1) * sizeof(tabledef*));
         _tcscpy(version, (const _TCHAR*)BDFFORMAT_VERSION);
     }
 };
 
-dbdef::dbdef(nsdatabase *pbe, short DefType) : nstable(pbe)
+dbdef::dbdef(nsdatabase* pbe, short DefType) : nstable(pbe)
 {
     m_impl = new dbdimple();
     m_impl->deftype = DefType;
     m_keybuflen = 128;
     m_keybuf = &m_impl->keybuf[0];
-	setShared();
- 
+    setShared();
 }
 
-dbdef::~dbdef() 
+dbdef::~dbdef()
 {
-	if (m_impl->bdf)
-		free(m_impl->bdf);
+    if (m_impl->bdf)
+        free(m_impl->bdf);
 
     for (int i = 0; i <= m_impl->tableCount; i++)
     {
@@ -107,20 +108,38 @@ dbdef::~dbdef()
         free(m_impl->tableDefs[TABLE_NUM_TMP]);
     if (m_impl->relateData)
         free(m_impl->relateData);
-	delete m_impl;
+    delete m_impl;
 }
 
-void dbdef::setDefType(short defType) {m_impl->deftype = defType;}
+void dbdef::setDefType(short defType)
+{
+    m_impl->deftype = defType;
+}
 
-short dbdef::tableCount() const {return m_impl->tableCount;}
+short dbdef::tableCount() const
+{
+    return m_impl->tableCount;
+}
 
-void* dbdef::relateData() const {return m_impl->relateData;}
+void* dbdef::relateData() const
+{
+    return m_impl->relateData;
+}
 
-short dbdef::openMode() const {return m_impl->openMode;}
+short dbdef::openMode() const
+{
+    return m_impl->openMode;
+}
 
-int dbdef::version() const {return m_impl->version[7] - '0';};
+int dbdef::version() const
+{
+    return m_impl->version[7] - '0';
+};
 
-void dbdef::setVersion(int v) {m_impl->version[7] = (char)v;}
+void dbdef::setVersion(int v)
+{
+    m_impl->version[7] = (char)v;
+}
 
 void* dbdef::allocRelateData(int size)
 {
@@ -149,12 +168,12 @@ void dbdef::moveById(short id)
         else
             break;
     }
-
 }
 
 bool dbdef::resizeReadBuf(void)
 {
-    m_impl->bdf = (tabledef*) realloc(m_impl->bdf, m_impl->bdfLen + BDFMAXBUFFER);
+    m_impl->bdf =
+        (tabledef*)realloc(m_impl->bdf, m_impl->bdfLen + BDFMAXBUFFER);
     if (m_impl->bdf == NULL)
     {
         m_stat = STATUS_CANT_ALLOC_MEMORY;
@@ -167,24 +186,24 @@ bool dbdef::resizeReadBuf(void)
 keydef* dbdef::getKeyDef(tabledef* p)
 {
     // keydefPos = size of tabledef �{ size of fielddef x number
-    return (keydef*)((char*) p +sizeof(tabledef) + (p->fieldCount*sizeof(fielddef)));
+    return (keydef*)((char*)p + sizeof(tabledef) +
+                     (p->fieldCount * sizeof(fielddef)));
 }
 
 fielddef* dbdef::getFieldDef(tabledef* p)
 {
 
-    return (fielddef*)((char*) p +sizeof(tabledef));
+    return (fielddef*)((char*)p + sizeof(tabledef));
 }
 
 void dbdef::setRecordLen(short TableIndex)
 {
-    tableDefs(TableIndex)->maxRecordLen = getRecordLen(TableIndex);
+    tabledef* td = tableDefs(TableIndex);
+    td->maxRecordLen = getRecordLen(TableIndex);
 
     // If valible length then specifing fixed length.
-    if ((tableDefs(TableIndex)->fixedRecordLen == 0) ||
-        (tableDefs(TableIndex)->flags.bit0 == false))
-        tableDefs(TableIndex)->fixedRecordLen = tableDefs(TableIndex)->maxRecordLen;
-
+    if ((td->fixedRecordLen == 0) || (td->flags.bit0 == false))
+        td->fixedRecordLen = td->maxRecordLen;
 }
 
 void dbdef::setCodePage(tabledef* td)
@@ -205,16 +224,12 @@ void dbdef::updateTableDef(short TableIndex, bool forPsqlDdf)
 {
     m_stat = STATUS_SUCCESS;
     tabledef* td = tableDefs(TableIndex);
-    short i = (short)(td->fieldCount - 1);
-    short j;
-    short ret;
-    short Fnum;
+    short i, j, ret, Fnum;
     uchar_td type;
 
     td->optionFlags.bitA = false; // reset valiable type
 
-
-    for (; i >= 0; --i)
+    for (i = 0; i < td->fieldCount; ++i)
     {
         ret = fieldNumByName(TableIndex, td->fieldDefs[i].name());
         if ((ret != -1) && (ret != i))
@@ -224,6 +239,10 @@ void dbdef::updateTableDef(short TableIndex, bool forPsqlDdf)
         }
         // Check field length.
         type = td->fieldDefs[i].type;
+
+        // reset update indicator
+        td->fieldDefs[i].enableFlags.bitE = false;
+
         ret = validLen(type, td->fieldDefs[i].len);
         if (!ret)
         {
@@ -233,26 +252,27 @@ void dbdef::updateTableDef(short TableIndex, bool forPsqlDdf)
         // Note or Lvar type must be the last of fields.
         if ((type == ft_note) || (type == ft_lvar))
         {
-            if (i != td->fieldCount - 1) {
+            if (i != td->fieldCount - 1)
+            {
                 m_stat = STATUS_LVAR_NOTE_NOT_LAST;
                 return;
             }
         }
 
-        // Check valiable type
-        if (!td->flags.bit0 && ((type == ft_myvarchar) || (type == ft_myvarbinary) ||
-            (type == ft_mywvarchar) || (type == ft_mywvarbinary)))
-            td->optionFlags.bitA = true;
-        if ((type == ft_myblob) || (type == ft_mytext))
-            td->optionFlags.bitB = true;
-
-         // If valiable length then cannot use blob.
-        if (td->flags.bit0 && td->optionFlags.bitB)
+        bool flag =
+            (td->flags.bit0 == true) && (i == (short)(td->fieldCount - 1));
+        if (flag && (type != ft_myvarbinary) && (type != ft_mywvarbinary) &&
+            (type != ft_note) && (type != ft_lvar))
         {
-            m_stat = STATUS_LVAR_NOTE_NOT_LAST;
+            m_stat = STATUS_INVALID_VARIABLETABLE;
             return;
         }
-
+        if ((type == ft_myvarchar) || (type == ft_mywvarchar) ||
+            (type == ft_myvarbinary) || (type == ft_mywvarbinary) ||
+            (type == ft_myfixedbinary))
+            td->optionFlags.bitA = true;
+        if ((type == ft_myblob) || (type == ft_mytext))
+            td->optionFlags.bitB = true;
     }
 
     // Check invalid key type
@@ -301,13 +321,12 @@ void dbdef::updateTableDef(short TableIndex, bool forPsqlDdf)
             m_pdata = td;
             m_buflen = totalDefLength(TableIndex);
             cacheFieldPos(td);
-            td->formatVersion = 1;
+            td->formatVersion = FORMAT_VERSON_CURRENT;
             update();
             m_pdata = m_impl->bdf;
             m_buflen = m_impl->bdfLen;
         }
     }
-
 }
 
 void dbdef::deleteTable(short TableIndex)
@@ -332,7 +351,6 @@ void dbdef::deleteTable(short TableIndex)
             del();
             m_pdata = m_impl->bdf;
             m_buflen = m_impl->bdfLen;
-
         }
     }
     if (m_stat == STATUS_SUCCESS)
@@ -340,7 +358,6 @@ void dbdef::deleteTable(short TableIndex)
         free(tableDefs(TableIndex));
         m_impl->tableDefs[TableIndex] = NULL;
     }
-
 }
 
 void dbdef::renumberFieldNum(short TableIndex, short Index, short op)
@@ -389,7 +406,8 @@ bool dbdef::isUsedField(short TableIndex, short DeleteIndex)
 void dbdef::deleteField(short TableIndex, short DeleteIndex)
 {
     m_stat = STATUS_SUCCESS;
-    if (isUsedField(TableIndex, DeleteIndex) == true) {
+    if (isUsedField(TableIndex, DeleteIndex) == true)
+    {
         m_stat = STATUS_USE_KEYFIELD;
         return;
     }
@@ -401,12 +419,12 @@ void dbdef::deleteField(short TableIndex, short DeleteIndex)
     else
     {
         memmove(&td->fieldDefs[DeleteIndex], &td->fieldDefs[DeleteIndex + 1],
-            totalDefLength(TableIndex) + (char*)td - (char*)&(td->fieldDefs[DeleteIndex + 1]));
+                totalDefLength(TableIndex) + (char*)td -
+                    (char*)&(td->fieldDefs[DeleteIndex + 1]));
     }
     td->fieldCount--;
     td->keyDefs = getKeyDef(tableDefs(TableIndex));
     updateTableDef(TableIndex);
-
 }
 
 void dbdef::deleteKey(short TableIndex, short DeleteIndex)
@@ -416,14 +434,18 @@ void dbdef::deleteKey(short TableIndex, short DeleteIndex)
     if (DeleteIndex != td->keyCount - 1)
     {
         memmove(&td->keyDefs[DeleteIndex], &td->keyDefs[DeleteIndex + 1],
-            totalDefLength(TableIndex) + (char*)td - (char*)&(td->keyDefs[DeleteIndex + 1]));
+                totalDefLength(TableIndex) + (char*)td -
+                    (char*)&(td->keyDefs[DeleteIndex + 1]));
     }
     td->keyCount--;
-    if ((td->primaryKeyNum == DeleteIndex) || (td->primaryKeyNum > td->keyCount - 1))
+    if ((td->primaryKeyNum == DeleteIndex) ||
+        (td->primaryKeyNum > td->keyCount - 1))
         td->primaryKeyNum = -1;
-    if ((td->parentKeyNum == DeleteIndex) || (td->parentKeyNum > td->keyCount - 1))
+    if ((td->parentKeyNum == DeleteIndex) ||
+        (td->parentKeyNum > td->keyCount - 1))
         td->parentKeyNum = -1;
-    if ((td->replicaKeyNum == DeleteIndex) || (td->replicaKeyNum > td->keyCount - 1))
+    if ((td->replicaKeyNum == DeleteIndex) ||
+        (td->replicaKeyNum > td->keyCount - 1))
         td->replicaKeyNum = -1;
 
     updateTableDef(TableIndex);
@@ -453,7 +475,8 @@ void dbdef::insertTable(tabledef* TableDef)
         m_stat = STATUS_TOO_MANY_FIELDS;
         return;
     }
-    m_impl->tableDefs[TableDef->id] = (tabledef*)malloc(USHRT_MAX /* sizeof(tabledef) */);
+    m_impl->tableDefs[TableDef->id] =
+        (tabledef*)malloc(USHRT_MAX /* sizeof(tabledef) */);
     if (m_impl->tableDefs[TableDef->id] == NULL)
     {
         m_stat = STATUS_CANT_ALLOC_MEMORY;
@@ -468,7 +491,7 @@ void dbdef::insertTable(tabledef* TableDef)
             m_impl->tableCount = TableDef->id;
         return;
     }
-    TableDef->formatVersion = 1;
+    TableDef->formatVersion = FORMAT_VERSON_CURRENT;
     if (m_impl->deftype == TYPE_SCHEMA_DDF)
         saveDDF(TableDef->id, 2);
     else
@@ -478,6 +501,8 @@ void dbdef::insertTable(tabledef* TableDef)
 
         memcpy(m_keybuf, &TableDef->id, 2);
         m_buflen = sizeof(tabledef);
+        if (isUseTransactd())
+            m_impl->bdf->varSize = m_buflen - 4;
         insert();
         m_pdata = m_impl->bdf;
         m_buflen = m_impl->bdfLen;
@@ -511,7 +536,6 @@ bool dbdef::resizeAt(short TableIndex, bool key)
         memcpy(p, def, totalDefLength(TableIndex));
         free(def);
         m_impl->tableDefs[TableIndex] = def = (tabledef*)p;
-
     }
     else
     {
@@ -530,13 +554,12 @@ keydef* dbdef::insertKey(short TableIndex, short InsertIndex)
     if (resizeAt(TableIndex, true) == false)
         return NULL;
 
-
     if (InsertIndex < tableDefs(TableIndex)->keyCount)
     {
         memmove(&tableDefs(TableIndex)->keyDefs[InsertIndex + 1],
-            &tableDefs(TableIndex)->keyDefs[InsertIndex],
-            totalDefLength(TableIndex) + (char*)tableDefs(TableIndex) -
-            (char*)&(tableDefs(TableIndex)->keyDefs[InsertIndex]));
+                &tableDefs(TableIndex)->keyDefs[InsertIndex],
+                totalDefLength(TableIndex) + (char*)tableDefs(TableIndex) -
+                    (char*)&(tableDefs(TableIndex)->keyDefs[InsertIndex]));
     }
     tableDefs(TableIndex)->keyCount++;
     memset(&(tableDefs(TableIndex)->keyDefs[InsertIndex]), 0, sizeof(keydef));
@@ -557,8 +580,10 @@ fielddef* dbdef::insertField(short TableIndex, short InsertIndex)
     if ((InsertIndex < td->fieldCount) || (td->keyCount > 0))
     {
 
-        memmove(&(td->fieldDefs[InsertIndex + 1]), &(td->fieldDefs[InsertIndex]),
-            totalDefLength(TableIndex) + (char*)td - (char*)&(td->fieldDefs[InsertIndex]));
+        memmove(&(td->fieldDefs[InsertIndex + 1]),
+                &(td->fieldDefs[InsertIndex]),
+                totalDefLength(TableIndex) + (char*)td -
+                    (char*)&(td->fieldDefs[InsertIndex]));
     }
     td->fieldCount++;
     td->keyDefs = getKeyDef(td);
@@ -567,61 +592,85 @@ fielddef* dbdef::insertField(short TableIndex, short InsertIndex)
     setRecordLen(TableIndex);
     fielddef* fd = &(td->fieldDefs[InsertIndex]);
     fd->setCharsetIndex(td->charsetIndex);
+    fd->setSchemaCodePage(td->schemaCodePage);
     return fd;
 }
 
 int dbdef::totalDefLength(short TableIndex)
 {
-    return (int)(sizeof(tabledef) + (sizeof(fielddef) * tableDefs(TableIndex)->fieldCount) +
-        (sizeof(keydef) * tableDefs(TableIndex)->keyCount));
+    tabledef* td = tableDefs(TableIndex);
+    int len = (int)(sizeof(tabledef) + (sizeof(fielddef) * td->fieldCount) +
+                    (sizeof(keydef) * td->keyCount));
+    if (isUseTransactd())
+        td->varSize = len - 4;
+    return len;
 }
 
-inline fielddef_t_my& dbdef::convert(fielddef_t_my& fd_my, const fielddef_t_pv& fd_pv)
+inline fielddef_t_my& dbdef::convert(fielddef_t_my& fd_my,
+                                     const fielddef_t_pv& fd_pv)
 {
-     memset(&fd_my, 0, sizeof(fd_my));
-	 strcpy(fd_my.m_name, fd_pv.m_name);
-	 void* dest = (char*)&fd_my + sizeof(fd_my.m_name);
-	 const void* src = (char*)&fd_pv + sizeof(fd_pv.m_name);
-	 size_t size = sizeof(fd_my) - sizeof(fd_my.m_name);
-	 memcpy(dest, src, size);
-     return fd_my;
+    memset(&fd_my, 0, sizeof(fd_my));
+    strcpy(fd_my.m_name, fd_pv.m_name);
+    void* dest = (char*)&fd_my + sizeof(fd_my.m_name);
+    const void* src = (char*)&fd_pv + sizeof(fd_pv.m_name);
+    size_t size = sizeof(fd_my) - sizeof(fd_my.m_name);
+    memcpy(dest, src, size);
+    return fd_my;
 }
 
-size_t getNewVersionSize(tabledef* src)
+inline int fixVariableLenBug(bool isUseTransactd, tabledef* src, size_t size)
 {
-    return src->fieldCount * sizeof(fielddef) + sizeof(tabledef)
-           + src->keyCount * sizeof(keydef)+1;
+    if (isUseTransactd)
+    { // A Transactd server format changed to nosupport FIXED_PLUS_VARIABLELEN
+        if (src->pageSize + 4 == (int)size)
+        { // This is a chagned server
+            if (src->preAlloc &&
+                ((src->preAlloc % 512 == 0) || (src->fieldCount > 255) ||
+                 (src->keyCount > 127) || (src->fieldCount == 0)))
+            {
+                // memmove(((char*)src)+4, ((char*)src)+6, src->pageSize-2);
+                memmove(((char*)src) + 2, ((char*)src) + 4, src->pageSize);
+                size -= 2;
+            }
+        }
+    }
+    return (int)size;
+}
 
+size_t getNewVersionSize(tabledef* src)
+{
+    return src->fieldCount * sizeof(fielddef) + sizeof(tabledef) +
+           src->keyCount * sizeof(keydef) + 1;
 }
 
 void dbdef::tableDefCopy(tabledef* dest, tabledef* src, size_t size)
 {
-    if (src->formatVersion == 0)
+
+    if (src->formatVersion == FORMAT_VERSON_BTRV_DEF)
     {
         size_t len = 0;
         memcpy(dest, src, sizeof(tabledef));
         len += sizeof(tabledef);
         fielddef_t_my* fd = (fielddef_t_my*)dbdef::getFieldDef(dest);
         fielddef_t_pv* src_fd = (fielddef_t_pv*)dbdef::getFieldDef(src);
-        for (int i=0;i<dest->fieldCount;++i)
+        for (int i = 0; i < dest->fieldCount; ++i)
         {
-            convert(*fd , *src_fd);
+            convert(*fd, *src_fd);
             len += sizeof(fielddef_t_pv);
             ++fd;
             ++src_fd;
         }
         memcpy(fd, src_fd, size - len);
-        dest->formatVersion = 1;
+        dest->formatVersion = FORMAT_VERSON_CURRENT;
     }
     else
         memcpy(dest, src, size);
-
 }
 
 tabledef** dbdef::tableDefPtr(int index)
 {
-	tableDefs(index);
-	return &m_impl->tableDefs[index];
+    tableDefs(index);
+    return &m_impl->tableDefs[index];
 }
 
 #pragma warn -8004
@@ -664,8 +713,11 @@ tabledef* dbdef::tableDefs(int index)
             m_stat = 0;
             return NULL;
         }
+        m_datalen =
+            fixVariableLenBug(isUseTransactd(), (tabledef*)m_pdata, m_datalen);
 
-        m_impl->tableDefs[index] = def = (tabledef*)malloc(getNewVersionSize((tabledef*)m_pdata));
+        m_impl->tableDefs[index] = def =
+            (tabledef*)malloc(getNewVersionSize((tabledef*)m_pdata));
 
         if (def == NULL)
         {
@@ -675,11 +727,9 @@ tabledef* dbdef::tableDefs(int index)
         tableDefCopy(def, (tabledef*)m_pdata, m_datalen);
         def->fieldDefs = getFieldDef(def);
         def->keyDefs = getKeyDef(def);
-		def->autoIncExSpace = ((database*)nsdb())->defaultAutoIncSpace();
+        def->autoIncExSpace = ((database*)nsdb())->defaultAutoIncSpace();
 
         setCodePage(def);
-
-
     }
     else if (def == (tabledef*)-1)
         return NULL;
@@ -701,7 +751,7 @@ void dbdef::doOpen(const _TCHAR* FullPath, char_td mode, const _TCHAR* OnerName)
         return;
     }
 
-    //version check
+    // version check
     m_impl->version[7] = '0';
     nstable::doOpen(FullPath, mode, m_impl->version);
     if (m_stat == STATUS_INVALID_OWNERNAME)
@@ -753,7 +803,7 @@ void dbdef::create(const _TCHAR* fullpath)
         createDDF(fullpath);
         return;
     }
-    fileSpec *fs;
+    fileSpec* fs;
 
     fs = (fileSpec*)malloc(512);
     memset(fs, 512, 0x00);
@@ -762,17 +812,17 @@ void dbdef::create(const _TCHAR* fullpath)
     fs->indexCount = 1;
     fs->fileFlag.all = 1; // valiable length
     fs->preAlloc = 10;
-    fs->keySpecs[0].keyPos = 1;        // id
-    fs->keySpecs[0].keyLen = 2;        // short
+    fs->keySpecs[0].keyPos = 1; // id
+    fs->keySpecs[0].keyLen = 2; // short
     fs->keySpecs[0].keyFlag.all = 258; // changeable  and extended key type
-    fs->keySpecs[0].keyType = 1;       // Integer
+    fs->keySpecs[0].keyType = 1; // Integer
     nsdb()->createTable(fs, 412, fullpath, 0);
     free(fs);
     if (nsdb()->stat() == 0)
     { // set owner name
         ownerNameSetter* bao = new ownerNameSetter(nsdb());
         bao->open(fullpath);
-        bao->setOwnerName((const _TCHAR*) BDFFORMAT_VERSION);
+        bao->setOwnerName((const _TCHAR*)BDFFORMAT_VERSION);
         bao->release();
     }
     m_stat = nsdb()->stat();
@@ -788,13 +838,13 @@ ushort_td dbdef::getRecordLen(short TableIndex)
 {
     ushort_td ret = 0;
     short i;
-    for (i = 0; i < tableDefs(TableIndex)->fieldCount; i++)
-        ret += tableDefs(TableIndex)->fieldDefs[i].len + tableDefs(TableIndex)
-            ->fieldDefs[i].varLenBytes();
+    tabledef* td = tableDefs(TableIndex);
+    for (i = 0; i < td->fieldCount; i++)
+        ret += td->fieldDefs[i].len + td->fieldDefs[i].varLenBytes();
     return ret;
 }
 
-ushort_td dbdef::getFieldPosition(tabledef *TableDef, short FieldNum)
+ushort_td dbdef::getFieldPosition(tabledef* TableDef, short FieldNum)
 {
     short i;
     ushort_td pos = 1;
@@ -809,7 +859,7 @@ void dbdef::getFileSpec(fileSpec* fs, short TableIndex)
     keydef* KeyDef;
     short i, j, k = 0;
     short FieldNum;
-    tabledef *TableDef = tableDefs(TableIndex);
+    tabledef* TableDef = tableDefs(TableIndex);
     fs->recLen = TableDef->fixedRecordLen;
     fs->pageSize = TableDef->pageSize;
     fs->indexCount = TableDef->keyCount;
@@ -843,7 +893,8 @@ void dbdef::getFileSpec(fileSpec* fs, short TableIndex)
             if (fs->fileFlag.bitA == true)
                 ks->keyNo = KeyDef->keyNumber;
             else
-                ks->keyNo = 0; ;
+                ks->keyNo = 0;
+            ;
             ks->acsNo = 0;
             k++;
         }
@@ -888,21 +939,23 @@ void dbdef::renumberTable(short OldIndex, short NewIndex)
     }
 }
 
-void dbdef::cacheFieldPos(tabledef *TableDef)
+void dbdef::cacheFieldPos(tabledef* TableDef)
 {
 
     short i;
     for (i = 0; i < TableDef->fieldCount; i++)
-        TableDef->fieldDefs[i].pos = (ushort_td)(getFieldPosition(TableDef, i) - 1);
+        TableDef->fieldDefs[i].pos =
+            (ushort_td)(getFieldPosition(TableDef, i) - 1);
 }
 
 short dbdef::fieldNumByViewNum(short TableIndex, short index)
 {
     short i;
-    tabledef *TableDef = tableDefs(TableIndex);
+    tabledef* TableDef = tableDefs(TableIndex);
     for (i = 0; i < TableDef->fieldCount; i++)
     {
-        if ((TableDef->fieldDefs[i].viewNum == index) && (TableDef->fieldDefs[i].enableFlags.bit0))
+        if ((TableDef->fieldDefs[i].viewNum == index) &&
+            (TableDef->fieldDefs[i].enableFlags.bit0))
             return i;
     }
     return -1;
@@ -911,7 +964,7 @@ short dbdef::fieldNumByViewNum(short TableIndex, short index)
 short dbdef::findKeynumByFieldNum(short TableIndex, short index)
 {
     short i;
-    tabledef *TableDef = tableDefs(TableIndex);
+    tabledef* TableDef = tableDefs(TableIndex);
 
     for (i = 0; i < TableDef->keyCount; i++)
     {
@@ -961,64 +1014,81 @@ uint_td dbdef::fieldValidLength(eFieldQuery query, uchar_td FieldType)
     switch (FieldType)
     {
     case ft_string:
-    case ft_mychar: minlen = 1;
+    case ft_mychar:
+        minlen = 1;
         maxlen = 255;
         defaultlen = 1;
         break;
     case ft_lstring:
-    case ft_zstring: minlen = 2;
+    case ft_zstring:
+        minlen = 2;
         maxlen = 255;
         defaultlen = 2;
         break;
     case ft_myvarchar:
-    case ft_myvarbinary: minlen = 1;
-        maxlen = 60000;
+    case ft_myvarbinary:
+        minlen = 1;
+        maxlen = 65535;
         defaultlen = 2;
         break;
     case ft_myblob:
-    case ft_mytext: minlen = 9;
+    case ft_mytext:
+        minlen = 9;
         maxlen = 12;
         defaultlen = 1;
         break;
     case ft_mywchar:
-    case ft_wstring: minlen = 2;
+    case ft_wstring:
+        minlen = 2;
         maxlen = 255;
         defaultlen = 2;
         break;
-    case ft_wzstring: minlen = 3;
+    case ft_wzstring:
+        minlen = 3;
         maxlen = 255;
         defaultlen = 2;
         break;
     case ft_mywvarchar:
-    case ft_mywvarbinary: minlen = 1;
-        maxlen = 60000;
+    case ft_mywvarbinary:
+        minlen = 1;
+        maxlen = 65535;
         defaultlen = 3;
         break;
-
-    case ft_mydate: minlen = 3;
+    case ft_myfixedbinary:
+        minlen = 256;
+        maxlen = 60000;
+        defaultlen = 1024;
+        break;
+    case ft_mydate:
+        minlen = 3;
         maxlen = 3;
         defaultlen = 3;
         break;
-    case ft_integer: minlen = 1;
+    case ft_integer:
+        minlen = 1;
         maxlen = 8;
         defaultlen = 2;
         break;
     case ft_bfloat:
-    case ft_float: minlen = 4;
+    case ft_float:
+        minlen = 4;
         maxlen = 8;
         defaultlen = 4;
         break;
     case ft_date:
-    case ft_time: minlen = 4;
+    case ft_time:
+        minlen = 4;
         maxlen = 4;
         defaultlen = 4;
         break;
-    case ft_mytime: minlen = 3;
+    case ft_mytime:
+        minlen = 3;
         maxlen = 6;
         defaultlen = 4;
         break;
     case ft_money:
-    case ft_decimal: minlen = 1;
+    case ft_decimal:
+        minlen = 1;
         maxlen = 10;
         defaultlen = 6;
         if (FieldType == 5)
@@ -1026,13 +1096,15 @@ uint_td dbdef::fieldValidLength(eFieldQuery query, uchar_td FieldType)
         else
             dec = 2;
         break;
-    case ft_logical: minlen = 1;
+    case ft_logical:
+        minlen = 1;
         maxlen = 2;
         defaultlen = 2;
         break;
     case ft_numericsts:
     case ft_numericsa:
-    case ft_numeric: minlen = 1;
+    case ft_numeric:
+        minlen = 1;
         maxlen = 15;
         defaultlen = 6;
         dec = 0;
@@ -1040,72 +1112,84 @@ uint_td dbdef::fieldValidLength(eFieldQuery query, uchar_td FieldType)
             minlen = 2;
         break;
 
-    case ft_note: minlen = 2;
+    case ft_note:
+        minlen = 2;
         maxlen = 32761;
         defaultlen = 2;
         break;
-    case ft_lvar: minlen = 5;
+    case ft_lvar:
+        minlen = 5;
         maxlen = 32761;
         defaultlen = 5;
         break;
-    case ft_uinteger: minlen = 1;
+    case ft_uinteger:
+        minlen = 1;
         maxlen = 8;
         defaultlen = 2;
         break;
     case ft_autoIncUnsigned:
-    case ft_autoinc: minlen = 2;
+    case ft_autoinc:
+        minlen = 2;
         maxlen = 8;
         defaultlen = 4;
         break;
-    case ft_bit: minlen = 1;
+    case ft_bit:
+        minlen = 1;
         maxlen = 1;
         defaultlen = 1;
         break;
     case ft_timestamp:
-    case ft_currency: minlen = 8;
+    case ft_currency:
+        minlen = 8;
         maxlen = 8;
         defaultlen = 8;
         break;
-    case ft_mytimestamp: minlen = 4;
+    case ft_mytimestamp:
+        minlen = 4;
         maxlen = 7;
         defaultlen = 7;
         break;
-    case ft_mydatetime: minlen = 5;
+    case ft_mydatetime:
+        minlen = 5;
         maxlen = 8;
         defaultlen = 5;
         break;
 
-    case ft_nullindicator: minlen = 0;
+    case ft_nullindicator:
+        minlen = 0;
         maxlen = 0;
         defaultlen = 0;
     }
     switch (query)
     {
-    case eMinlen: return minlen;
-    case eMaxlen: return maxlen;
-    case eDefaultlen: return defaultlen;
-    case eDecimals: return dec;
+    case eMinlen:
+        return minlen;
+    case eMaxlen:
+        return maxlen;
+    case eDefaultlen:
+        return defaultlen;
+    case eDecimals:
+        return dec;
     }
     return 0;
-
 }
 
 bool dbdef::validLen(uchar_td FieldType, uint_td FieldLen)
 { // return valid length of field by field type.
-    if ((FieldLen >= fieldValidLength(eMinlen, FieldType)) && (FieldLen <= fieldValidLength(eMaxlen,
-        FieldType)))
+    if ((FieldLen >= fieldValidLength(eMinlen, FieldType)) &&
+        (FieldLen <= fieldValidLength(eMaxlen, FieldType)))
     {
         if ((FieldType == ft_integer) || (FieldType == ft_uinteger))
         {
-            if ((FieldLen == 1) || (FieldLen == 2) || (FieldLen == 4) || (FieldLen == 8))
+            if ((FieldLen == 1) || (FieldLen == 2) || (FieldLen == 4) ||
+                (FieldLen == 8))
                 return true;
             else
                 return false;
-
         }
         else if ((FieldType == ft_autoinc) || (FieldType == ft_autoIncUnsigned))
         {
-            if ((FieldLen == 2) || (FieldLen == 4)|| (FieldLen == 8))
+            if ((FieldLen == 2) || (FieldLen == 4) || (FieldLen == 8))
                 return true;
             else
                 return false;
@@ -1125,8 +1209,8 @@ bool dbdef::validLen(uchar_td FieldType, uint_td FieldLen)
 
 bool dbdef::isPassKey(uchar_td FieldType)
 {
-    if (FieldType == ft_bit)
-        return false;
+    if (FieldType == ft_autoIncUnsigned)
+        return true;
     if (FieldType == ft_wstring)
         return true;
     if (FieldType == ft_wzstring)
@@ -1155,7 +1239,11 @@ bool dbdef::isPassKey(uchar_td FieldType)
         return true;
     if (FieldType == ft_mydatetime)
         return true;
+    if (FieldType == ft_myfixedbinary)
+        return false;
 
+    if (FieldType == ft_bit)
+        return false;
     if (FieldType > ft_numericsts)
         return false;
     if (FieldType == ft_note)
@@ -1165,7 +1253,10 @@ bool dbdef::isPassKey(uchar_td FieldType)
     return true;
 }
 
-void dbdef::autoMakeSchema() {tdap(TD_AUTOMEKE_SCHEMA);}
+void dbdef::autoMakeSchema()
+{
+    tdap(TD_AUTOMEKE_SCHEMA);
+}
 
 void dbdef::createDDF(const _TCHAR* fullpath)
 {
@@ -1201,7 +1292,6 @@ void dbdef::createDDF(const _TCHAR* fullpath)
         fd->release();
     if (id)
         id->release();
-
 }
 
 void dbdef::saveDDF(short TableIndex, short opration, bool forPsqlDdf)
@@ -1213,7 +1303,7 @@ void dbdef::saveDDF(short TableIndex, short opration, bool forPsqlDdf)
     ushort_td keyid;
     ushort_td segid;
     ushort_td pos;
-    const _TUCHAR* own[3];
+    const _TCHAR* own[3];
 
     m_stat = STATUS_SUCCESS;
     tabledef* TableDef;
@@ -1228,9 +1318,9 @@ void dbdef::saveDDF(short TableIndex, short opration, bool forPsqlDdf)
     {
         if (m_impl->userName[0] != 0x00)
         {
-            own[0] = (const _TUCHAR*)m_impl->userName;
-            own[1] = (const _TUCHAR*)m_impl->userName;
-            own[2] = (const _TUCHAR*)m_impl->userName;
+            own[0] = (const _TCHAR*)m_impl->userName;
+            own[1] = (const _TCHAR*)m_impl->userName;
+            own[2] = (const _TCHAR*)m_impl->userName;
         }
         else
         {
@@ -1238,11 +1328,14 @@ void dbdef::saveDDF(short TableIndex, short opration, bool forPsqlDdf)
             own[1] = ow1;
             own[2] = ow2;
         }
-        tb->open(((database*)nsdb())->rootDir(), (char_td)Mode, (const _TCHAR*) own[0]);
+        tb->open(((database*)nsdb())->rootDir(), (char_td)Mode,
+                 (const _TCHAR*)own[0]);
         chOpen += tb->stat();
-        fd->open(((database*)nsdb())->rootDir(), (char_td)Mode, (const _TCHAR*)own[1]);
+        fd->open(((database*)nsdb())->rootDir(), (char_td)Mode,
+                 (const _TCHAR*)own[1]);
         chOpen += fd->stat();
-        id->open(((database*)nsdb())->rootDir(), (char_td)Mode, (const _TCHAR*)own[2]);
+        id->open(((database*)nsdb())->rootDir(), (char_td)Mode,
+                 (const _TCHAR*)own[2]);
         chOpen += id->stat();
         if (chOpen)
         {
@@ -1253,11 +1346,10 @@ void dbdef::saveDDF(short TableIndex, short opration, bool forPsqlDdf)
             return;
         }
 
-        //erase all records
+        // erase all records
         nsdb()->beginTrn(200);
         tb->setKeyNum(0);
 
-
         tb->setStat(0);
         fd->setStat(0);
         id->setStat(0);
@@ -1272,7 +1364,7 @@ void dbdef::saveDDF(short TableIndex, short opration, bool forPsqlDdf)
             strcpy(tb->tablename, TableDef->tableNameA());
             strcpy(tb->filename, TableDef->fileNameA());
             if (forPsqlDdf)
-                tb->flag = 0;//PSQL are reading flags from table files.
+                tb->flag = 0; // PSQL are reading flags from table files.
             else
                 tb->flag = TableDef->flags.all;
             if (tb->stat() == STATUS_SUCCESS)
@@ -1303,7 +1395,7 @@ void dbdef::saveDDF(short TableIndex, short opration, bool forPsqlDdf)
                 {
                     FieldDef = &TableDef->fieldDefs[fdid];
                     if (FieldDef->ddfid == 0)
-                    FieldDef->ddfid = getDDFNewFieldIndex();
+                        FieldDef->ddfid = getDDFNewFieldIndex();
                     fd->fieldid = FieldDef->ddfid;
                     fd->fileid = tb->id;
                     strcpy(fd->name, FieldDef->nameA());
@@ -1317,7 +1409,7 @@ void dbdef::saveDDF(short TableIndex, short opration, bool forPsqlDdf)
                     fd->flag = 0;
                     fd->insert();
                     if (fd->stat())
-                    goto JmpErr;
+                        goto JmpErr;
                 }
             }
             // delete keys.
@@ -1338,12 +1430,15 @@ void dbdef::saveDDF(short TableIndex, short opration, bool forPsqlDdf)
                     id->keyid = keyid;
                     for (segid = 0; segid < KeyDef->segmentCount; segid++)
                     {
-                    id->fieldid = TableDef->fieldDefs[KeyDef->segments[segid].fieldNum].ddfid;
-                    id->segmentnum = segid;
-                    id->flag = KeyDef->segments[segid].flags.all;
-                    id->insert();
-                    if (id->stat())
-                    goto JmpErr;
+                        id->fieldid =
+                            TableDef
+                                ->fieldDefs[KeyDef->segments[segid].fieldNum]
+                                .ddfid;
+                        id->segmentnum = segid;
+                        id->flag = KeyDef->segments[segid].flags.all;
+                        id->insert();
+                        if (id->stat())
+                            goto JmpErr;
                     }
                 }
             }
@@ -1363,7 +1458,6 @@ void dbdef::saveDDF(short TableIndex, short opration, bool forPsqlDdf)
         fd->release();
     if (id)
         id->release();
-
 }
 
 void dbdef::openDdf(const _TCHAR* dir, short Mode, const _TCHAR* OwnerName)
@@ -1419,7 +1513,7 @@ void dbdef::openDdf(const _TCHAR* dir, short Mode, const _TCHAR* OwnerName)
             return;
         }
 
-        tb->setKeyNum(1);
+        tb->setKeyNum(0);
         tb->seekFirst();
         while (tb->stat() == 0)
         { // Inser table
@@ -1439,7 +1533,6 @@ void dbdef::openDdf(const _TCHAR* dir, short Mode, const _TCHAR* OwnerName)
             if (m_stat != 0)
                 break;
 
-
             fd->setKeyNum(1);
             fd->fileid = tb->id;
             fd->seekGreater(true);
@@ -1450,9 +1543,11 @@ void dbdef::openDdf(const _TCHAR* dir, short Mode, const _TCHAR* OwnerName)
 
                 if (fd->type != ft_nullindicator)
                 {
-                    for (FieldIndex = 0; FieldIndex < tableDefs(tbid)->fieldCount; FieldIndex++)
+                    for (FieldIndex = 0;
+                         FieldIndex < tableDefs(tbid)->fieldCount; FieldIndex++)
                     {
-                        if (tableDefs(tbid)->fieldDefs[FieldIndex].pos > fd->pos)
+                        if (tableDefs(tbid)->fieldDefs[FieldIndex].pos >
+                            fd->pos)
                             break;
                     }
                     FieldDef = insertField(tbid, FieldIndex);
@@ -1475,8 +1570,10 @@ void dbdef::openDdf(const _TCHAR* dir, short Mode, const _TCHAR* OwnerName)
 
                         KeyDef = &(tableDefs(tbid)->keyDefs[id->keyid]);
                         if (KeyDef->segmentCount < id->segmentnum + 1)
-                            KeyDef->segmentCount = (uchar_td)(id->segmentnum + 1);
-                        KeyDef->segments[id->segmentnum].fieldNum = (uchar_td)FieldIndex;
+                            KeyDef->segmentCount =
+                                (uchar_td)(id->segmentnum + 1);
+                        KeyDef->segments[id->segmentnum].fieldNum =
+                            (uchar_td)FieldIndex;
                         KeyDef->segments[id->segmentnum].flags.all = id->flag;
                         id->seekNext();
                     }
@@ -1504,18 +1601,18 @@ void dbdef::openDdf(const _TCHAR* dir, short Mode, const _TCHAR* OwnerName)
                 }
             }
 
-
             for (short i = tableDefs(tbid)->fieldCount - 1; i >= 0; i--)
             {
                 short pos = tableDefs(tbid)->fieldDefs[i].pos;
                 short startPos = 0;
                 if (i > 0)
                     startPos = tableDefs(tbid)->fieldDefs[i - 1].pos +
-                    tableDefs(tbid)->fieldDefs[i - 1].len;
+                               tableDefs(tbid)->fieldDefs[i - 1].len;
                 if (tableDefs(tbid)->fieldDefs[i].len && (startPos != pos))
                 {
                     FieldDef = insertField(tbid, i);
-                    sprintf_s((char*)FieldDef->nameA(), FIELD_NAME_SIZE, "NIS%d", i + 1);
+                    sprintf_s((char*)FieldDef->nameA(), FIELD_NAME_SIZE,
+                              "NIS%d", i + 1);
 
                     FieldDef->type = ft_nullindicator;
                     FieldDef->len = 1;
@@ -1569,7 +1666,7 @@ ushort_td dbdef::getDDFNewFieldIndex()
                 for (j = 0; j < tableDefs(i)->fieldCount; j++)
                 {
                     if (tableDefs(i)->fieldDefs[j].ddfid > m_impl->maxid)
-                    m_impl->maxid = tableDefs(i)->fieldDefs[j].ddfid;
+                        m_impl->maxid = tableDefs(i)->fieldDefs[j].ddfid;
                 }
             }
         }
@@ -1596,9 +1693,10 @@ void dbdef::pushBackup(short TableIndex)
 
     blen = totalDefLength(TableIndex);
     if (!tableDefs(TABLE_NUM_TMP))
-        m_impl->tableDefs[TABLE_NUM_TMP] = (tabledef*) malloc(blen);
+        m_impl->tableDefs[TABLE_NUM_TMP] = (tabledef*)malloc(blen);
     else
-        m_impl->tableDefs[TABLE_NUM_TMP] = (tabledef*)realloc(tableDefs(TABLE_NUM_TMP), blen);
+        m_impl->tableDefs[TABLE_NUM_TMP] =
+            (tabledef*)realloc(tableDefs(TABLE_NUM_TMP), blen);
     if (!tableDefs(TABLE_NUM_TMP))
     {
         m_stat = STATUS_CANT_ALLOC_MEMORY;
@@ -1618,30 +1716,45 @@ bool dbdef::compAsBackup(short TableIndex)
     int len2 = totalDefLength(TableIndex);
     if (len != len2)
         return true;
-    else if (memcmp(tableDefs(TABLE_NUM_TMP), tableDefs(TableIndex), len) != 0)
+    tabledef* tds = tableDefs(TableIndex);
+    tabledef* tdo = tableDefs(TABLE_NUM_TMP);
+
+    if (memcmp(tds, tdo, ((char*)(&(tdo->fieldDefs))) - ((char*)tdo)))
         return true;
+
+    for (int i = 0; i < tds->fieldCount; i++)
+    {
+        if (memcmp(&tds->fieldDefs[i], &tdo->fieldDefs[i], sizeof(fielddef)))
+            return true;
+    }
+    for (int i = 0; i < tds->keyCount; i++)
+    {
+        if (memcmp(&tds->keyDefs[i], &tdo->keyDefs[i], sizeof(keydef)))
+            return true;
+    }
     return false;
 }
 
 void dbdef::popBackup(short TableIndex)
 {
     int len = totalDefLength(TABLE_NUM_TMP);
-    m_impl->tableDefs[TableIndex] = (tabledef*)realloc(tableDefs(TableIndex), len);
+    m_impl->tableDefs[TableIndex] =
+        (tabledef*)realloc(tableDefs(TableIndex), len);
     memcpy(tableDefs(TableIndex), tableDefs(TABLE_NUM_TMP), len);
     tableDefs(TableIndex)->fieldDefs = getFieldDef(tableDefs(TableIndex));
     tableDefs(TableIndex)->keyDefs = getKeyDef(tableDefs(TableIndex));
 
     updateTableDef(TableIndex);
 }
+
 void dbdef::reopen(char_td mode)
 {
     close();
     open(uri(), mode, NULL);
 }
 
-
-}// namespace client
-}// namespace tdap
-}// namespace protocol
-}// namespace db
-}// namespace bzs
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs