transactd 2.4.0 → 2.4.2

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

@@ -1659,7 +1659,7 @@ double field::getFVnumeric() const
     char dp[] = "{ABCDEFGHI}JKLMNOPQR";
     char dpsa[] = "PQRSTUVWXYpqrstuvwxy";
     char* pdp = NULL;
-    char i;
+    int i;
     char buf[20] = { 0x00 };
     char dummy[20];
 
@@ -1836,6 +1836,20 @@ inline int compNumber(const field& l, const field& r, char logType)
     return compare<T>((const char*)l.ptr(), (const char*)r.ptr());
 }
 
+template <class T>
+inline int compBitAnd(const field& l, const field& r, char logType)
+{
+    return bitMask<T>((const char*)l.ptr(), (const char*)r.ptr());
+}
+
+inline int compBitAnd24(const field& l, const field& r, char logType)
+{
+
+    int lv = ((*((int*)(const char*)l.ptr()) & 0xFFFFFF) << 8) / 0x100;
+    int rv = ((*((int*)(const char*)r.ptr()) & 0xFFFFFF) << 8) / 0x100;
+    return bitMask<int>((const char*)&lv, (const char*)&rv);
+}
+
 inline int compNumber24(const field& l, const field& r, char logType)
 {
     return compareInt24((const char*)l.ptr(), (const char*)r.ptr());
@@ -1899,18 +1913,37 @@ compFieldFunc field::getCompFunc(char logType) const
     case ft_autoinc:
     case ft_currency:
     {
-        switch (m_fd->len)
+        if (logType & eBitAnd)
         {
-        case 1:
-            return &compNumber<char>;
-        case 2:
-            return &compNumber<short>;
-        case 3:
-            return &compNumber24;
-        case 4:
-            return &compNumber<int>;
-        case 8:
-            return &compNumber<__int64>;
+
+            switch (m_fd->len)
+            {
+            case 1:
+                return &compBitAnd<char>;
+            case 2:
+                return &compBitAnd<short>;
+            case 3:
+                return &compBitAnd24;
+            case 4:
+                return &compBitAnd<int>;
+            case 8:
+                return &compBitAnd<__int64>;
+            }
+        }else
+        {
+            switch (m_fd->len)
+            {
+            case 1:
+                return &compNumber<char>;
+            case 2:
+                return &compNumber<short>;
+            case 3:
+                return &compNumber24;
+            case 4:
+                return &compNumber<int>;
+            case 8:
+                return &compNumber<__int64>;
+            }
         }
     }
     case ft_mychar:
@@ -1931,18 +1964,36 @@ compFieldFunc field::getCompFunc(char logType) const
     case ft_timestamp:
     case ft_mydate:
     {
-        switch (m_fd->len)
+        if (logType & eBitAnd)
         {
-        case 1:
-            return &compNumber<unsigned char>;
-        case 2:
-            return &compNumber<unsigned short>;
-        case 3:
-            return &compNumberU24;
-        case 4:
-            return &compNumber<unsigned int>;
-        case 8:
-            return &compNumber<unsigned __int64>;
+            switch (m_fd->len)
+            {
+            case 1:
+                return &compBitAnd<unsigned char>;
+            case 2:
+                return &compBitAnd<unsigned short>;
+            case 3:
+                return &compBitAnd24;
+            case 4:
+                return &compBitAnd<unsigned int>;
+            case 8:
+                return &compBitAnd<unsigned __int64>;
+            }
+        }else
+        {
+            switch (m_fd->len)
+            {
+            case 1:
+                return &compNumber<unsigned char>;
+            case 2:
+                return &compNumber<unsigned short>;
+            case 3:
+                return &compNumberU24;
+            case 4:
+                return &compNumber<unsigned int>;
+            case 8:
+                return &compNumber<unsigned __int64>;
+            }
         }
     }
     case ft_mytime:

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

@@ -85,8 +85,9 @@ class DLLLIB fielddefs : public fieldShare
     friend class recordsetQuery;
     friend struct recordsetQueryImple;
     friend class fieldsBase;
-
+public:
     void addAllFileds(tabledef* def);
+protected:
     void copyFrom(const class table* tb);
     bool canUnion(const fielddefs& r) const;
     size_t totalFieldLen() const;
@@ -95,6 +96,7 @@ class DLLLIB fielddefs : public fieldShare
     void push_back(const fielddef* p, bool rePosition = false);
     void remove(int index);
     void reserve(size_t size);
+public:
     void clear();
 
 public:

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

@@ -806,7 +806,7 @@ class filter
     {
         int keySize = q->getJoinKeySize();
         uchar_td* dataBuf;
-        keydef* kd = &m_tb->tableDef()->keyDefs[m_tb->keyNum()];
+        keydef* kd = &m_tb->tableDef()->keyDefs[(int)m_tb->keyNum()];
         
         if (!prebuiltSeeks(kd, keyValues.size(), q, keySize, &dataBuf))
              return false;
@@ -1098,7 +1098,7 @@ public:
     bool supplySeekValues(const T& values, size_t size, int keySize)
     {
         uchar_td* dataBuf;
-        keydef* kd = &m_tb->tableDef()->keyDefs[m_tb->keyNum()];
+        keydef* kd = &m_tb->tableDef()->keyDefs[(int)m_tb->keyNum()];
 
         if (!prebuiltSeeks(kd, size, NULL, keySize, &dataBuf))
              return false;
@@ -1113,7 +1113,7 @@ public:
 
     bool beginSupplySeekValues(size_t size, int keySize)
     {
-        keydef* kd = &m_tb->tableDef()->keyDefs[m_tb->keyNum()];
+        keydef* kd = &m_tb->tableDef()->keyDefs[(int)m_tb->keyNum()];
 
         if (!prebuiltSeeks(kd, size, NULL, keySize, &m_buftmp))
              return false;
@@ -1126,7 +1126,7 @@ public:
     bool supplySeekValue(const uchar_td* ptr[] , int len[], int keySize, int& index)
     {
         const tabledef* td = m_tb->tableDef();
-        keydef* kd = &td->keyDefs[m_tb->keyNum()];
+        keydef* kd = &td->keyDefs[(int)m_tb->keyNum()];
         fielddef* fds = td->fieldDefs;
 
         seek& l = m_seeks[index];

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

@@ -268,10 +268,11 @@ void recordsetQuery::init(const fielddefs* fdinfo)
 
 bool recordsetQuery::isMatch(int ret, unsigned char compType) const
 {
-    compType &= 0xf; // lower then 15
+    compType &= 0xf; // lower than 15
     switch ((eCompType)compType)
     {
     case eEqual:
+    case eBitAnd:
         return (ret == 0);
     case eGreaterEq:
         return (ret >= 0);
@@ -282,6 +283,7 @@ bool recordsetQuery::isMatch(int ret, unsigned char compType) const
     case eLess:
         return (ret < 0);
     case eNotEq:
+    case eNotBitAnd:
         return (ret != 0);
     }
     return false;

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

@@ -336,22 +336,29 @@ void writableRecord::insert()
     copyFromBuffer(m_tb);
 }
 
-void writableRecord::del(bool KeysetAlrady)
+void writableRecord::del(bool KeysetAlrady, bool noSeek)
 {
     if (!KeysetAlrady)
         copyToBuffer(m_tb);
-    m_tb->seek();
-    if (m_tb->stat())
-        nstable::throwError(_T("activeTable delete "), m_tb->stat());
+    if (noSeek == false)
+    {
+        m_tb->seek();
+        if (m_tb->stat())
+            nstable::throwError(_T("activeTable delete "), m_tb->stat());
+    }
     deleteRecord(m_tb);
 }
 
-void writableRecord::update()
+void writableRecord::update(bool KeysetAlrady, bool noSeek)
 {
-    copyToBuffer(m_tb);
-    m_tb->seek();
-    if (m_tb->stat())
-        nstable::throwError(_T("activeTable update "), m_tb->stat());
+    if (!KeysetAlrady)
+        copyToBuffer(m_tb);
+    if (noSeek == false)
+    {
+        m_tb->seek();
+        if (m_tb->stat())
+            nstable::throwError(_T("activeTable update "), m_tb->stat());
+    }
     copyToBuffer(m_tb, true /*only changed*/);
     updateRecord(m_tb);
 }

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

@@ -173,8 +173,8 @@ public:
     bool read(bool KeysetAlrady = false);
     bool read(bookmark_td& bm);
     void insert();
-    void del(bool KeysetAlrady = false);
-    void update();
+    void del(bool KeysetAlrady = false, bool noSeek = false);
+    void update(bool KeysetAlrady = false, bool noSeek = false);
     void save();
 
 };

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

@@ -786,7 +786,7 @@ bool nsdatabase::connect(const _TCHAR* URI, bool newConnection)
 
     char uri_a[MAX_PATH] = { 0x00 };
     const char* p = toServerUri(uri_a, MAX_PATH, URI, isUseTransactd());
-    char_td keyNum = newConnection ? 3 : 0;
+    char_td keyNum = (isUseTransactd() == false) ? 0 : newConnection ? 3 : 0;
     m_stat = m_btrcallid(TD_CONNECT, NULL, NULL, &datalen, (void*)p,
                          (keylen_td)(strlen(p) + 1), keyNum, clientID());
     if (m_stat)

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

@@ -152,7 +152,7 @@ private:
                 m_fds->copyFrom(tb);
             if (tb && (addtype == mra_nojoin))
             {
-                const keydef& kd = tb->tableDef()->keyDefs[tb->keyNum()];
+                const keydef& kd = tb->tableDef()->keyDefs[(int)tb->keyNum()];
                 m_uniqueReadMaxField = (kd.segments[0].flags.bit0 == false)
                                            ? (short)m_fds->size()
                                            : 0;
@@ -580,7 +580,8 @@ public:
         m_fds->push_back(&fd);
         for (int i = 0; i < (int)m_unionFds.size(); ++i)
             m_unionFds[i]->push_back(&fd);
-        registerMemoryBlock(NULL, fd.len * size(), fd.len, mra_outerjoin);
+        if (size())
+            registerMemoryBlock(NULL, fd.len * size(), fd.len, mra_outerjoin);
     }
 
     inline recordsetImple& operator+=(const recordsetImple& r)

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

@@ -647,6 +647,13 @@ struct queryStatementsImple
         }
     }
 
+    void move(int from, int to)
+    {
+        executable* p = statements[from];
+		statements.erase(statements.begin() + from);
+		statements.insert(statements.begin() + to, p);
+    }
+
 private:
     friend class boost::serialization::access;
     template <class Archive>
@@ -1105,6 +1112,11 @@ void queryStatements::clear()
     m_impl->reset();
 }
 
+void queryStatements::move(int from, int to)
+{
+    m_impl->move(from, to);
+}
+
 int queryStatements::statementType(int index)
 {
     if (dynamic_cast<readHasMany*>(m_impl->statements[index]))

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

@@ -274,6 +274,7 @@ public:
 
     void clear();
     int size() const;
+    void move(int from, int to);
     void save(const _TCHAR* filename);
     void load(const _TCHAR* filename);
     void save(std::stringstream& sf);

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

@@ -233,38 +233,58 @@ public:
         }
     }
 
