transactd 1.2.0 → 2.0.0

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

@@ -0,0 +1,281 @@
+#ifndef BZS_DB_PROTOCOL_TDAP_CLIENT_GROUPQUERY_H
+#define BZS_DB_PROTOCOL_TDAP_CLIENT_GROUPQUERY_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 <bzs/db/protocol/tdap/client/trdboostapi.h>
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+namespace client
+{
+
+class DLLLIB fieldNames
+{
+
+protected:
+    /** @cond INTERNAL */
+    struct fieldNamesImple* m_impl;
+    /** @endcond */
+
+public:
+    fieldNames();
+    fieldNames(const fieldNames& r);
+    fieldNames& operator=(const fieldNames& r);
+
+    virtual ~fieldNames();
+    virtual fieldNames& reset();
+    fieldNames& keyField(const _TCHAR* name, const _TCHAR* name1 = NULL,
+                         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, const _TCHAR* name9 = NULL,
+                         const _TCHAR* name10 = NULL);
+
+    int count() const;
+    const _TCHAR* operator[](int index) const;
+    const _TCHAR* getValue(int index) const;
+    void addValue(const _TCHAR* v);
+    void addValues(const _TCHAR* values,
+                   const _TCHAR* delmi); // delmi = boost::is_any_of
+    static fieldNames* create();
+    void release();
+};
+
+struct sortField
+{
+    std::_tstring name;
+    bool asc;
+};
+
+class sortFields
+{
+    std::vector<sortField> m_params;
+    /** @cond INTERNAL */
+    template <class Archive>
+    friend void serialize(Archive& ar, sortFields& q, const unsigned int);
+    /** @endcond */
+
+public:
+    inline sortFields& add(const _TCHAR* name, bool asc)
+    {
+        sortField op = { name, asc };
+        m_params.push_back(op);
+        return *this;
+    }
+    inline size_t size() const { return m_params.size(); }
+    inline const sortField& operator[](int index) const
+    {
+        return m_params[index];
+    }
+    inline void clear() { m_params.clear(); }
+};
+
+class DLLLIB recordsetQuery : protected query
+{
+    friend class groupFuncBase;
+    friend class recordsetImple;
+
+    struct recordsetQueryImple* m_imple;
+    void init(const fielddefs* fdinfo);
+    bool isMatch(int ret, unsigned char compType) const;
+    bool match(const row_ptr row) const;
+
+public:
+    recordsetQuery();
+    recordsetQuery(const recordsetQuery& r);
+    ~recordsetQuery();
+
+    recordsetQuery& operator=(const recordsetQuery& r);
+
+    template <class T>
+    inline recordsetQuery& when(const _TCHAR* name, const _TCHAR* qlogic,
+                                T value)
+    {
+        query::where(name, qlogic, value);
+        return *this;
+    }
+
+    template <class T>
+    inline recordsetQuery& and_(const _TCHAR* name, const _TCHAR* qlogic,
+                                T value)
+    {
+        query::and_(name, qlogic, value);
+        return *this;
+    }
+
+    template <class T>
+    inline recordsetQuery& or_(const _TCHAR* name, const _TCHAR* qlogic,
+                               T value)
+    {
+        query::or_(name, qlogic, value);
+        return *this;
+    }
+
+    inline recordsetQuery& reset()
+    {
+        query::reset();
+        return *this;
+    }
+
+    inline const _TCHAR* toString() const { return queryBase::toString(); }
+
+    inline query* internalQuery() { return this; }
+    static recordsetQuery* create();
+    void release();
+};
+
+class DLLLIB groupFuncBase : public recordsetQuery
+{
+protected:
+    friend class groupQueryImple;
+
+    class groupFuncBaseImple* m_imple;
+    virtual void initResultVariable(int index);
+    virtual void doCalc(const row_ptr& row, int groupIndex);
+    void init(const fielddefs* fdinfo);
+
+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 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;
+};
+
+class recordsetImple;
+
+class DLLLIB groupQuery
+{
+    friend class recordsetImple;
+    class groupQueryImple* m_imple;
+    void grouping(recordsetImple& rs);
+
+public:
+    groupQuery();
+    groupQuery(const groupQuery& r);
+    groupQuery& operator=(const groupQuery& r);
+
+    ~groupQuery();
+    groupQuery& reset();
+    groupQuery& addFunction(groupFuncBase* func);
+    groupQuery& keyField(const _TCHAR* name, const _TCHAR* name1 = NULL,
+                         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, const _TCHAR* name9 = NULL,
+                         const _TCHAR* name10 = NULL);
+    const fieldNames& getKeyFields() const;
+    const groupFuncBase* getFunction(int index) const;
+    int functionCount() const;
+    static groupQuery* create();
+    void release();
+};
+
+class DLLLIB sum : public groupFuncBase
+{
+protected:
+    void doCalc(const row_ptr& row, int index);
+
+public:
+    sum() {}
+    sum(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
+    groupFuncBase* clone();
+    static sum* create(const fieldNames& targetNames,
+                       const _TCHAR* resultName = NULL);
+};
+
+class DLLLIB count : public groupFuncBase
+{
+protected:
+    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;
+
+public:
+    avg() {}
+    avg(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
+    groupFuncBase* clone();
+    static avg* create(const fieldNames& targetNames,
+                       const _TCHAR* resultName = NULL);
+};
+
+#undef min
+class DLLLIB min : public sum
+{
+    bool m_flag;
+    void doCalc(const row_ptr& row, int index);
+
+public:
+    min() {}
+    min(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
+    groupFuncBase* clone();
+    static min* create(const fieldNames& targetNames,
+                       const _TCHAR* resultName = NULL);
+};
+
+#undef max
+class DLLLIB max : public sum
+{
+    bool m_flag;
+    void doCalc(const row_ptr& row, int index);
+
+public:
+    max() {}
+    max(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
+    groupFuncBase* clone();
+    static max* create(const fieldNames& targetNames,
+                       const _TCHAR* resultName = NULL);
+};
+
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
+
+#endif // BZS_DB_PROTOCOL_TDAP_CLIENT_GROUPQUERY_H

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

@@ -16,15 +16,10 @@
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
  ================================================================= */
-#include <bzs/env/tstring.h>
-#pragma hdrstop
-
 #include "indexDDF.h"
 #include "nsDatabase.h"
 #pragma package(smart_init)
 
-
-
 namespace bzs
 {
 namespace db
@@ -36,7 +31,10 @@ namespace tdap
 namespace client
 {
 
-indexDDF::indexDDF(nsdatabase *pbe) : nstable(pbe) {m_keybuflen = 128;}
+indexDDF::indexDDF(nsdatabase* pbe) : nstable(pbe)
+{
+    m_keybuflen = 128;
+}
 
 void indexDDF::doOpen(const _TCHAR* Dir, char_td mode, const _TCHAR* OwnerName)
 {
@@ -61,11 +59,12 @@ keylen_td indexDDF::writeKeyData()
     keylen_td len = 2;
     switch (m_keynum)
     {
-    case 0: memcpy(&keybuf[0], &fileid, len);
+    case 0:
+        memcpy(&keybuf[0], &fileid, len);
         break;
-    case 1: memcpy(&keybuf[0], &fieldid, len);
+    case 1:
+        memcpy(&keybuf[0], &fieldid, len);
         break;
-
     }
     return len;
 }
@@ -77,7 +76,6 @@ void indexDDF::writeRecordData()
     datbuf.flag = flag;
     datbuf.keyid = keyid;
     datbuf.segmentnum = segmentnum;
-
 }
 
 void indexDDF::onReadAfter()
@@ -87,12 +85,11 @@ void indexDDF::onReadAfter()
     flag = datbuf.flag;
     keyid = datbuf.keyid;
     segmentnum = datbuf.segmentnum;
-
 }
 
 void indexDDF::createTable(const _TCHAR* fullpath)
 {
-    fileSpec *fs;
+    fileSpec* fs;
     fs = (fileSpec*)malloc(512);
     memset(fs, 512, 0x00);
     fs->recLen = 10;
@@ -130,8 +127,8 @@ void indexDDF::createTable(const _TCHAR* fullpath)
     m_stat = nsdb()->stat();
 }
 
-}// namespace client
-}// namespace tdap
-}// namespace protocol
-}// namespace db
-}// namespace bzs
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs

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

