transactd 2.3.0 → 2.4.0

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

@@ -31,13 +31,7 @@ namespace bzs
 
 namespace db
 {
-namespace engine
-{
-namespace mysql
-{
-class table;
-}
-}
+namespace engine{ namespace mysql { class table; } }
 
 namespace protocol
 {
@@ -46,9 +40,17 @@ namespace tdap
 namespace client
 {
 
+short errorCode(const boost::system::error_code& e);
+
 class request : public bzs::db::protocol::tdap::request, 
                 public bzs::netsvc::client::idirectReadHandler
 {
+
+    unsigned int handleError(const boost::system::error_code& e)
+    {
+        result = errorCode(e);
+        return 0;
+    }
 public:
     clientID* cid;
     request() : bzs::db::protocol::tdap::request(), cid(NULL){};
@@ -56,14 +58,20 @@ public:
     unsigned int onRead(unsigned int size, bzs::netsvc::client::connection* c) // orverride
     {
         unsigned int readlen = 0;
-        readlen += c->directRead(&paramMask, sizeof(uint_td)); // paramMask and result 
+        readlen += c->directRead(&paramMask, sizeof(uint_td)); // paramMask and result
+        if (c->error()) return handleError(c->error());
+
         if (P_MASK_POSBLK & paramMask)
+        {
             readlen += c->directRead(pbk, TD_POSBLK_TRANSMIT_SIZE);
-
+            if (c->error()) return handleError(c->error());
+        }
         if (P_MASK_DATALEN & paramMask)
         {
             uint_td tmp;
             readlen += c->directRead(&tmp, sizeof(uint_td));
+            if (c->error()) return handleError(c->error());
+
             if (*datalen < tmp)
             {
                 result = STATUS_BUFFERTOOSMALL;
@@ -75,7 +83,10 @@ public:
                     data = pbk->allocFunc(pbk->tb, tmp);
                 *datalen = tmp;
                 if (P_MASK_DATA & paramMask)
+                {
                     readlen += c->directRead(data, *datalen);
+                    if (c->error()) return handleError(c->error());
+                }
             }
         }
 
@@ -83,6 +94,7 @@ public:
         {
             keylen_td tmp;
             readlen += c->directRead(&tmp, sizeof(keylen_td));
+            if (c->error()) return handleError(c->error());
             if (keylen < tmp)
             {
                 result = STATUS_KEYBUFFERTOOSMALL;
@@ -91,13 +103,18 @@ public:
             memset(keybuf, 0, keylen);
             keylen = tmp;
             readlen += c->directRead(keybuf, keylen);
+            if (c->error()) return handleError(c->error());
         }
         if (P_MASK_KEYNUM & paramMask)
+        {
             readlen += c->directRead(&keyNum, sizeof(char_td));
-
+            if (c->error()) return handleError(c->error());
+        }
         if (paramMask & P_MASK_BLOBBODY)
         {
-            blobHeader = (const bzs::db::blobHeader*)c->directReadRemain(size - readlen);
+            blobHeader =
+                (const bzs::db::blobHeader*)c->directReadRemain(size - readlen);
+            if (c->error()) return handleError(c->error());
             readlen = size;
             if (blobHeader->rows)
                 blobHeader->resetCur();

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

@@ -71,6 +71,8 @@ char g_buf[TMP_BUFSIZE];
 #define NOTE_TYPE 12
 #define VAR_TYPE 13
 
+#define NIS_FD_KEYSEG_LIMIT 1
+
 const char* getFieldTypeName(uchar_td fieldType, int size, bool nobinary,
                              const char* charsetName)
 {
@@ -284,6 +286,17 @@ std::string getFiledList(const tabledef* table, std::vector<std::string>& fdl)
     return s;
 }
 
+bool isNeedNis(const tabledef* table, const keydef& key)
+{
+    if (key.segmentCount > NIS_FD_KEYSEG_LIMIT)
+    {
+        // If a first segment is not 1 byte of Logical
+        const fielddef& fd = table->fieldDefs[key.segments[0].fieldNum];
+        return (!((fd.len == 1) && (fd.type == ft_logical)));
+    }
+    return false;
+}
+
 void insertNisFields(const tabledef* table, std::vector<std::string>& fdl,
                      std::string& s)
 {
@@ -293,7 +306,7 @@ void insertNisFields(const tabledef* table, std::vector<std::string>& fdl,
         _ltoa_s(i, buf, 20, 10);
         std::string fddef = "";
         const keydef& key = table->keyDefs[i];
-        if (key.segmentCount > 1)
+        if (isNeedNis(table, key))
         {
             if (key.segments[0].flags.bit9)
                 fddef = std::string("`") + "$nfn" + buf +
@@ -332,17 +345,12 @@ std::string& getKey(const tabledef* table, std::vector<std::string>& fdl,
     s += "(";
 
     // "nf" segment is added to a head.
-    if (key.segmentCount > 1)
+    if (isNeedNis(table, key))
     {
-        // If a first segment is not 1 byte of Logical
-        const fielddef& fd = table->fieldDefs[key.segments[0].fieldNum];
-        if (!((fd.len == 1) && (fd.type == ft_logical)))
-        {
-            if (key.segments[0].flags.bit9)
-                s += std::string("`") + "$nfn" + buf + "`,";
-            else if (key.segments[0].flags.bit3)
-                s += std::string("`") + "$nfa" + buf + "`,";
-        }
+        if (key.segments[0].flags.bit9)
+            s += std::string("`") + "$nfn" + buf + "`,";
+        else if (key.segments[0].flags.bit3)
+            s += std::string("`") + "$nfa" + buf + "`,";
     }
     for (int j = 0; j < key.segmentCount; j++)
     {

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

@@ -29,6 +29,7 @@
 #include <bzs/rtl/stringBuffers.h>
 #include "stringConverter.h"
 #include <boost/timer.hpp>
+#include <boost/thread/mutex.hpp>
 
 #pragma package(smart_init)
 
@@ -60,8 +61,8 @@ class recordCache;
 
 struct tbimpl
 {
-
-    void* bookMarks;
+    boost::mutex bookmarkMutex;
+    uchar_td* bookMarks;
     client::fields fields;
     pq_handle filterPtr;
     recordCache* rc;
@@ -71,8 +72,9 @@ struct tbimpl
     void* bfAtcPtr;
     void* optionalData;
     uint_td dataBufferLen;
-    int bookMarksMemSize;
-    int maxBookMarkedCount;
+    unsigned int bookMarksMemSize;
+    unsigned int maxBookMarkedCount;
+    recordCountFn onRecordCountFunc;
     char keybuf[MAX_KEYLEN];
     char keyNumIndex[128];
 
@@ -87,7 +89,7 @@ struct tbimpl
         : bookMarks(NULL), fields(tb), rc(NULL), mraPtr(NULL),
           dataBak(NULL), smartUpDate(NULL), bfAtcPtr(NULL), optionalData(NULL),
           dataBufferLen(0), bookMarksMemSize(0), maxBookMarkedCount(0),
-          smartUpDateFlag(false), dataPacked(false)
+          onRecordCountFunc(NULL), smartUpDateFlag(false), dataPacked(false)
     {
         memset(&keyNumIndex[0], 0, 128);
     }
@@ -101,6 +103,62 @@ struct tbimpl
         if (bookMarks)
             free(bookMarks);
     }
+
+    inline void resetBookmarks()
+    {
+        boost::mutex::scoped_lock lck(bookmarkMutex);
+        maxBookMarkedCount = 0;
+    }
+
+    inline uchar_td* bookmarks(unsigned int index, ushort_td len)
+    {
+        boost::mutex::scoped_lock lck(bookmarkMutex);
+        unsigned int pos = index * (len + 2) + 2;
+        if ((index < maxBookMarkedCount) && bookMarks)
+            return bookMarks + pos;
+        return NULL;
+    }
+
+    /*inline bookmark_td* bookmarksPtr(unsigned int index)
+    {
+        boost::mutex::scoped_lock lck(bookmarkMutex);
+        unsigned int pos = index * 6 + 2;
+        if ((index < maxBookMarkedCount) && bookMarks)
+            return (bookmark_td*)((char*)bookMarks + pos);
+        return NULL;
+    }*/
+
+    inline short insertBookmarks(unsigned int start, void* data, ushort_td len,
+                         ushort_td count)
+    {
+        unsigned int size = (start + count) * (2 + len);
+        boost::mutex::scoped_lock lck(bookmarkMutex);
+        if (!bookMarks)
+        {
+            bookMarks = (uchar_td*)malloc(BOOKMARK_ALLOC_SIZE);
+            if (bookMarks)
+                bookMarksMemSize = BOOKMARK_ALLOC_SIZE;
+            else
+                return STATUS_CANT_ALLOC_MEMORY;
+        }
+
+        if (bookMarksMemSize < size)
+        {
+            bookMarks = (uchar_td*)realloc(bookMarks, size + BOOKMARK_ALLOC_SIZE);
+            bookMarksMemSize = size + BOOKMARK_ALLOC_SIZE;
+        }
+        if (bookMarks)
+        {
+            //if (start + count > m_impl->maxBookMarkedCount)
+            memcpy(bookMarks + (start * (2 + len)), data,
+                                                count * (2 + len));
+            maxBookMarkedCount = start + count;
+        }
+        else
+            return STATUS_CANT_ALLOC_MEMORY;
+        return STATUS_SUCCESS;
+    }
+
 };
 
 // ---------------------------------------------------------------------------
@@ -123,7 +181,7 @@ class recordCache
     unsigned int m_len;
     unsigned int m_unpackLen;
     unsigned int m_rowCount;
-    bookmark_td m_bookmark;
+    uchar_td* m_bookmark;
     uchar_td* m_ptr;
     uchar_td* m_tmpPtr;
     blobHeader* m_hd;
@@ -156,7 +214,7 @@ public:
         m_ptr += DATASIZE_BYTE;
         if (bookmarkSize)
         {
-            m_bookmark = *((bookmark_td*)(m_ptr));
+            m_bookmark = m_ptr;
             m_ptr += bookmarkSize;
         }
     }
@@ -302,7 +360,7 @@ public:
             m_ptr += DATASIZE_BYTE;
             if (m_filter->bookmarkSize())
             {
-                m_bookmark = *((bookmark_td*)(m_ptr));
+                m_bookmark = m_ptr;
                 m_ptr += m_filter->bookmarkSize();
             }
             m_tmpPtr = data + totalSize;
@@ -371,7 +429,7 @@ public:
     }
 
     inline unsigned int len() const { return m_unpackLen; };
-    inline bookmark_td bookmarkCurRow() const { return m_bookmark; };
+    inline uchar_td* bookmarkCurRow() const { return m_bookmark; };
     inline int row() const { return m_row; }
 
     inline int rowCount() const { return m_rowCount; }
@@ -500,41 +558,6 @@ fields& table::fields()
     return m_impl->fields;
 }
 
-void table::setBookMarks(int StartId, void* Data, ushort_td Count)
-{
-    long size = (StartId + Count) * 6;
-
-    if (!m_impl->bookMarks)
-    {
-        m_impl->bookMarks = malloc(BOOKMARK_ALLOC_SIZE);
-        if (m_impl->bookMarks)
-            m_impl->bookMarksMemSize = BOOKMARK_ALLOC_SIZE;
-        else
-        {
-            m_stat = STATUS_CANT_ALLOC_MEMORY;
-            return;
-        }
-    }
-
-    if (m_impl->bookMarksMemSize < size)
-    {
-
-        m_impl->bookMarks =
-            realloc(m_impl->bookMarks, size + BOOKMARK_ALLOC_SIZE);
-        m_impl->bookMarksMemSize = size + BOOKMARK_ALLOC_SIZE;
-    }
-    if (m_impl->bookMarks)
-    {
-        if (StartId + Count - 1 > m_impl->maxBookMarkedCount)
-            m_impl->maxBookMarkedCount = StartId + Count - 1;
-        memcpy((void*)((char*)m_impl->bookMarks + ((StartId - 1) * 6)), Data,
-               Count * 6);
-    }
-    else
-        m_stat = STATUS_CANT_ALLOC_MEMORY;
-    return;
-}
-
 inline short calcNextReadRecordCount(ushort_td curCount, int eTime)
 {
     ushort_td ret = curCount;
@@ -550,6 +573,22 @@ inline short calcNextReadRecordCount(ushort_td curCount, int eTime)
     return ret;
 }
 
+void table::setOnRecordCount(const recordCountFn v)
+{
+    m_impl->onRecordCountFunc = v;
+}
+
+recordCountFn table::onRecordCount() const
+{
+    return m_impl->onRecordCountFunc;
+}
+
+void table::onRecordCounting(size_t count, bool& complate)
+{
+    if (m_impl->onRecordCountFunc)
+        m_impl->onRecordCountFunc(this, (int)count, complate);
+}
+
 uint_td table::doRecordCount(bool estimate, bool fromCurrent)
 {
     uint_td result = 0;
@@ -584,11 +623,14 @@ uint_td table::doRecordCount(bool estimate, bool fromCurrent)
 
         bookmark_td bm = bookmark();
 
+
         ushort_td tmpRejectCount = filter->rejectCount();
         ushort_td tmpRecCount = filter->recordCount();
 
         filter->setIgnoreFields(true);
-        m_impl->maxBookMarkedCount = 0;
+        m_impl->resetBookmarks();
+        bool withBookmark = filter->withBookmark();
+
         if (fromCurrent)
             m_stat = curStat;
         else if (op == TD_KEY_NEXT_MULTI)
@@ -629,11 +671,11 @@ uint_td table::doRecordCount(bool estimate, bool fromCurrent)
                 }
                 recCountOnce = calcNextReadRecordCount(recCountOnce, eTime);
                 filter->setMaxRows(recCountOnce);
-                result += *((ushort_td*)m_pdata/*m_impl->dataBak*/);
-                setBookMarks(m_impl->maxBookMarkedCount + 1,
-                             (void*)((char*)m_pdata/*m_impl->dataBak*/ + 2),
-                             *((ushort_td*)m_pdata/*m_impl->dataBak*/));
-                m_impl->maxBookMarkedCount = result;
+                result += *((ushort_td*)m_pdata);
+                if (withBookmark)
+                    insertBookmarks(m_impl->maxBookMarkedCount,
+                             (void*)((char*)m_pdata + 2), *((ushort_td*)m_pdata));
+
                 onRecordCounting(result, Complete);
                 if (Complete)
                     break;
@@ -648,7 +690,7 @@ uint_td table::doRecordCount(bool estimate, bool fromCurrent)
         filter->setIgnoreFields(false);
         filter->setMaxRows(tmpRecCount);
 
-        if (bm)
+        if (!bm.empty)
             seekByBookmark(bm);
         m_impl->exBookMarking = false;
         m_stat = tmpStat;
@@ -781,10 +823,13 @@ short table::statReasonOfFind() const
 
 bookmark_td table::bookmarkFindCurrent() const
 {
-
+    bookmark_td bm;
     if (!m_impl->rc->isEndOfRow(m_impl->rc->row()))
-        return m_impl->rc->bookmarkCurRow();
-    return 0;
+    {
+        memcpy(bm.val, m_impl->rc->bookmarkCurRow(), bookmarkLen());
+        bm.empty = false;
+    }
+    return bm;
 }
 
 inline bool checkStatus(short v)
@@ -876,7 +921,13 @@ void table::btrvSeekMulti()
         }
         else
         {
-            tdap((ushort_td)(TD_KEY_SEEK));
+            if (m_impl->filterPtr->isSeekByBookmarks())
+            {
+                memcpy(m_pdata, m_impl->keybuf, bookmarkLen());
+                m_datalen = m_buflen;
+                tdap((ushort_td)(TD_MOVE_BOOKMARK));
+            }else    
+                tdap((ushort_td)(TD_KEY_SEEK));
             if (!doSeekMultiAfter(i))
                 return;
         }
@@ -1090,9 +1141,11 @@ void table::setPrepare(const pq_handle stmt)
     }
     m_impl->rc->reset();
     m_impl->exBookMarking = false;
-    m_impl->maxBookMarkedCount = 0;
+    m_impl->resetBookmarks();
     if (m_impl->filterPtr != stmt)
         m_impl->filterPtr = stmt;
+    if (nsdb()->isReconnected())
+        m_impl->filterPtr->setServerPreparedId(0);
 }
 
 pq_handle table::setQuery(const queryBase* query, bool serverPrepare)
@@ -1101,7 +1154,7 @@ pq_handle table::setQuery(const queryBase* query, bool serverPrepare)
     m_stat = 0;
     m_impl->rc->reset();
     m_impl->exBookMarking = false;
-    m_impl->maxBookMarkedCount = 0;
+    m_impl->resetBookmarks();
     m_impl->filterPtr.reset();
     if (query == NULL)
         return m_impl->filterPtr;
@@ -1510,9 +1563,8 @@ uint_td table::unPack(char* ptr, size_t size)
         if (fd.type == ft_myfixedbinary)
         {
             int dl = *((unsigned short*)(pos));
-            assert(dl == fd.len - 2);
             memmove(pos, pos + 2, dl);
-            pos += dl;
+            pos += fd.len - 2;
             *((unsigned short*)(pos)) = 0x00;
             ;
             pos += 2;
@@ -1918,23 +1970,42 @@ unsigned int table::getRecordHash()
     return hash((const char*)fieldPtr(0), datalen());
 }
 
-int table::bookMarksCount() const
+void table::insertBookmarks(unsigned int start, void* data, ushort_td count)
 {
-    int ret;
-    ret = m_impl->maxBookMarkedCount;
-    return ret;
+    m_stat =  m_impl->insertBookmarks(start, data, bookmarkLen(), count);
 }
 
-void table::moveBookmarksId(long id)
+int table::bookmarksCount() const
 {
-    long Point = (id - 1) * 6 + 2;
+    return m_impl->maxBookMarkedCount;
+}
 
-    if ((id <= m_impl->maxBookMarkedCount) && (m_impl->bookMarks))
-        seekByBookmark(*((bookmark_td*)((char*)m_impl->bookMarks + Point)));
-    else
-        seekByBookmark(0);
+void table::moveBookmarks(unsigned int index)
+{
+    seekByBookmark((bookmark_td*)m_impl->bookmarks(index, bookmarkLen()));
+}
+
+bookmark_td table::bookmarks(unsigned int index) const
+{
+    bookmark_td bm;
+    uchar_td* p = m_impl->bookmarks(index, bookmarkLen());
+    if (p)
+    {
+        memcpy(bm.val, p, bookmarkLen());
+        bm.empty = false;
+    }else
+    {
+        bm.empty = true;
+        m_stat = STATUS_PROGRAM_ERROR;
+    }
+    return bm;
 }
 
+/*bookmark_td* table::bookmarksPtr(unsigned int index) const
+{
+    return m_impl->bookmarksPtr(index);
+}*/
+
 short_td table::doBtrvErr(HWND hWnd, _TCHAR* retbuf)
 {
     return nstable::tdapErr(hWnd, m_stat, (*m_tableDef)->tableName(), retbuf);
@@ -2120,7 +2191,8 @@ struct impl
     impl()
         : m_reject(1), m_limit(0), m_joinKeySize(0),
           m_optimize(queryBase::none), m_direction(table::findForword),
-          m_nofilter(false), m_withBookmark(false), m_stopAtLimit(false)
+          m_nofilter(false), m_withBookmark(false), m_stopAtLimit(false),
+          m_seekByBookmarks(false)
     {
     }
 
@@ -2139,6 +2211,7 @@ struct impl
     {
         bool m_withBookmark : 1;
         bool m_stopAtLimit : 1;
+        bool m_seekByBookmarks : 1;
     };
 };
 
@@ -2223,6 +2296,7 @@ void queryBase::addSeekKeyValue(const _TCHAR* value, bool reset)
     }
     m_impl->m_keyValues.push_back(value);
     m_impl->m_nofilter = false;
+    m_impl->m_seekByBookmarks = false;
 }
 
 void queryBase::addSeekKeyValuePtr(const void* value, ushort_td len,
@@ -2236,6 +2310,13 @@ void queryBase::addSeekKeyValuePtr(const void* value, ushort_td len,
     }
     m_impl->m_keyValuesPtr.push_back(keyValuePtr(value, len, typeStr));
     m_impl->m_nofilter = false;
+    m_impl->m_seekByBookmarks = false;
+}
+
+void queryBase::addSeekBookmark(bookmark_td& bm, ushort_td len, bool reset)
+{
+    addSeekKeyValuePtr(&bm, len, KEYVALUE_PTR, reset);
+    m_impl->m_seekByBookmarks = true;
 }
 
 void queryBase::clearSeekKeyValues()
@@ -2439,6 +2520,12 @@ queryBase& queryBase::stopAtLimit(bool v)
     return *this;
 }
 
+bool queryBase::isSeekByBookmarks() const
+{
+    return m_impl->m_seekByBookmarks;
+}
+
+
 const std::vector<std::_tstring>& queryBase::getSelects() const
 {
     return m_impl->m_selects;

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

@@ -41,6 +41,17 @@ namespace client
 class database;
 class queryBase;
 class fields;
+class table;
+/** @endcond */
+
+#if (defined(__BORLANDC__) && !defined(__clang__))
+typedef void __stdcall(* recordCountFn)(table* tb, int count, bool& complate);
+#else
+/** @cond INTERNAL */
+/** Callback function on a record was record count. */
+typedef void(__STDCALL* recordCountFn)(table* tb, int count, bool& complate);
+#endif
+
 #define null_str _T("")
 
 #pragma warning(disable : 4251)
@@ -120,7 +131,6 @@ protected:
     void* dataBak() const;
     void* reallocDataBuffer(uint_td v);
     int dataBufferLen() const;
-    void setBookMarks(int StartId, void* Data, ushort_td Count);
     uint_td unPack(char* ptr, size_t size);
     uint_td pack(char* ptr, size_t size);
     keylen_td writeKeyData(); // orverride
@@ -147,7 +157,7 @@ protected:
 
     virtual void doInit(tabledef** def, short filenum, bool regularDir);
 
-    virtual void onRecordCounting(size_t count, bool& complate){};
+    virtual void onRecordCounting(size_t count, bool& cancel);
 
     virtual void setNoUpdateTimeStamp(bool v){};
 
@@ -172,8 +182,10 @@ public:
     void* optionalData() const;
     void setOptionalData(void* v);
     bool myDateTimeValueByBtrv() const;
-    int bookMarksCount() const;
-    void moveBookmarksId(long Id);
+    void insertBookmarks(unsigned int start, void* data, ushort_td count);
+    int bookmarksCount() const;
+    void moveBookmarks(unsigned int index);
+    bookmark_td bookmarks(unsigned int index) const;
     void clearBuffer();
     unsigned int getRecordHash();
     void smartUpdate();
@@ -275,6 +287,8 @@ public:
     void keyValueDescription(_TCHAR* buf, int bufsize);
     short getCurProcFieldCount() const;
     short getCurProcFieldIndex(short index) const;
+    void setOnRecordCount(const recordCountFn v);
+    recordCountFn onRecordCount() const;
     client::fields& fields();
 };
 
@@ -328,6 +342,7 @@ public:
     void addLogic(const _TCHAR* combine, const _TCHAR* name,
                   const _TCHAR* logic, const _TCHAR* value);
     void addSeekKeyValue(const _TCHAR* value, bool reset = false);
+    void addSeekBookmark(bookmark_td& bm, ushort_td len, bool reset = false);
     void addSeekKeyValuePtr(const void* value, ushort_td len, short typeStr,
                             bool reset = false);
     void reserveSeekKeyValueSize(size_t v);
@@ -350,13 +365,13 @@ public:
     eOptimize getOptimize() const;
     bool isStopAtLimit() const;
     bool isBookmarkAlso() const;
+    bool isSeekByBookmarks() const;
     short selectCount() const;
     const _TCHAR* getSelect(short index) const;
     short whereTokens() const;
     const _TCHAR* getWhereToken(short index) const;
     void setWhereToken(short index, const _TCHAR* v);
     void reverseAliasName(const _TCHAR* alias, const _TCHAR* src);
-
     void release(); // don't virtual
     static queryBase* create();
 };