+    inline char* moveCurrentData(char* ptr, unsigned short& len, int& sqnum)
+    {
+        len = *((unsigned short*)ptr);
+        ptr += DATASIZE_BYTE;
+        sqnum = *((int*)(ptr));
+        ptr += sizeof(int);
+        ptr += len;
+        return ptr;
+    }
+
     inline void hasManyJoinMra(int rowCount, uchar_td* data)
     {
         int rowOffset = 0;
-        int row = 0; // zero start
+        int row = 0;
         int count = 0;
-        char* ptr = (char*)data + DATASIZE_BYTE; // rowCount
+        int sqnum = 0;
         unsigned short len = 0;
-        for (int i = 0; i < (int)rowCount; ++i)
+
+        char* ptr = (char*)data + DATASIZE_BYTE; // rowCount
+        ptr = moveCurrentData(ptr, len, sqnum);  // getFirst
+        for (int i = 1; i < (int)rowCount; ++i)
         {
-            ptr += len;
-            len = *((unsigned short*)ptr);
-            ptr += DATASIZE_BYTE;
-
-            // get sequential number
-            int tmp = *((int*)(ptr));
-            ptr += sizeof(int);
-            // If len == 0 then next first record read error
-            if ((len == 0) || (tmp != row))
+            if (sqnum == row)
+            {
+                ++count;
+
+                //if row == 0
+                if (len == 0)
+                {
+                    ++row;
+                    count = 0;
+                }
+
+            }else if(sqnum != row)
             {
-                if (count)
+                if (--count > 0)
                 {
                     m_tb->m_impl->mraPtr->duplicateRow(row + rowOffset, count);
                     rowOffset += count;
                 }
                 ++row;
-                count = 0;
+                count = (len == 0) ? 0 : 1;
+
             }
-            else if (i != 0)
-                ++count;
+            ptr = moveCurrentData(ptr, len, sqnum);
         }
-        if (count)
+        if (sqnum == row)
+            count = (len == 0) ? 0 : count + 1;
+
+        if (--count > 0)
             m_tb->m_impl->mraPtr->duplicateRow(row + rowOffset, count);
+
     }
 
     inline void reset(filter* p, uchar_td* data, unsigned int totalSize,
@@ -291,7 +311,6 @@ public:
             const tabledef* td = m_tb->tableDef();
             ushort_td fieldCount = m_filter->fieldCount();
             m_tmpPtr = mra->ptr(m_row, mra_current_block);
-            int resultOffset = 0;
 
             while (m_row < m_rowCount)
             {
@@ -302,7 +321,7 @@ public:
                     if (m_filter->fieldSelected())
                     {
                         uchar_td* fieldPtr = m_ptr;
-                        resultOffset = 0;
+                        int resultOffset = 0;
                         int blobFieldNum = 0;
                         for (int i = 0; i < fieldCount; i++)
                         {
@@ -324,21 +343,17 @@ public:
                         {
                             memset(m_tmpPtr, 0, td->maxRecordLen);
                             memcpy(m_tmpPtr, m_ptr, m_len);
-                            m_unpackLen = m_tb->unPack((char*)m_tmpPtr, m_len);
-                            resultOffset = m_unpackLen; 
+                            m_unpackLen = td->unPack((char*)m_tmpPtr, m_len);
                         }
                         else
-                        {
                             memcpy(m_tmpPtr, m_ptr, m_len);
-                            resultOffset = m_len;
-                        }
                         if (bd)
                             bd = m_tb->setBlobFieldPointer((char*)m_tmpPtr, m_hd, bd);
                     }
                 }
                 ++m_row;
                 moveNextRow(bookmarkSize);
-                m_tmpPtr += resultOffset;
+                m_tmpPtr += recordLen;
             }
         }
         //prebuilt next ead operation
@@ -407,7 +422,7 @@ public:
             {
                 memset(m_tmpPtr, 0, td->maxRecordLen);
                 memcpy(m_tmpPtr, m_ptr, m_len);
-                m_unpackLen = m_tb->unPack((char*)m_tmpPtr, m_len);
+                m_unpackLen = td->unPack((char*)m_tmpPtr, m_len);
             }
             else
                 m_tmpPtr = m_ptr;
@@ -1218,7 +1233,7 @@ void table::getKeySpec(keySpec* ks, bool SpecifyKeyNum)
     short FieldNum;
     int j;
     tabledef* td = (*m_tableDef);
-    KeyDef = &td->keyDefs[m_keynum];
+    KeyDef = &td->keyDefs[(int)m_keynum];
     for (j = 0; j < KeyDef->segmentCount; j++)
     {
         FieldNum = KeyDef->segments[j].fieldNum;
@@ -1261,7 +1276,7 @@ void table::doCreateIndex(bool SpecifyKeyNum)
     }
     else
     {
-        int segmentCount = (*m_tableDef)->keyDefs[m_keynum].segmentCount;
+        int segmentCount = (*m_tableDef)->keyDefs[(int)m_keynum].segmentCount;
         keySpec* ks = (keySpec*)malloc(sizeof(keySpec) * segmentCount);
         memset(ks, 0, sizeof(keySpec) * segmentCount);
         getKeySpec(ks, SpecifyKeyNum);
@@ -1290,7 +1305,7 @@ bool table::isUniqeKey(char_td keynum)
 {
     if ((keynum >= 0) && (keynum < (*m_tableDef)->keyCount))
     {
-        keydef* kd = &(*m_tableDef)->keyDefs[m_keynum];
+        keydef* kd = &(*m_tableDef)->keyDefs[(int)m_keynum];
         return !(kd->segments[0].flags.bit0);
     }
     return false;
@@ -1388,7 +1403,7 @@ void* table::attachBuffer(void* NewPtr, bool unpack, size_t size)
     m_pdata = NewPtr;
     ushort_td len = (*m_tableDef)->maxRecordLen; 
     if (unpack)
-        len = unPack((char*)m_pdata, size);
+        len = (*m_tableDef)->unPack((char*)m_pdata, size);
     m_datalen = len;
     return oldptr;
 }
@@ -1436,7 +1451,7 @@ keylen_td table::writeKeyDataTo(uchar_td* to, int keySize)
     if ((*m_tableDef)->keyCount)
     {
         keydef& keydef =
-            (*m_tableDef)->keyDefs[(short)m_impl->keyNumIndex[m_keynum]];
+            (*m_tableDef)->keyDefs[(int)m_impl->keyNumIndex[(int)m_keynum]];
         uchar_td* start = to;
         if (keySize == 0)
             keySize = keydef.segmentCount;
@@ -1458,40 +1473,19 @@ keylen_td table::writeKeyData()
     return writeKeyDataTo((uchar_td*)m_impl->keybuf, 0);
 }
 
-uint_td table::pack(char* ptr, size_t size)
+
+uint_td table::unPack(char* ptr, size_t size)
 {
-    char* pos = ptr;
-    char* end = pos + size;
-    int movelen;
-    for (int i = 0; i < (*m_tableDef)->fieldCount; 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
-            *((unsigned short*)(pos)) = fd.len - 2; // fixed size
-            pos += fd.len;
-        }
-        else
-        {
-            int blen = fd.varLenBytes();
-            int dl = fd.len; // length
-            if (blen == 1)
-                dl = *((unsigned char*)(pos)) + blen;
-            else if (blen == 2)
-                dl = *((unsigned short*)(pos)) + blen;
-            pos += dl;
-            if ((movelen = fd.len - dl) != 0)
-            {
-                end -= movelen;
-                memmove(pos, pos + movelen, end - pos);
-            }
-        }
-    }
-    m_impl->dataPacked = true;
-    return (uint_td)(pos - ptr);
+    m_impl->dataPacked = false;
+    return tableDef()->unPack(ptr, size);
 }
 