@@ -20,7 +20,6 @@
  ================================================================= */
 #include "table.h"
 
-
 namespace bzs
 {
 namespace db
@@ -32,8 +31,8 @@ namespace tdap
 namespace client
 {
 
-#pragma option -a1
-pragma_pack1
+#pragma pack(push, 1)
+pragma_pack1;
 
 struct SIDXDDF
 {
@@ -44,10 +43,8 @@ struct SIDXDDF
     short flag;
 };
 
-#pragma option -a
-pragma_pop
-
-
+#pragma pack(pop)
+pragma_pop;
 
 class indexDDF : public nstable
 {
@@ -71,14 +68,14 @@ public:
 
     char keybuf[128];
 
-    explicit indexDDF(nsdatabase *pbe);
+    explicit indexDDF(nsdatabase* pbe);
     void createTable(const _TCHAR* fullpath);
     using nstable::open;
 };
 
-}// namespace client
-}// namespace tdap
-}// namespace protocol
-}// namespace db
-}// namespace bzs
-#endif//BZS_DB_PROTOCOL_TDAP_CLIENT_INDEXDDF_H
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
+#endif // BZS_DB_PROTOCOL_TDAP_CLIENT_INDEXDDF_H

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

@@ -0,0 +1,231 @@
+/*=================================================================
+   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.
+=================================================================*/
+#pragma hdrstop
+
+#include "memRecord.h"
+#include <bzs/db/protocol/tdap/client/trdboostapi.h>
+//---------------------------------------------------------------------------
+#pragma package(smart_init)
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+namespace client
+{
+
+autoMemory::autoMemory() : ptr(0), endFieldIndex(NULL), size(0), owner(false)
+{
+}
+
+autoMemory::autoMemory(unsigned char* p, size_t s, short* endIndex, bool own)
+    : ptr(p), endFieldIndex(NULL), size((unsigned int)s), owner(own)
+
+{
+    if (owner)
+    {
+        ptr = new unsigned char[s];
+        if (p)
+            memcpy(ptr, p, size);
+        else
+            memset(ptr, 0, size);
+        endFieldIndex = new short;
+        if (endIndex != NULL)
+            *endFieldIndex = *endIndex;
+    }
+    else
+        endFieldIndex = endIndex;
+}
+
+autoMemory::~autoMemory()
+{
+    if (owner)
+    {
+        delete[] ptr;
+        delete endFieldIndex;
+    }
+}
+
+autoMemory::autoMemory(const autoMemory& p)
+    : ptr(p.ptr), endFieldIndex(p.endFieldIndex), size(p.size), owner(p.owner)
+{
+    const_cast<autoMemory&>(p).owner = false;
+    // const_cast<autoMemory&>(p).ptr = NULL;
+}
+
+autoMemory& autoMemory::operator=(const autoMemory& p)
+{
+    ptr = p.ptr;
+    size = p.size;
+    endFieldIndex = p.endFieldIndex;
+    owner = p.owner;
+    const_cast<autoMemory&>(p).owner = false;
+    // const_cast<autoMemory&>(p).ptr = NULL;
+    return *this;
+}
+
+//---------------------------------------------------------------------------
+//    class memoryRecord
+//---------------------------------------------------------------------------
+inline memoryRecord::memoryRecord(fielddefs& fdinfo) : fieldsBase(fdinfo)
+{
+
+    m_memblock.reserve(ROW_MEM_BLOCK_RESERVE);
+}
+
+memoryRecord::memoryRecord(const memoryRecord& r)
+    : fieldsBase(r.m_fns), m_memblock(r.m_memblock)
+{
+}
+
+void memoryRecord::clear()
+{
+    for (int i = 0; i < (int)m_memblock.size(); ++i)
+        memset(m_memblock[i].ptr, 0, m_memblock[i].size);
+
+    m_fns.resetUpdateIndicator();
+}
+
+void memoryRecord::setRecordData(unsigned char* ptr, size_t size,
+                                 short* endFieldIndex, bool owner)
+{
+    if ((size == 0) && owner)
+    {
+        size = m_fns.totalFieldLen();
+        *endFieldIndex = (short)m_fns.size();
+    }
+    autoMemory am(ptr, size, endFieldIndex, owner);
+    m_memblock.push_back(am);
+}
+
+void memoryRecord::copyToBuffer(table* tb, bool updateOnly) const
+{
+    if (!updateOnly)
+        memcpy(tb->fieldPtr(0), ptr(0), m_fns.totalFieldLen());
+    else
+    {
+        for (int i = 0; i < (int)m_fns.size(); ++i)
+        {
+            const fielddef& fd = m_fns[i];
+            // ptr() return memory block first address
+            if (fd.enableFlags.bitE)
+                memcpy(tb->fieldPtr(i), ptr(i) + fd.pos, fd.len);
+        }
+    }
+}
+
+memoryRecord* memoryRecord::create(fielddefs& fdinfo)
+{
+    return new memoryRecord(fdinfo);
+}
+
+void memoryRecord::release(fieldsBase* p)
+{
+    delete p;
+}
+
+//---------------------------------------------------------------------------
+//    class writableRecord
+//---------------------------------------------------------------------------
+writableRecord::writableRecord(table* tb, const aliasMap_type* alias)
+    : memoryRecord(*fddefs()), m_tb(tb)
+{
+    m_tb->setFilter(NULL, 0, 0);
+    m_tb->clearBuffer();
+    m_fddefs->clear();
+    m_fddefs->setAliases(alias);
+    m_fddefs->copyFrom(m_tb);
+    setRecordData(0, 0, &m_endIndex, true);
+}
+
+fielddefs* writableRecord::fddefs()
+{
+    m_fddefs = fielddefs::create();
+    return m_fddefs;
+}
+
+writableRecord::~writableRecord()
+{
+    m_fddefs->release();
+}
+
+bool writableRecord::read(bool KeysetAlrady)
+{
+    if (!KeysetAlrady)
+        copyToBuffer(m_tb);
+    m_tb->seek();
+    if (m_tb->stat())
+        return false;
+    copyFromBuffer(m_tb);
+    return true;
+}
+
+void writableRecord::insert()
+{
+    copyToBuffer(m_tb);
+    insertRecord(m_tb);
+    copyFromBuffer(m_tb);
+}
+
+void writableRecord::del(bool KeysetAlrady)
+{
+    if (!KeysetAlrady)
+        copyToBuffer(m_tb);
+    m_tb->seek();
+    if (m_tb->stat())
+        nstable::throwError(_T("activeTable delete "), m_tb->stat());
+    deleteRecord(m_tb);
+}
+
+void writableRecord::update()
+{
+    copyToBuffer(m_tb);
+    m_tb->seek();
+    if (m_tb->stat())
+        nstable::throwError(_T("activeTable update "), m_tb->stat());
+    copyToBuffer(m_tb, true /*only changed*/);
+    updateRecord(m_tb);
+}
+
+void writableRecord::save()
+{
+    copyToBuffer(m_tb);
+    m_tb->seek();
+    if (m_tb->stat() == STATUS_NOT_FOUND_TI)
+        insertRecord(m_tb);
+    else
+    {
+        copyToBuffer(m_tb);
+        updateRecord(m_tb);
+    }
+}
+
+writableRecord* writableRecord::create(table* tb, const aliasMap_type* alias)
+{
+    return new writableRecord(tb, alias);
+}
+
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs