transactd 2.2.0 → 2.3.0

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

@@ -150,28 +150,38 @@ class DLLLIB groupFuncBase : public recordsetQuery
 {
 protected:
     friend class groupQueryImple;
+    friend class groupFuncBaseImple;
+
+    typedef double numeric_type;
 
     class groupFuncBaseImple* m_imple;
+
+    void init(const fielddefs* fdinfo);
+    unsigned char* stringResult(int groupIndex) const;
+    uchar_td resultType() const;
+    ushort_td resultLen() const;
+    void operator()(const row_ptr& row, int index, bool insert);
+
     virtual void initResultVariable(int index);
     virtual void doCalc(const row_ptr& row, int groupIndex);
-    void init(const fielddefs* fdinfo);
+    virtual void doReset();
+    virtual void doInit(const fielddefs* fdinfo);
+    virtual numeric_type numericResult(int groupIndex) const;
+    
 
 public:
-    typedef double value_type;
     groupFuncBase();
     groupFuncBase(const groupFuncBase& v);
-    groupFuncBase& operator=(const groupFuncBase& v);
     groupFuncBase(const fieldNames& targetNames,
                   const _TCHAR* resultName = NULL);
     virtual ~groupFuncBase();
+    groupFuncBase& operator=(const groupFuncBase& v);
     groupFuncBase& operator=(const recordsetQuery& v);
     fieldNames& targetNames() const;
     const _TCHAR* resultName() const;
     void setResultName(const _TCHAR* v);
     int resultKey() const;
     void reset();
-    void operator()(const row_ptr& row, int index, bool insert);
-    virtual value_type result(int groupIndex) const;
     virtual groupFuncBase* clone() = 0;
 };
 
@@ -208,11 +218,10 @@ class DLLLIB sum : public groupFuncBase
 {
 protected:
     void doCalc(const row_ptr& row, int index);
-
+    groupFuncBase* clone();
 public:
     sum() {}
     sum(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
-    groupFuncBase* clone();
     static sum* create(const fieldNames& targetNames,
                        const _TCHAR* resultName = NULL);
 };
@@ -220,26 +229,25 @@ public:
 class DLLLIB count : public groupFuncBase
 {
 protected:
+    groupFuncBase* clone();
     void doCalc(const row_ptr& row, int index);
 
 public:
     count() {}
     count(const _TCHAR* resultName);
-    groupFuncBase* clone();
     static count* create(const _TCHAR* resultName);
 };
 
 class DLLLIB avg : public sum
 {
-
     void initResultVariable(int index);
     void doCalc(const row_ptr& row, int index);
-    value_type result(int index) const;
+    numeric_type numericResult(int index) const;
+    groupFuncBase* clone();
 
 public:
     avg() {}
     avg(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
-    groupFuncBase* clone();
     static avg* create(const fieldNames& targetNames,
                        const _TCHAR* resultName = NULL);
 };
@@ -247,13 +255,15 @@ public:
 #undef min
 class DLLLIB min : public sum
 {
+protected:
     bool m_flag;
     void doCalc(const row_ptr& row, int index);
+    groupFuncBase* clone();
+    min& operator=(const min& r);
 
 public:
     min() {}
     min(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
-    groupFuncBase* clone();
     static min* create(const fieldNames& targetNames,
                        const _TCHAR* resultName = NULL);
 };
@@ -263,15 +273,48 @@ class DLLLIB max : public sum
 {
     bool m_flag;
     void doCalc(const row_ptr& row, int index);
+    groupFuncBase* clone();
+    max& operator=(const max& r);
 
 public:
     max() {}
     max(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
-    groupFuncBase* clone();
     static max* create(const fieldNames& targetNames,
                        const _TCHAR* resultName = NULL);
 };
 
+
+class DLLLIB last : public groupFuncBase
+{
+protected:
+    void doCalc(const row_ptr& row, int index);
+    void doInit(const fielddefs* fdinfo);
+    groupFuncBase* clone();
+public:
+    last() {}
+    last(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
+    static last* create(const fieldNames& targetNames,
+                       const _TCHAR* resultName = NULL);
+};
+
+
+class DLLLIB first : public last
+{
+    bool m_readed;
+protected:
+    void doCalc(const row_ptr& row, int index);
+    void doReset();
+    groupFuncBase* clone();
+    first& operator=(const first& r);
+public:
+    first() {}
+    first(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
+    static first* create(const fieldNames& targetNames,
+                       const _TCHAR* resultName = NULL);
+};
+
+
+
 } // namespace client
 } // namespace tdap
 } // namespace protocol

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

@@ -31,6 +31,7 @@
 typedef void* HANDLE;
 typedef void* HINSTANCE;
 #endif
+#include <bzs/db/protocol/tdap/tdapRequest.h>
 
 #pragma package(smart_init)
 
@@ -762,20 +763,97 @@ bool nsdatabase::connect(const _TCHAR* URI, bool newConnection)
 
 bool nsdatabase::disconnect(const _TCHAR* URI)
 {
-    if (isTransactdUri(URI))
+    if (!URI || (URI[0] == 0x00) || isTransactdUri(URI))
         if (!setUseTransactd())
             return false;
     uint_td datalen = 0;
-    char uri_a[MAX_PATH];
-    const char* p = toServerUri(uri_a, MAX_PATH, URI, isUseTransactd());
-    m_stat = m_btrcallid(TD_CONNECT, NULL, NULL, &datalen, (void*)p,
-                         (keylen_td)(strlen(p) + 1), LG_SUBOP_DISCONNECT,
+
+    //Transactd not use uri.
+    m_stat = m_btrcallid(TD_CONNECT, NULL, NULL, &datalen, (void*)URI,
+                         (keylen_td)(_tcslen(URI) + 1), LG_SUBOP_DISCONNECT,
                          clientID());
     if (m_stat)
         return false;
     return true;
 }
 
+
+bool nsdatabase::disconnectForReconnectTest()
+{
+    //Transactd only
+    if (!isUseTransactd())
+        return false;
+
+    uint_td datalen = 0;
+    m_stat = m_btrcallid(TD_CONNECT, NULL, NULL, &datalen, NULL,
+                         0, LG_SUBOP_DISCONNECT_EX,
+                         clientID());
+    if (m_stat)
+        return false;
+    return true;
+}
+
+/* TD_RECONNECT data buffer structure
+   
+   1 byte keynum
+   1 byte bookmark size
+   n byte bookmark
+
+*/
+void nsdatabase::doReconnect(nstable* tb)
+{
+    uint_td datalen = 0;
+    char uri_a[MAX_PATH] = { 0x00 };
+    tb->abortBulkInsert();
+    datalen = tb->buflen();
+    tdap::posblk* pb = (tdap::posblk*)tb->posblk(); 
+    char* databuf = new char[datalen];
+    databuf[0] = tb->keyNum();
+    memcpy(databuf + 1, &pb->bookmarkLen, pb->bookmarkLen + 1);
+    const char* p = toServerUri(uri_a, MAX_PATH, tb->uri(), true);
+    short offset = (pb->lock) ? ROW_LOCK_X : 0;
+    m_stat = m_btrcallid(TD_RECONNECT + offset, pb, databuf, &datalen, (void*)p,
+                    (keylen_td)(strlen(p) + 1), tb->mode(), clientID());
+    delete [] databuf;
+}
+
+bool nsdatabase::reconnect()
+{
+    //Transactd only
+    if (!isUseTransactd())
+        return false;
+    m_nsimpl->tranCount = 0;
+    m_nsimpl->snapShotCount = 0;
+
+   
+    uint_td datalen = 0;
+    char uri_a[MAX_PATH] = { 0x00 };
+    const char* p = toServerUri(uri_a, MAX_PATH, m_nsimpl->bdfPath, true);
+    m_stat = m_btrcallid(TD_CONNECT, NULL, NULL, &datalen, (void*)p,
+                         (keylen_td)(strlen(p) + 1), 
+                         LG_SUBOP_RECONNECT, clientID());
+    if (m_stat) return false;
+
+    //Whole table, restore position.
+    nstable* lockedTable = NULL; //This is only one.
+    for (int i=0;i<m_nsimpl->tableCount;++i)
+    {
+        nstable* tb = m_nsimpl->tables[i];
+        if (tb && tb->isOpen())
+        {
+            tdap::posblk* pb = (tdap::posblk*)tb->posblk();
+            if (pb->lock)
+                lockedTable = tb;
+            else
+                doReconnect(tb);
+            if (m_stat != 0) break;
+        }
+    }
+    if (lockedTable)
+        doReconnect(lockedTable);
+    return (m_stat == 0);
+}
+
 bool nsdatabase::trnsactionFlushWaitStatus()
 {
     bool ret = false;

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

@@ -77,7 +77,7 @@ protected:
     bool findTable(nstable* tb);
     void addref();
     void internalRelease() { nsdatabase::release(); }
-
+    void doReconnect(nstable* tb);
 public:
     nsdatabase();
     virtual void release();
@@ -121,6 +121,9 @@ public:
     void readDatabaseDirectory(_TCHAR* retBuf, uchar_td len);
     bool connect(const _TCHAR* uri, bool newConnection = false);
     bool disconnect(const _TCHAR* uri = _T(""));
+    bool disconnectForReconnectTest(); //for connection brokn emulate
+	bool reconnect();
+
     static const int maxtables = 50;
     static bool trnsactionFlushWaitStatus();
     static void setExecCodePage(unsigned int codepage);

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

@@ -388,10 +388,10 @@ void nstable::doOpen(const _TCHAR* name, char_td mode, const _TCHAR* ownerName)
     else
         m_keynum = mode;
 
-    char ownerNameBuf[OWNERNAME_SIZE + 1] = { 0x00 };
+    char ownerNameBuf[OWNERNAME_SIZE] = { 0x00 };
     if (NULL != ownerName && 0x00 != ownerName[0])
     {
-        const char* p2 = toChar(ownerNameBuf, ownerName, 22);
+        const char* p2 = toChar(ownerNameBuf, ownerName, OWNERNAME_SIZE);
         m_pdata = (void*)p2;
         m_datalen = (uint_td)strlen(p2) + 1;
         if (m_datalen > 11)

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

@@ -56,7 +56,8 @@ public:
     enum eFindType
     {
         findForword,
-        findBackForword
+        findBackForword,
+        findContinue
     };
     static const bool inkey = true;
 

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

@@ -98,9 +98,10 @@ class pooledDbManager : public idatabaseManager
     dbmanager_ptr m_db;
     bool m_inUse;
     xaTransaction m_xa;
+    bool m_use_xa;
 
 public:
-    inline pooledDbManager() : m_inUse(false){};
+    inline pooledDbManager() : m_inUse(false),m_use_xa(false){};
 
     inline pooledDbManager(const connectParams* param) : m_inUse(false)
     {
@@ -113,6 +114,10 @@ public:
             unUse();
     }
 
+    inline bool isUseXa() const {return m_use_xa;}
+
+    inline void setUseXa(bool v) {m_use_xa = v;}
+
     inline void use(const connectParams* param = NULL)
     {
         m_db = cpool.get(param);
@@ -139,15 +144,24 @@ public:
 
     inline bool isOpened() const { return m_db->isOpened(); }
 
-    inline void setOption(__int64 v) { m_db->setOption(v); };
+    inline void setOption(__int64 v) { m_db->setOption(v); }
 
-    inline __int64 option() { return m_db->option(); };
+    inline __int64 option() { return m_db->option(); }
 
-    inline void beginTrn(short bias) { m_xa.beginTrn(bias); };
+    inline void beginTrn(short bias) 
+    { 
+        (m_use_xa == true) ? m_xa.beginTrn(bias) : m_db->beginTrn(bias); 
+    }
 
-    inline void endTrn() { m_xa.endTrn(); }
+    inline void endTrn() 
+    { 
+        (m_use_xa == true) ? m_xa.endTrn() : m_db->endTrn(); 
+    }
 
-    inline void abortTrn() { m_xa.abortTrn(); }
+    inline void abortTrn() 
+    { 
+        (m_use_xa == true) ? m_xa.abortTrn() : m_db->abortTrn(); 
+    }
 
     inline int enableTrn() { return m_db->enableTrn(); }
 

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

@@ -186,6 +186,13 @@ void recordset::appendField(const _TCHAR* name, int type, short len)
 
 recordset& recordset::operator+=(const recordset& r)
 {
+    if (r.size() == 0)
+        return *this;
+    if ((size() == 0) && r.size())
+    {
+        *this = r;
+        return *this;
+    }
     m_imple->operator+=(*r.m_imple);
     return *this;
 }

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

@@ -387,10 +387,13 @@ public:
 
     inline void clear()
     {
-        clearRecords();
-        m_fds->clear();
-        m_unionFds.clear();
-        m_memblock.clear();
+        if (m_memblock.size())
+        {
+            clearRecords();
+            m_fds->clear();
+            m_unionFds.clear();
+            m_memblock.clear();
+        }
     }
 
     inline row_ptr& getRow(size_t index) { return m_recordset[index]; }
@@ -567,6 +570,7 @@ public:
         assert(m_fds->size());
         
         fielddef fd((*m_fds)[0]);
+        memset(&fd, 0, sizeof(fielddef));
         fd.len = len;
         fd.pos = 0;
         fd.type = type;

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

@@ -51,7 +51,6 @@ class request : public bzs::db::protocol::tdap::request,
 {
 public:
     clientID* cid;
-
     request() : bzs::db::protocol::tdap::request(), cid(NULL){};
 
     unsigned int onRead(unsigned int size, bzs::netsvc::client::connection* c) // orverride
@@ -123,7 +122,18 @@ public:
         {
             memcpy(pbk, p, TD_POSBLK_TRANSMIT_SIZE);
             p += TD_POSBLK_TRANSMIT_SIZE;
+            if (P_MASK_PB_BOOKMARK & paramMask)
+            {
+                unsigned char len =  *((unsigned char*)p);
+                // copy sizeByte and bookmark
+                pbk->bookmarkLen = len;
+                pbk->lock = ((paramMask & P_MASK_PB_LOCKED) != 0);
+                memcpy(pbk->bookmark, ++p , len);
+                p += len;
+            }
         }
+        if (P_MASK_PB_ERASE_BM & paramMask)
+             pbk->bookmarkLen = 0; 
 
         if (P_MASK_DATALEN & paramMask)
         {

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

@@ -48,6 +48,8 @@ BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::count, "count");
 BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::avg, "avg");
 BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::min, "min");
 BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::max, "max");
+BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::first, "first");
+BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::last, "last");
 
 BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::readStatement,
                         "readStatement");
@@ -63,6 +65,7 @@ BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::reverseOrderStatement,
                         "reverseOrderStatement");
 
 BOOST_CLASS_VERSION(bzs::db::protocol::tdap::client::groupFuncBase, 1)
+BOOST_CLASS_VERSION(bzs::db::protocol::tdap::client::queryBase, 1)
 
 namespace bzs
 {
@@ -201,7 +204,7 @@ void serialize(Archive& ar, queryBase& q, const unsigned int version)
 }
 
 template <class Archive>
-void save(Archive& ar, const queryBase& q, const unsigned int /*version*/)
+void save(Archive& ar, const queryBase& q, const unsigned int version)
 {
     std::_tstring s = q.toString();
 
@@ -214,12 +217,22 @@ void save(Archive& ar, const queryBase& q, const unsigned int /*version*/)
     ar& make_nvp("optimize", v);
     v = q.isBookmarkAlso();
     ar& make_nvp("boolmarkAlso", v);
+
+    if (version >= 1)
+    {
+        v = q.getDirection();
+        ar& make_nvp("direction", v);
+
+        v = q.isStopAtLimit();
+        ar& make_nvp("stopAtLimit", v);
+
+    }
     v = q.isAll();
     ar& make_nvp("isAll", v);
 }
 
 template <class Archive>
-void load(Archive& ar, queryBase& q, const unsigned int /*version*/)
+void load(Archive& ar, queryBase& q, const unsigned int version)
 {
     std::_tstring s;
     int v;
@@ -240,6 +253,13 @@ void load(Archive& ar, queryBase& q, const unsigned int /*version*/)
     ar& make_nvp("boolmarkAlso", v);
     q.bookmarkAlso(v != 0);
 
+    if (version >= 1)
+    {
+        ar& make_nvp("direction", v);
+        q.direction((table::eFindType)v);
+        ar& make_nvp("stopAtLimit", v);
+        q.stopAtLimit(v == 1);
+    }
     ar& make_nvp("isAll", v);
     if (v)
         q.all();
@@ -342,6 +362,18 @@ void serialize(Archive& ar, max& q, const unsigned int /*version*/)
     ar& make_nvp("param", boost::serialization::base_object<groupFuncBase>(q));
 }
 
+template <class Archive>
+void serialize(Archive& ar, first& q, const unsigned int /*version*/)
+{
+    ar& make_nvp("param", boost::serialization::base_object<groupFuncBase>(q));
+}
+
+template <class Archive>
+void serialize(Archive& ar, last& q, const unsigned int /*version*/)
+{
+    ar& make_nvp("param", boost::serialization::base_object<groupFuncBase>(q));
+}
+
 template <class Archive>
 void serialize(Archive& ar, groupQuery& q, const unsigned int /*version*/)
 {
@@ -449,6 +481,12 @@ groupFuncBase& groupByStatement::addFunction(eFunc v,
     case fmax:
         func = new client::max(targetNames, resultName);
         break;
+    case ffirst:
+        func = new client::first(targetNames, resultName);
+        break;
+    case flast:
+        func = new client::last(targetNames, resultName);
+        break;
     };
     m_statements->push_back(func);
     return *func;

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

@@ -88,7 +88,9 @@ public:
         fcount,
         favg,
         fmin,
-        fmax
+        fmax,
+        ffirst,
+        flast
     };
     groupByStatement();
     ~groupByStatement();
@@ -103,7 +105,7 @@ public:
     static groupByStatement* create();
 };
 
-#define MAX_FUNCTION_SIZE (int) groupByStatement::fmax + 1
+#define MAX_FUNCTION_SIZE (int) groupByStatement::flast + 1
 
 class DLLLIBSTMT matchByStatement : public recordsetQuery, public executable
 {

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

@@ -144,6 +144,7 @@ const char* getFieldTypeName(uchar_td fieldType, int size, bool nobinary,
         if (size == 8)
             return "DOUBLE";
     case ft_string:
+    case ft_wstring:
         sprintf_s(g_buf, TMP_BUFSIZE, "BINARY(%d)", size);
         return g_buf;
     case ft_zstring:

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

@@ -418,12 +418,12 @@ public:
 typedef myVarBinaryStoreBase myWvarBinaryStore;
 typedef myVarBinaryStoreBase myVarBinaryStore;
 
-class myBinaryStoreBase
+class binaryStoreBase
 {
     const fielddef& m_fd;
 
 public:
-    inline myBinaryStoreBase(const fielddef& fd) : m_fd(fd){};
+    inline binaryStoreBase(const fielddef& fd) : m_fd(fd){};
 
     inline size_t maxStoreBytes() const { return m_fd.len; };
 
@@ -436,8 +436,8 @@ public:
     inline bool isNeedReadCopy() const { return true; }
 };
 
-typedef myBinaryStoreBase myWbinaryStore;
-typedef myBinaryStoreBase myBinaryStore;
+typedef binaryStoreBase wbinaryStore;
+typedef binaryStoreBase binaryStore;
 
 class zstringStore
 {