+uint_td table::pack(char* ptr, size_t size)
+{
+    m_impl->dataPacked = true;
+    return tableDef()->pack(ptr, size);
+}
+
 uint_td table::doGetWriteImageLen()
 {
     tabledef* td = (*m_tableDef);
@@ -1550,49 +1544,6 @@ uint_td table::doGetWriteImageLen()
     }
 }
 
-uint_td table::unPack(char* ptr, size_t size)
-{
-    char* pos = ptr;
-    const char* end = pos + size;
-    tabledef* td = *m_tableDef;
-    const char* max = pos + td->maxRecordLen;
-    int movelen;
-    for (int i = 0; i < td->fieldCount; i++)
-    {
-        fielddef& fd = td->fieldDefs[i];
-        if (fd.type == ft_myfixedbinary)
-        {
-            int dl = *((unsigned short*)(pos));
-            memmove(pos, pos + 2, dl);
-            pos += fd.len - 2;
-            *((unsigned short*)(pos)) = 0x00;
-            ;
-            pos += 2;
-        }
-        else
-        {
-            int blen = fd.varLenBytes();
-            int dl = fd.len; // length
-            if (blen == 1)
-                dl = *((unsigned char*)(pos)) + blen;
-            else if (blen == 2)
-                dl = *((unsigned short*)(pos)) + blen;
-            if ((movelen = fd.len - dl) != 0)
-            {
-                if (max < end + movelen)
-                    return 0;
-                char* src = pos + dl;
-                memmove(pos + fd.len, src, end - src);
-                memset(src, 0, movelen);
-                end += movelen;
-            }
-            pos += fd.len;
-        }
-    }
-    m_impl->dataPacked = false;
-    return (uint_td)(pos - ptr);
-}
-
 void table::addBlobEndRow()
 {
     char_td knum = m_keynum;
@@ -2015,7 +1966,7 @@ short_td table::doBtrvErr(HWND hWnd, _TCHAR* retbuf)
 bool table::setSeekValueField(int row)
 {
     const std::vector<client::seek>& keyValues = m_impl->filterPtr->seeks();
-    keydef* kd = &tableDef()->keyDefs[keyNum()];
+    keydef* kd = &tableDef()->keyDefs[(int)keyNum()];
     if (keyValues.size() % kd->segmentCount)
         return false;
     // Check uniqe key
@@ -2055,9 +2006,9 @@ void table::keyValueDescription(_TCHAR* buf, int bufsize)
     if (stat() == STATUS_NOT_FOUND_TI)
     {
 
-        for (int i = 0; i < tableDef()->keyDefs[keyNum()].segmentCount; i++)
+        for (int i = 0; i < tableDef()->keyDefs[(int)keyNum()].segmentCount; i++)
         {
-            short fnum = tableDef()->keyDefs[keyNum()].segments[i].fieldNum;
+            short fnum = tableDef()->keyDefs[(int)keyNum()].segments[i].fieldNum;
             s += std::_tstring(tableDef()->fieldDefs[fnum].name()) + _T(" = ") +
                  getFVstr(fnum) + _T("\n");
         }
@@ -2475,7 +2426,7 @@ const _TCHAR* queryBase::toString() const
     for (size_t i = 0; i < wheres.size(); i += 4)
     {
         if (i + 1 < wheres.size())
-            s += wheres[i] + _T(" ") + wheres[i + 1];
+            s += wheres[i] + _T(" ") + escape_value(wheres[i + 1]);
         if (i + 2 < wheres.size())
             s += _T(" '") + escape_value(wheres[i + 2]) + _T("' ");
         if (i + 3 < wheres.size())

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

@@ -132,7 +132,8 @@ protected:
     void* reallocDataBuffer(uint_td v);
     int dataBufferLen() const;
     uint_td unPack(char* ptr, size_t size);
-    uint_td pack(char* ptr, size_t size);
+    uint_td pack(char* ptr, size_t size);
+
     keylen_td writeKeyData(); // orverride
     keylen_td writeKeyDataTo(uchar_td* to, int keySize);
 

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

@@ -101,6 +101,19 @@ public:
         : m_type(TYPE_SCHEMA_BDF), m_mode(TD_OPEN_READONLY)
     {
         _tcscpy_s(m_buf, MAX_PATH, uri);
+        size_t len = _tcslen(uri);
+        if (len > 5)
+        {
+            _TCHAR tmp[10];
+            _tcscpy_s(tmp, 10, uri + len - 4);
+#ifdef _tcsupr_s
+            _tcsupr_s(tmp, 10);
+#else
+            _tcsupr(tmp);
+#endif
+            if (_tcscmp(tmp, _T(".DDF"))==0)
+                m_type = TYPE_SCHEMA_DDF;
+        }
     }
     inline void setMode(char_td v) { m_mode = v; }
 

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

@@ -172,7 +172,7 @@ public:
         if (keynum < td.keyCount)
         {
             tb->clearBuffer();
-            const keydef kd = td.keyDefs[keynum];
+            const keydef kd = td.keyDefs[(int)keynum];
             if (kd.segmentCount > 0)
                 tb->setFV(kd.segments[0].fieldNum, kv0);
             if (kd.segmentCount > 1)