transactd 1.2.0 → 2.0.0

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

@@ -0,0 +1,370 @@
+#ifndef BZS_DB_PROTOCOL_TDAP_CLIENT_ACTIVETABLEIMPLE_H
+#define BZS_DB_PROTOCOL_TDAP_CLIENT_ACTIVETABLEIMPLE_H
+/*=================================================================
+   Copyright (C) 2014 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
+   as published by the Free Software Foundation; either version 2
+   of the License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.
+=================================================================*/
+#include "trdboostapi.h"
+#include "trdormapi.h"
+#include "recordsetImple.h"
+#include "memRecord.h"
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+namespace client
+{
+
+class map_orm_fdi
+{
+    friend class map_orm;
+    const table* m_tb;
+
+public:
+    void init(table* tb) { m_tb = tb; }
+};
+
+inline map_orm_fdi* createFdi(map_orm_fdi*)
+{
+    return new map_orm_fdi();
+}
+inline void destroyFdi(map_orm_fdi* p)
+{
+    delete p;
+}
+inline void initFdi(map_orm_fdi* fdi, table* tb)
+{
+    fdi->init(tb);
+}
+
+class map_orm
+{
+    const map_orm_fdi& m_fdi;
+    short m_autoIncFiled;
+
+    int comp(row& lm, row& rm, const _TCHAR* name, int index) const
+    {
+        return lm[index].comp(rm[index], 0);
+    }
+
+public:
+    map_orm(const map_orm_fdi& fdi) : m_fdi(fdi), m_autoIncFiled(-2) {}
+
+    bool compKeyValue(row& l, row& r, int keyNum) const
+    {
+        const tabledef* def = m_fdi.m_tb->tableDef();
+        const keydef* kd = &def->keyDefs[keyNum];
+        for (int i = 0; i < kd->segmentCount; ++i)
+        {
+            short n = kd->segments[i].fieldNum;
+            const fielddef* fd = &def->fieldDefs[n];
+            int ret = comp(l, r, fd->name(), n);
+            if (ret)
+                return (ret < 0);
+        }
+        return 0;
+    }
+
+    template <class T> void readMap(T& m, const fields& fds, int optipn)
+    {
+        // needlessness
+    }
+
+    typedef row mdl_typename;
+    typedef map_orm_fdi fdi_typename;
+    typedef mdlsHandler<map_orm, recordsetImple> collection_orm_typename;
+};
+
+struct joinInfo
+{
+    std::_tstring fixedValue;
+    ushort_td len;
+    ushort_td type;
+};
+
+#define JOIN_KEYVALUE_TYPE_PTR 0
+#define JOIN_KEYVALUE_TYPE_STR 1
+
+class activeTableImple : public activeObject<map_orm>
+{
+
+    typedef recordsetImple Container;
+    typedef boost::shared_ptr<writableRecord> record;
+    typedef activeObject<map_orm> baseClass_type;
+    typedef std::vector<std::vector<int> > joinmap_type;
+    record m_record;
+
+    // return can memcpy
+    uchar_td convertFieldType(uchar_td v)
+    {
+        if (v == ft_autoinc)
+            v = ft_integer;
+        else if (v == ft_autoIncUnsigned)
+            v = ft_integer;
+        else if (v == ft_uinteger)
+            v = ft_integer;
+        else if (v == ft_logical)
+            v = ft_integer;
+        else if (v == ft_bit)
+            v = ft_integer;
+        return v;
+    }
+
+    template <class Container>
+    inline void
+    makeJoinFieldInfo(Container& mdls, const fielddefs* fds,
+                      const fieldNames& fns,
+                      std::vector<typename Container::key_type>& fieldIndexes,
+                      std::vector<joinInfo>& joinFields)
+    {
+        joinFields.resize(fns.count());
+        fieldIndexes.resize(fns.count());
+        const tabledef* td = table()->tableDef();
+        const keydef* kd = &td->keyDefs[table()->keyNum()];
+        if (kd->segmentCount < fns.count())
+            THROW_BZS_ERROR_WITH_MSG(_T("Join key fields are too many.\n ")
+                                     _T("Check index number and field count."));
+
+        for (int i = 0; i < fns.count(); ++i)
+        {
+            std::_tstring s = fns.getValue(i);
+            if (s[0] == '[')
+            {
+                fieldIndexes[i] = -1;
+                joinFields[i].type = JOIN_KEYVALUE_TYPE_PTR;
+                joinFields[i].len = (ushort_td)(s.size() - 2);
+                joinFields[i].fixedValue = s.substr(1, s.size() - 2);
+            }
+            else
+            {
+                ushort_td index = resolvKeyValue(mdls, s, false);
+                fieldIndexes[i] = index;
+                const fielddef& fd = (*fds)[index];
+                // Check the fieldType
+                if (convertFieldType(fd.type) ==
+                    convertFieldType(
+                        td->fieldDefs[kd->segments[i].fieldNum].type))
+                {
+                    joinFields[i].len = fd.len;
+                    joinFields[i].type = JOIN_KEYVALUE_TYPE_PTR;
+                }
+                else
+                {
+                    joinFields[i].len = 0;
+                    joinFields[i].type = JOIN_KEYVALUE_TYPE_STR;
+                }
+            }
+        }
+    }
+
+    template <class Container>
+    inline void
+    addSeekValues(row& mdl, queryBase& q,
+                  std::vector<typename Container::key_type>& fieldIndexes,
+                  std::vector<joinInfo>& joinFields)
+    {
+        for (int i = 0; i < (int)fieldIndexes.size(); ++i)
+        {
+            if (fieldIndexes[i] == -1)
+                q.addSeekKeyValuePtr(joinFields[i].fixedValue.c_str(),
+                                     joinFields[i].len, KEYVALUE_STR);
+            else if (joinFields[i].type == JOIN_KEYVALUE_TYPE_PTR)
+                q.addSeekKeyValuePtr(mdl[fieldIndexes[i]].ptr(),
+                                     joinFields[i].len, KEYVALUE_PTR);
+            else
+            {
+                const _TCHAR* p = mdl[fieldIndexes[i]].c_str();
+                q.addSeekKeyValuePtr(p, (ushort_td)_tcslen(p),
+                                     KEYVALUE_STR_NEED_COPY);
+            }
+        }
+    }
+
+    template <class Container>
+    void makeJoinMap(Container& mdls, joinmap_type& joinRowMap,
+                     std::vector<typename Container::key_type>& keyFields)
+    {
+        grouping_comp<Container> groupingComp(mdls, keyFields);
+        std::vector<int> index;
+        std::vector<int> tmp;
+        for (int n = 0; n < (int)mdls.size(); ++n)
+        {
+            bool found = false;
+            int i = binary_search(n, index, 0, (int)index.size(), groupingComp,
+                                  found);
+            if (!found)
+            {
+                index.insert(index.begin() + i, n);
+                joinRowMap.insert(joinRowMap.begin() + i, tmp);
+            }
+            joinRowMap[i].push_back(n);
+        }
+    }
+
+    template <class Container>
+    void doJoin(bool innner, Container& mdls, queryBase& q, const _TCHAR* name1,
+                const _TCHAR* name2 = NULL, const _TCHAR* name3 = NULL,
+                const _TCHAR* name4 = NULL, const _TCHAR* name5 = NULL,
+                const _TCHAR* name6 = NULL, const _TCHAR* name7 = NULL,
+                const _TCHAR* name8 = NULL)
+    {
+        if (mdls.size() == 0)
+            return;
+        m_alias.reverseAliasNamesQuery(q);
+        q.clearSeekKeyValues();
+
+        mraResetter mras(m_tb);
+        typename Container::iterator it = mdls.begin(), ite = mdls.end();
+
+        bool optimize = !(q.getOptimize() & queryBase::joinHasOneOrHasMany);
+        joinmap_type joinRowMap;
+
+        fieldNames fns;
+        fns.keyField(name1, name2, name3, name4, name5, name6, name7, name8);
+
+        std::vector<typename Container::key_type> fieldIndexes;
+        std::vector<joinInfo> joinFields;
+
+        const fielddefs* fds = mdls.fieldDefs();
+        makeJoinFieldInfo<Container>(mdls, fds, fns, fieldIndexes, joinFields);
+
+        // optimizing join
+        // if base recordsetImple is made by unique key and join by uniqe field,
+        // that can not opitimize.
+        //
+        q.joinKeySize(fns.count());
+        if (optimize)
+        {
+            makeJoinMap(mdls, joinRowMap, fieldIndexes);
+            q.reserveSeekKeyValuePtrSize(joinRowMap.size() *
+                                         fieldIndexes.size());
+            std::vector<std::vector<int> >::iterator it1 = joinRowMap.begin(),
+                                                     ite1 = joinRowMap.end();
+            while (it1 != ite1)
+            {
+                row& mdl = *(mdls.getRow((*it1)[0]));
+                addSeekValues<Container>(mdl, q, fieldIndexes, joinFields);
+                ++it1;
+            }
+        }
+        else
+        {
+            q.reserveSeekKeyValuePtrSize(mdls.size() * fieldIndexes.size());
+            while (it != ite)
+            {
+                row& mdl = *(*it);
+                addSeekValues<Container>(mdl, q, fieldIndexes, joinFields);
+                ++it;
+            }
+        }
+
+        m_tb->setQuery(&q);
+        if (m_tb->stat() != 0)
+            nstable::throwError(_T("activeObject Join Query"), &(*m_tb));
+
+        typename map_orm::collection_orm_typename map(mdls);
+
+        // std::vector<typename Container::iterator> ignores;
+        it = mdls.begin();
+        map.init(m_option, m_fdi, m_map, m_tb, &m_alias);
+        if (m_tb->mra())
+        {
+            m_tb->mra()->setJoinType(innner ? mra_innerjoin : mra_outerjoin);
+            if (optimize)
+                m_tb->mra()->setJoinRowMap(&joinRowMap);
+        }
+        m_tb->find();
+        while (1)
+        {
+            if (m_tb->stat())
+            {
+                if ((m_tb->stat() == STATUS_EOF) ||
+                    ((m_tb->stat() != STATUS_SUCCESS) &&
+                     (m_tb->stat() != STATUS_NOT_FOUND_TI)))
+                    break;
+            }
+            ++it;
+            m_tb->findNext(); // mra copy value to memrecord
+        }
+
+        readStatusCheck(*m_tb, _T("join"));
+        m_tb->mra()->setJoinRowMap(NULL);
+
+        // remove record see ignore list for inner join
+        if (innner)
+        {
+            for (int i = (int)mdls.size() - 1; i >= 0; --i)
+            {
+                if (mdls[i].isInvalidRecord())
+                    mdls.erase(i);
+            }
+        }
+    }
+
+public:
+    explicit activeTableImple(idatabaseManager* mgr, const _TCHAR* tableName)
+        : baseClass_type(mgr, tableName){};
+
+    explicit activeTableImple(database_ptr& db, const _TCHAR* tableName)
+        : baseClass_type(db, tableName){};
+
+    explicit activeTableImple(database* db, const _TCHAR* tableName)
+        : baseClass_type(db, tableName){};
+
+    inline writableRecord& getWritableRecord()
+    {
+        m_record.reset(writableRecord::create(m_tb.get(), &m_alias),
+                       &writableRecord::release);
+        return *m_record.get();
+    }
+
+    inline void join(Container& mdls, queryBase& q, const _TCHAR* name1,
+                     const _TCHAR* name2 = NULL, const _TCHAR* name3 = NULL,
+                     const _TCHAR* name4 = NULL, const _TCHAR* name5 = NULL,
+                     const _TCHAR* name6 = NULL, const _TCHAR* name7 = NULL,
+                     const _TCHAR* name8 = NULL)
+    {
+        doJoin(true, mdls, q, name1, name2, name3, name4, name5, name6, name7,
+               name8);
+    }
+
+    inline void
+    outerJoin(Container& mdls, queryBase& q, const _TCHAR* name1,
+              const _TCHAR* name2 = NULL, const _TCHAR* name3 = NULL,
+              const _TCHAR* name4 = NULL, const _TCHAR* name5 = NULL,
+              const _TCHAR* name6 = NULL, const _TCHAR* name7 = NULL,
+              const _TCHAR* name8 = NULL)
+    {
+        doJoin(false, mdls, q, name1, name2, name3, name4, name5, name6, name7,
+               name8);
+    }
+
+    void releaseTable() { m_tb.reset(); }
+};
+
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
+
+#endif // BZS_DB_PROTOCOL_TDAP_CLIENT_ACTIVETABLEIMPLE_H

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

@@ -49,22 +49,17 @@ public:
         m_ptr = m_buf + sizeof(ushort_td);
         m_count = 0;
         m_buflen = BULKBUFSIZE;
-
     }
 
-    ~bulkInsert()
-    {
-        delete [] m_buf;
-    }
+    ~bulkInsert() { delete[] m_buf; }
 
     char* reallocBuffer(char* buf, int oldsize, int newSize)
     {
         char* p = new char[newSize];
         memcpy(p, buf, oldsize);
-        delete [] buf;
+        delete[] buf;
 
         return p;
-
     }
 
     ushort_td insert(const char* p, ushort_td size, nstable* tb)
@@ -73,17 +68,17 @@ public:
         if (m_count == (int)(USHRT_MAX - 3))
         {
             ins_rows = tb->commitBulkInsert(true /* auto */);
-            m_ptr = m_buf +sizeof(ushort_td);
+            m_ptr = m_buf + sizeof(ushort_td);
             m_count = 0;
         }
 
         // check over run. current size + need size
-        if ((m_ptr - m_buf )+ size + sizeof(ushort_td) > (uint_td)m_buflen)
+        if ((m_ptr - m_buf) + size + sizeof(ushort_td) > (uint_td)m_buflen)
         {
             if ((int)(m_buflen + BULKBUFSIZE) > m_maxBuflen)
             {
                 ins_rows = tb->commitBulkInsert(true /* auto */);
-                m_ptr = m_buf +sizeof(ushort_td);
+                m_ptr = m_buf + sizeof(ushort_td);
                 m_count = 0;
             }
             else
@@ -100,7 +95,6 @@ public:
         m_ptr += size;
         m_count++;
         return ins_rows;
-
     }
 
     void* data()
@@ -109,19 +103,15 @@ public:
         return m_buf;
     }
 
-    uint_td dataLen()
-    {
-        return (uint_td)(m_ptr - m_buf);
-    }
-
-    int count() {return m_count;}
+    uint_td dataLen() { return (uint_td)(m_ptr - m_buf); }
 
+    int count() { return m_count; }
 };
 
-}//namespace client
-}//namespace tdap
-}//namespace protocol
-}//namespace db
-}//namespace bzs
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
 
-#endif//BZS_DB_PROTOCOL_TDAP_CLIENT_BULKINSERT_H
+#endif // BZS_DB_PROTOCOL_TDAP_CLIENT_BULKINSERT_H

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

@@ -1,21 +1,21 @@
-/*=================================================================
-   Copyright (C) 2012 2013 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
-   as published by the Free Software Foundation; either version 2
-   of the License, or (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-   02111-1307, USA.
-=================================================================*/
+/* =================================================================
+ Copyright (C) 2012 2013 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
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+ ================================================================= */
 #include "client.h"
 #include "sqlBuilder.h"
 #include "stringConverter.h"
@@ -24,7 +24,6 @@ using namespace bzs::db::protocol::tdap::client;
 
 bzs::netsvc::client::connections* m_cons = NULL;
 
-
 namespace bzs
 {
 namespace db
@@ -39,68 +38,82 @@ namespace client
 #ifdef USETLS
 tls_key g_tlsiID;
 #else
-__THREAD client* __THREAD_BCB g_client=NULL;
+__THREAD client* __THREAD_BCB g_client = NULL;
 #endif
 
+bool checkVersion(trdVersiton& ver)
+{
+    if ((ver.srvMajor < 1) || ((ver.srvMajor == 1) && (ver.srvMinor < 3)))
+        return false;
+    return true;
+}
 
 bool client::readServerCharsetIndex()
 {
-	if (m_charsetIndexServer == -1)
-	{
-		request req = m_req;
-		uint_td len = 256;
-		char tmp[256]={0x00};
-		req.op = TD_GETSERVER_CHARSET;
-		req.data = tmp;
-		req.datalen = &len;
-
-		mutex::scoped_lock lck(m_mutex);
-		char* p = con()->sendBuffer();
-		unsigned int size = req.serialize(p);
-		p = con()->asyncWriteRead(size);
-		req.parse(p);
-		if (req.result==0)
-		{
-			m_charsetIndexServer = mysql::charsetIndex((const char*)req.data);
-			return true;
-		}
-		return false;
-	}
-	return true;
+    if (m_charsetIndexServer == -1)
+    {
+        request req = m_req;
+        req.paramMask = P_MASK_POSBLK | P_MASK_DATA | P_MASK_DATALEN;
+        trdVersiton ver;
+        memset(&ver, 0, sizeof(trdVersiton));
+        ver.cherserServer[0] = 0x00;
+        ver.clMajor = (ushort_td)atoi(C_INTERFACE_VER_MAJOR);
+        ver.clMinor = (ushort_td)atoi(C_INTERFACE_VER_MINOR);
+        ver.clRelease = (ushort_td)atoi(C_INTERFACE_VER_RELEASE);
+
+        uint_td len = sizeof(trdVersiton);
+        req.op = TD_GETSERVER_CHARSET;
+        req.data = &ver;
+        req.datalen = &len;
+
+        mutex::scoped_lock lck(m_mutex);
+        char* p = con()->sendBuffer(m_req.sendLenEstimate());
+        unsigned int size = req.serialize(p);
+        p = con()->asyncWriteRead(size);
+        req.parse(p, 0, 0);
+        if (req.result == 0)
+        {
+            if (!checkVersion(ver))
+                return false;
+            m_charsetIndexServer = mysql::charsetIndex(ver.cherserServer);
+            return true;
+        }
+        return false;
+    }
+    return true;
 }
 
 void client::addSecondCharsetData(unsigned int destCodePage, std::string& src)
 {
-	stringConverter cv(destCodePage, CP_UTF8);
-	int osize = (int)src.size()*3;
-	char* srvchar = new char[osize];
-	
-	size_t len = cv.convert(srvchar, osize, src.c_str(), src.size());
-	srvchar[len]  = 0x00;
-	src += std::string("\t")  + srvchar;
-	delete [] srvchar;
+    stringConverter cv(destCodePage, CP_UTF8);
+    int osize = (int)src.size() * 3;
+    char* srvchar = new char[osize];
+
+    size_t len = cv.convert(srvchar, osize, src.c_str(), src.size());
+    srvchar[len] = 0x00;
+    src += std::string("\t") + srvchar;
+    delete[] srvchar;
 }
 
 bool client::buildDualChasetKeybuf()
 {
-	if (!readServerCharsetIndex())
-		return false;
-	//m_serverCharData = std::string((char*)m_req.keybuf, m_req.keylen);
-	m_serverCharData = (char*)m_req.keybuf;
-	if (CHARSET_UTF8 != m_charsetIndexServer)
-		addSecondCharsetData(mysql::codePage(m_charsetIndexServer), m_serverCharData);
-	else
-		m_serverCharData += std::string("\t")  + (char*)m_req.keybuf;
-	
-	m_req.keybuf = (void_td*)m_serverCharData.c_str();
-	m_req.keylen = (keylen_td)m_serverCharData.size() + 1;
+    if (!readServerCharsetIndex())
+        return false;
+    // m_serverCharData = std::string((char*)m_req.keybuf, m_req.keylen);
+    m_serverCharData = (char*)m_req.keybuf;
+    if (CHARSET_UTF8 != m_charsetIndexServer)
+        addSecondCharsetData(mysql::codePage(m_charsetIndexServer),
+                             m_serverCharData);
+    else
+        m_serverCharData += std::string("\t") + (char*)m_req.keybuf;
+
+    m_req.keybuf = (void_td*)m_serverCharData.c_str();
+    m_req.keylen = (keylen_td)m_serverCharData.size() + 1;
     return true;
 }
 
-}//namespace client
-}//namespace tdap
-}//namespace protocol
-}//namespace db
-}//namespace bzs
-
-
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs