transactd 3.1.0 → 3.2.0

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

@@ -105,10 +105,11 @@ struct dbdimple
     }
 };
 
-dbdef::dbdef(nsdatabase* pbe, short DefType) : nstable(pbe)
+dbdef::dbdef(nsdatabase* pbe, short defType) : nstable(pbe)
 {
     m_dimpl = new dbdimple();
-    m_dimpl->deftype = DefType;
+    m_dimpl->deftype = defType;
+    m_dimpl->noWriteMode = (m_dimpl->deftype == TYPE_SCHEMA_BDF_NOPRELOAD);
     m_keybuflen = 128;
     m_keybuf = &m_dimpl->keybuf[0];
     setShared();
@@ -120,11 +121,6 @@ dbdef::~dbdef()
     m_dimpl = NULL;
 }
 
-void dbdef::setDefType(short defType)
-{
-    m_dimpl->deftype = defType;
-}
-
 short dbdef::tableCount() const
 {
     return m_dimpl->tableCount;
@@ -236,10 +232,10 @@ bool dbdef::testTablePtr(tabledef* td)
     return true;
 }
 
-short dbdef::validateTableDef(short TableIndex)
+short dbdef::validateTableDef(short tableIndex)
 {
     m_stat = STATUS_SUCCESS;
-    tabledef* td = tableDefs(TableIndex);
+    tabledef* td = tableDefs(tableIndex);
     if (!testTablePtr(td)) return m_stat;
 
     td->optionFlags.bitA = false; // reset valiable type
@@ -247,7 +243,7 @@ short dbdef::validateTableDef(short TableIndex)
     for (short i = 0; i < td->fieldCount; ++i)
     {
         const fielddef& fd = td->fieldDefs[i];
-        short ret = fieldNumByName(TableIndex, fd.name());
+        short ret = fieldNumByName(tableIndex, fd.name());
         if ((ret != -1) && (ret != i))
         {
             m_stat = STATUS_DUPLICATE_FIELDNAME;
@@ -344,7 +340,7 @@ short dbdef::validateTableDef(short TableIndex)
     // Chack duplicate table name.
     for (short i = 1; i < m_dimpl->tableCount; i++)
     {
-        if ((tableDefs(i)) && (i != TableIndex))
+        if ((tableDefs(i)) && (i != tableIndex))
         {
             m_stat = 0;
             if (strcmp(tableDefs(i)->tableNameA(), td->tableNameA()) == 0)
@@ -359,21 +355,22 @@ short dbdef::validateTableDef(short TableIndex)
     return m_stat;
 }
 
-void dbdef::updateTableDef(short TableIndex, bool forPsqlDdf)
+void dbdef::updateTableDef(short tableIndex, bool forPsqlDdf)
 {
-    if ((m_stat = validateTableDef(TableIndex)) != 0)
+    if ((m_stat = validateTableDef(tableIndex)) != 0)
         return;
 
-    tabledef* td = tableDefs(TableIndex);
+    tabledef* td = tableDefs(tableIndex);
     if (!testTablePtr(td)) return;
 
     if (m_dimpl->noWriteMode)
     {
-        m_stat = STATUS_ACCESS_DENIED;
+        if (m_dimpl->deftype != TYPE_SCHEMA_BDF_NOPRELOAD)
+            m_stat = STATUS_ACCESS_DENIED;
         return;
     }
     if (m_dimpl->deftype == TYPE_SCHEMA_DDF)
-        saveDDF(TableIndex, 3, forPsqlDdf);
+        saveDDF(tableIndex, 3, forPsqlDdf);
     else
     {
         moveById(td->id);
@@ -389,21 +386,21 @@ void dbdef::updateTableDef(short TableIndex, bool forPsqlDdf)
             m_pdata = m_dimpl->bdf;
             m_buflen = m_dimpl->bdfLen;
             if (m_stat == STATUS_SUCCESS)
-                setDefaultImage(TableIndex, NULL, 0);
+                setDefaultImage(tableIndex, NULL, 0);
         }
     }
 }
 
-void dbdef::deleteTable(short TableIndex)
+void dbdef::deleteTable(short tableIndex)
 {
-    tabledef* td = tableDefs(TableIndex); 
+    tabledef* td = tableDefs(tableIndex);
     if (!testTablePtr(td)) return;
 
     m_stat = STATUS_SUCCESS;
     if (m_dimpl->noWriteMode == false)
     {
         if (m_dimpl->deftype == TYPE_SCHEMA_DDF)
-            saveDDF(TableIndex, 4);
+            saveDDF(tableIndex, 4);
         else
         {
             moveById(td->id);
@@ -419,18 +416,18 @@ void dbdef::deleteTable(short TableIndex)
     }
     if (m_stat == STATUS_SUCCESS)
     {
-        setDefaultImage(TableIndex, NULL, 0);
+        setDefaultImage(tableIndex, NULL, 0);
         free(td);
-        m_dimpl->tableDefs[TableIndex] = NULL;
+        m_dimpl->tableDefs[tableIndex] = NULL;
     }
 }
 
-void dbdef::renumberFieldNum(short TableIndex, short Index, short op)
+void dbdef::renumberFieldNum(short tableIndex, short Index, short op)
 {
     int i, j;
     keydef* KeyDef;
 
-    tabledef* td = tableDefs(TableIndex);
+    tabledef* td = tableDefs(tableIndex);
     if (!testTablePtr(td)) return;
 
     for (i = 0; i < td->keyCount; i++)
@@ -454,11 +451,11 @@ void dbdef::renumberFieldNum(short TableIndex, short Index, short op)
     }
 }
 
-bool dbdef::isUsedField(short TableIndex, short DeleteIndex)
+bool dbdef::isUsedField(short tableIndex, short deleteIndex)
 {
     int i, j;
     keydef* KeyDef;
-    tabledef* td = tableDefs(TableIndex);
+    tabledef* td = tableDefs(tableIndex);
     if (!testTablePtr(td)) return false;
 
     for (i = 0; i < td->keyCount; i++)
@@ -466,60 +463,60 @@ bool dbdef::isUsedField(short TableIndex, short DeleteIndex)
         KeyDef = &(td->keyDefs[i]);
         for (j = 0; j < KeyDef->segmentCount; j++)
         {
-            if (KeyDef->segments[j].fieldNum == DeleteIndex)
+            if (KeyDef->segments[j].fieldNum == deleteIndex)
                 return true;
         }
     }
     return false;
 }
 
-void dbdef::deleteField(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;
     }
-    renumberFieldNum(TableIndex, DeleteIndex, 4);
-    tabledef* td = tableDefs(TableIndex);
-    if ((DeleteIndex == td->fieldCount - 1) && (td->keyCount == 0))
+    renumberFieldNum(tableIndex, deleteIndex, 4);
+    tabledef* td = tableDefs(tableIndex);
+    if ((deleteIndex == td->fieldCount - 1) && (td->keyCount == 0))
     {
     }
     else
     {
-        memmove(&td->fieldDefs[DeleteIndex], &td->fieldDefs[DeleteIndex + 1],
+        memmove(&td->fieldDefs[deleteIndex], &td->fieldDefs[deleteIndex + 1],
                 td->size() + (char*)td -
-                    (char*)&(td->fieldDefs[DeleteIndex + 1]));
+                    (char*)&(td->fieldDefs[deleteIndex + 1]));
     }
     td->fieldCount--;
     td->setKeydefsPtr();
-    updateTableDef(TableIndex);
+    updateTableDef(tableIndex);
 }
 
-void dbdef::deleteKey(short TableIndex, short DeleteIndex)
+void dbdef::deleteKey(short tableIndex, short deleteIndex)
 {
     m_stat = STATUS_SUCCESS;
-    tabledef* td = tableDefs(TableIndex);
+    tabledef* td = tableDefs(tableIndex);
     if (!testTablePtr(td)) return ;
-    if (DeleteIndex != td->keyCount - 1)
+    if (deleteIndex != td->keyCount - 1)
     {
-        memmove(&td->keyDefs[DeleteIndex], &td->keyDefs[DeleteIndex + 1],
+        memmove(&td->keyDefs[deleteIndex], &td->keyDefs[deleteIndex + 1],
                 td->size() + (char*)td -
-                    (char*)&(td->keyDefs[DeleteIndex + 1]));
+                    (char*)&(td->keyDefs[deleteIndex + 1]));
     }
     td->keyCount--;
-    if ((td->primaryKeyNum == DeleteIndex) ||
+    if ((td->primaryKeyNum == deleteIndex) ||
         (td->primaryKeyNum > td->keyCount - 1))
         td->primaryKeyNum = -1;
-    if ((td->parentKeyNum == DeleteIndex) ||
+    if ((td->parentKeyNum == deleteIndex) ||
         (td->parentKeyNum > td->keyCount - 1))
         td->parentKeyNum = -1;
-    if ((td->replicaKeyNum == DeleteIndex) ||
+    if ((td->replicaKeyNum == deleteIndex) ||
         (td->replicaKeyNum > td->keyCount - 1))
         td->replicaKeyNum = -1;
 
-    updateTableDef(TableIndex);
+    updateTableDef(tableIndex);
 }
 
 void dbdef::insertTable(tabledef* td)
@@ -557,6 +554,7 @@ void dbdef::insertTable(tabledef* td)
     if ((td->ddfid == 0) && (m_dimpl->deftype == TYPE_SCHEMA_DDF))
         td->ddfid = getDDFNewTableIndex();
     memcpy(m_dimpl->tableDefs[td->id], td, sizeof(tabledef));
+    m_dimpl->tableDefs[td->id]->defaultImage = NULL;
     if (m_dimpl->noWriteMode)
     {
         if (m_dimpl->tableCount < td->id)
@@ -589,10 +587,12 @@ void dbdef::insertTable(tabledef* td)
     }
 }
 
-bool dbdef::resizeAt(short TableIndex, bool key)
+bool dbdef::resizeAt(short tableIndex, bool key)
 {
-    tabledef* def = m_dimpl->tableDefs[TableIndex];
-    if (!key && def->m_inUse != 0) return false;
+    tabledef* td = m_dimpl->tableDefs[tableIndex];
+    if (!testTablePtr(td)) return false;
+
+    if (!key && td->m_inUse != 0) return false;
 
     uint_td addsize;
 
@@ -601,64 +601,64 @@ bool dbdef::resizeAt(short TableIndex, bool key)
     else
         addsize = sizeof(fielddef);
 
-    uint_td size = def->size() + addsize;
- 
+    uint_td size = td->size() + addsize;
+
     void* p = malloc(size);
     if (p)
     {
-        memcpy(p, def, def->size());
-        free(def);
-        m_dimpl->tableDefs[TableIndex] = def = (tabledef*)p;
+        memcpy(p, td, td->size());
+        free(td);
+        m_dimpl->tableDefs[tableIndex] = td = (tabledef*)p;
         // init for memcpy
-        def->setFielddefsPtr();
-        def->setKeydefsPtr();
+        td->setFielddefsPtr();
+        td->setKeydefsPtr();
         return true;
     }
     m_stat = STATUS_CANT_ALLOC_MEMORY;
     return false;
 }
 
-keydef* dbdef::insertKey(short TableIndex, short InsertIndex)
+keydef* dbdef::insertKey(short tableIndex, short insertIndex)
 {
-    if (resizeAt(TableIndex, true) == false)
+    if (resizeAt(tableIndex, true) == false)
         return NULL;
 
-    tabledef* td = m_dimpl->tableDefs[TableIndex];
-    if (InsertIndex < tableDefs(TableIndex)->keyCount)
+    tabledef* td = m_dimpl->tableDefs[tableIndex];
+    if (insertIndex < tableDefs(tableIndex)->keyCount)
     {
-        memmove(&td->keyDefs[InsertIndex + 1],
-                &td->keyDefs[InsertIndex],
-                td->size() + (char*)td - (char*)&(td->keyDefs[InsertIndex]));
+        memmove(&td->keyDefs[insertIndex + 1],
+                &td->keyDefs[insertIndex],
+                td->size() + (char*)td - (char*)&(td->keyDefs[insertIndex]));
     }
     td->keyCount++;
-    memset(&(td->keyDefs[InsertIndex]), 0, sizeof(keydef));
+    memset(&(td->keyDefs[insertIndex]), 0, sizeof(keydef));
 
     if ((!m_dimpl->noWriteMode) && (m_dimpl->deftype != TYPE_SCHEMA_DDF))
-        updateTableDef(TableIndex);
+        updateTableDef(tableIndex);
     else
         td->calcReclordlen();
-    return &(td->keyDefs[InsertIndex]);
+    return &(td->keyDefs[insertIndex]);
 }
 
-fielddef* dbdef::insertField(short TableIndex, short InsertIndex)
+fielddef* dbdef::insertField(short tableIndex, short insertIndex)
 {
-    if (resizeAt(TableIndex, false) == false)
+    if (resizeAt(tableIndex, false) == false)
         return NULL;
 
-    tabledef* td = tableDefs(TableIndex);
-    if ((InsertIndex < td->fieldCount) || (td->keyCount > 0))
+    tabledef* td = tableDefs(tableIndex);
+    if ((insertIndex < td->fieldCount) || (td->keyCount > 0))
     {
 
-        memmove(&(td->fieldDefs[InsertIndex + 1]),
-                &(td->fieldDefs[InsertIndex]),
+        memmove(&(td->fieldDefs[insertIndex + 1]),
+                &(td->fieldDefs[insertIndex]),
                 td->size() + (char*)td -
-                    (char*)&(td->fieldDefs[InsertIndex]));
+                    (char*)&(td->fieldDefs[insertIndex]));
     }
     td->fieldCount++;
     td->setKeydefsPtr();
-    renumberFieldNum(TableIndex, InsertIndex, 2);
-    memset(&(td->fieldDefs[InsertIndex]), 0, sizeof(fielddef));
-    fielddef* fd = &(td->fieldDefs[InsertIndex]);
+    renumberFieldNum(tableIndex, insertIndex, 2);
+    memset(&(td->fieldDefs[insertIndex]), 0, sizeof(fielddef));
+    fielddef* fd = &(td->fieldDefs[insertIndex]);
     fd->setCharsetIndex(td->charsetIndex);
     fd->setSchemaCodePage(td->schemaCodePage);
     fd->setPadCharSettings(false, true);
@@ -809,6 +809,7 @@ tabledef* dbdef::tableDefs(int index)
 
 void dbdef::doOpen(const _TCHAR* uri, char_td mode, const _TCHAR* onerName)
 {
+    assert((m_dimpl->deftype != TYPE_SCHEMA_BDF_NOPRELOAD));
     m_dimpl->noWriteMode = true;
 
     if (m_dimpl->deftype == TYPE_SCHEMA_DDF)
@@ -988,9 +989,9 @@ void dbdef::renumberTable(short OldIndex, short NewIndex)
     }
 }
 
-short dbdef::fieldNumByViewNum(short TableIndex, short index)
+short dbdef::fieldNumByViewNum(short tableIndex, short index)
 {
-    tabledef* td = tableDefs(TableIndex);
+    tabledef* td = tableDefs(tableIndex);
     if (td)
     {
         for (short i = 0; i < td->fieldCount; i++)
@@ -1003,9 +1004,9 @@ short dbdef::fieldNumByViewNum(short TableIndex, short index)
     return -1;
 }
 
-short dbdef::findKeynumByFieldNum(short TableIndex, short index)
+short dbdef::findKeynumByFieldNum(short tableIndex, short index)
 {
-    tabledef* td = tableDefs(TableIndex);
+    tabledef* td = tableDefs(tableIndex);
     if (td)
         return td->findKeynumByFieldNum(index);
     return -1;
@@ -1027,9 +1028,9 @@ short dbdef::tableNumByName(const _TCHAR* tableName)
     return -1;
 }
 
-short dbdef::fieldNumByName(short TableIndex, const _TCHAR* name)
+short dbdef::fieldNumByName(short tableIndex, const _TCHAR* name)
 {
-    tabledef* td = tableDefs(TableIndex);
+    tabledef* td = tableDefs(tableIndex);
     if (td)
         return td->fieldNumByName(name);
     return -1;
@@ -1316,11 +1317,11 @@ void dbdef::createDDF(const _TCHAR* fullpath)
         id->release();
 }
 
-void dbdef::saveDDF(short TableIndex, short opration, bool forPsqlDdf)
+void dbdef::saveDDF(short tableIndex, short opration, bool forPsqlDdf)
 {
     ushort_td chOpen = 0;
     short Mode = 0;
-    ushort_td tbid = TableIndex;
+    ushort_td tbid = tableIndex;
     ushort_td fdid;
     ushort_td keyid;
     ushort_td segid;
@@ -1789,11 +1790,18 @@ void dbdef::reopen(char_td mode)
 
 void dbdef::synchronizeSeverSchema(short tableIndex)
 {
-    if (!isUseTransactd()) return;
+    if (isUseTransactd() == false)
+    {
+        m_stat = STATUS_NOSUPPORT_OP;
+        return ;
+    }
 
     tabledef* tdold = tableDefs(tableIndex);
-    if (!tdold) return;
-
+    if (!tdold)
+    {
+        m_stat = STATUS_INVALID_TABLE_IDX;
+        return;
+    }
     void* tmp = m_keybuf;
 
     _TCHAR dummyUrl[MAX_PATH] = _T("tdap://srv/db?dbfile=");

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

@@ -77,7 +77,6 @@ class DLLLIB dbdef : private nstable
     dbdef(nsdatabase* pbe, short defType);
     void create(const _TCHAR* uri);
     void autoMakeSchema(bool noUseNullkey);
-    void setDefType(short defType);
     bool testTablePtr(tabledef* td);
     tabledef* initReadAfter(short tableIndex, const tabledef* data, uint_td datalen);
     void* getBufferPtr(uint_td& size);
@@ -97,7 +96,7 @@ public:
     int version() const;
 
     inline short_td stat() const { return m_stat; }
-    short validateTableDef(short TableIndex);
+    short validateTableDef(short tableIndex);
     void updateTableDef(short tableIndex, bool forPsqlDdf = true);
     fielddef* insertField(short tableIndex, short insertIndex);
     void deleteField(short tableIndex, short deleteIndex);

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

@@ -368,8 +368,9 @@ extern "C" PACKAGE_OSX short_td __STDCALL
                 client_t->reconnect();
             else
                 client_t->cmdConnect();
-            if (client_t->req().keyNum == LG_SUBOP_DISCONNECT_EX)
-                return 0;
+            if ((client_t->req().keyNum == LG_SUBOP_ASSOCIATE) ||
+                    (client_t->req().keyNum == LG_SUBOP_DISCONNECT_EX))
+                return STATUS_SUCCESS;
             break;
         }
         case TD_RECONNECT:
@@ -378,8 +379,7 @@ extern "C" PACKAGE_OSX short_td __STDCALL
             break;
         }
         case TD_STASTISTICS:
-            client_t->req().paramMask =
-                P_MASK_DATALEN | P_MASK_KEYBUF | P_MASK_KEYNUM;
+            client_t->req().paramMask = P_MASK_DATALEN | P_MASK_KEYBUF | P_MASK_KEYNUM;
             break;
         case TD_RESET_CLIENT:
         case TD_GETDIRECTORY:
@@ -396,7 +396,11 @@ extern "C" PACKAGE_OSX short_td __STDCALL
             break;
         case TD_GET_SCHEMA:
             if (client_t->isSupportFunction(TD_GET_SCHEMA))
-                client_t->req().paramMask = P_MASK_DATALEN | P_MASK_KEYBUF;
+            {
+                client_t->req().paramMask = P_MASK_DATALEN | P_MASK_KEYNUM | P_MASK_KEYBUF;
+                if (keyNum == SC_SUBOP_BY_SQL)
+                    client_t->req().paramMask |= P_MASK_POSBLK;
+            }
             else
                 return STATUS_NOSUPPORT_OP;
             break;

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

@@ -765,7 +765,7 @@ class filter
                     const keyValuePtr& v = keyValues[i + j];
                     fielddef& fd = fds[kd->segments[j].fieldNum];
                     has_null |= (v.ptr == NULL);
-                    to = fd.keyCopy(to, (uchar_td*)v.ptr, v.len, (v.ptr == NULL));
+                    to = fd.keyCopy(to, (uchar_td*)v.ptr, v.len, (v.ptr == NULL), m_isTransactd);
                 }
             }
             if (!l.setParam(dataBuf, (ushort_td)(to - dataBuf), has_null))
@@ -1156,7 +1156,7 @@ public:
         for (int j = 0; j < keySize; ++j)
         {
             fielddef& fd = fds[kd->segments[j].fieldNum];
-            to = fd.keyCopy(to, (uchar_td*)ptr[j], len[j], (ptr[j]==NULL));
+            to = fd.keyCopy(to, (uchar_td*)ptr[j], len[j], (ptr[j]==NULL), m_isTransactd);
             has_null |= (ptr[j] == NULL);
         }
         if (!l.setParam(m_buftmp, (ushort_td)(to - m_buftmp), has_null))

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

@@ -1,7 +1,7 @@
 #ifndef BZS_DB_PROTOCOL_TDAP_CLIENT_GROUPCOMP_H
 #define BZS_DB_PROTOCOL_TDAP_CLIENT_GROUPCOMP_H
 /*=================================================================
-   Copyright (C) 2014 BizStation Corp All rights reserved.
+   Copyright (C) 2014-2016 BizStation Corp All rights reserved.
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
@@ -62,7 +62,7 @@ int binary_search(int key, const Container& a, int left, int right, FUNC func,
 inline int compByKey(const fieldsBase& l, const fieldsBase& r, const int& s)
 {
     assert((s < (int)l.size()) && (s < (int)r.size()));
-    return l.getFieldNoCheck(s).comp(r.getFieldNoCheck(s), 0);
+    return l.getFieldNoCheck(s).comp(r.getFieldNoCheck(s), CMPLOGICAL_VAR_COMP_ALL);
 }
 
 template <class Container> class grouping_comp

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

@@ -58,7 +58,7 @@ void autoMemory::setParams(unsigned char* p, size_t s, short* endIndex, bool own
         if (p)
             memcpy(ptr, p, size);
         else
-            memset(ptr, 0, size);
+            memset(ptr, 0, size + 1);
         endFieldIndex = new short;
         if (endIndex != NULL)
             *endFieldIndex = *endIndex;