transactd 1.2.0 → 2.0.0

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

@@ -0,0 +1,145 @@
+#ifndef BZS_DB_PROTOCOL_TDAP_CLIENT_MEMRECORD_H
+#define BZS_DB_PROTOCOL_TDAP_CLIENT_MEMRECORD_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 "fields.h"
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+namespace client
+{
+
+/** @cond INTERNAL */
+
+class DLLLIB autoMemory
+{
+
+public:
+    autoMemory();
+    explicit autoMemory(unsigned char* p, size_t s, short* endIndex, bool own);
+    autoMemory(const autoMemory& p);
+    ~autoMemory();
+    autoMemory& operator=(const bzs::db::protocol::tdap::client::autoMemory& p);
+    unsigned char* ptr;
+    short* endFieldIndex;
+    unsigned int size;
+    bool owner;
+};
+
+/** @endcond */
+
+#pragma warning(disable : 4251)
+#pragma warning(disable : 4275)
+#define ROW_MEM_BLOCK_RESERVE 4
+
+class DLLLIB memoryRecord : public fieldsBase
+{
+    friend class multiRecordAlocatorImple;
+    friend class recordsetImple;
+
+    std::vector<autoMemory> m_memblock;
+
+protected:
+    /** @cond INTERNAL */
+    inline memoryRecord(fielddefs& fdinfo);
+    memoryRecord(const memoryRecord& r);
+    void copyToBuffer(table* tb, bool updateOnly = false) const;
+
+    /* return memory block first address which not field ptr address */
+    inline unsigned char* ptr(int index) const
+    {
+        for (int i = 0; i < memBlockSize(); ++i)
+            if (*(m_memblock[i].endFieldIndex) > index)
+                return m_memblock[i].ptr;
+        assert(0);
+        return NULL;
+    }
+
+    inline const autoMemory& memBlockByField(int index) const
+    {
+        for (int i = 0; i < memBlockSize(); ++i)
+            if (*(m_memblock[i].endFieldIndex) > index)
+                return m_memblock[i];
+        assert(0);
+        return *((autoMemory*)0);
+    }
+
+    inline const autoMemory& memBlock(int index) const
+    {
+        return m_memblock[index];
+    }
+
+    inline int memBlockSize() const { return (int)m_memblock.size(); }
+
+    inline void copyFromBuffer(const table* tb)
+    {
+        memcpy(ptr(0), tb->fieldPtr(0), m_fns.totalFieldLen());
+    }
+    void removeLastMemBlock() { m_memblock.pop_back(); }
+
+    /** @endcond */
+public:
+    void clear(); // orverride
+    void setRecordData(unsigned char* ptr, size_t size, short* endFieldIndex,
+                       bool owner = false);
+
+    static memoryRecord* create(fielddefs& fdinfo);
+    static void release(fieldsBase* p);
+};
+
+#pragma warning(default : 4275)
+#pragma warning(default : 4251)
+
+/* non copyable*/
+class DLLLIB writableRecord : public memoryRecord
+{
+    fielddefs* m_fddefs;
+    table* m_tb;
+    short m_endIndex;
+
+    writableRecord(table* tb, const aliasMap_type* alias);
+    writableRecord(const writableRecord&);
+    writableRecord& operator=(const writableRecord&);
+
+    fielddefs* fddefs();
+
+public:
+    ~writableRecord();
+    bool read(bool KeysetAlrady = false);
+    void insert();
+    void del(bool KeysetAlrady = false);
+    void update();
+    void save();
+
+    static writableRecord* create(table* tb, const aliasMap_type* alias);
+};
+
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
+
+#endif // BZS_DB_PROTOCOL_TDAP_CLIENT_MEMRECORD_H

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

@@ -0,0 +1,448 @@
+/*=================================================================
+   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 "memRecordset.h"
+
+#ifdef _DEBUG
+#include <iostream>
+#endif
+#pragma package(smart_init)
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+namespace client
+{
+
+// ---------------------------------------------------------------------------
+// class multiRecordAlocatorImple
+// ---------------------------------------------------------------------------
+class multiRecordAlocatorImple : public multiRecordAlocator
+{
+    class recordset* m_rs;
+    int m_rowOffset;
+    int m_addType;
+    int m_curFirstFiled;
+    const std::vector<std::vector<int> >* m_joinRowMap;
+
+public:
+    inline multiRecordAlocatorImple(recordset* rs)
+        : m_rs(rs), m_rowOffset(0), m_addType(0), m_curFirstFiled(0),
+          m_joinRowMap(NULL)
+    {
+    }
+
+    inline void init(size_t recordCount, size_t recordLen, int addType,
+                     const table* tb)
+    {
+        m_rs->registerMemoryBlock(NULL, recordCount * recordLen, recordLen,
+                                  addType | m_addType, tb);
+    }
+
+    inline unsigned char* ptr(size_t row, int stat)
+    {
+        int col = (stat == mra_current_block) ? m_curFirstFiled : 0;
+        size_t rowNum = m_joinRowMap ? (*m_joinRowMap)[row + m_rowOffset][0]
+                                     : row + m_rowOffset;
+        return (*m_rs)[rowNum].ptr(col);
+    }
+
+    inline void setRowOffset(int v) { m_rowOffset = v; }
+
+    inline void setJoinType(int v) { m_addType = v; }
+
+    inline void setInvalidRecord(size_t row, bool v)
+    {
+        (*m_rs)[row + m_rowOffset].setInvalidRecord(v);
+    }
+
+    inline void setCurFirstFiled(int v) { m_curFirstFiled = v; }
+
+    inline void setJoinRowMap(const std::vector<std::vector<int> >* v)
+    {
+        m_joinRowMap = v; /*m_joinMapSize = size;*/
+    }
+
+    inline const std::vector<std::vector<int> >* joinRowMap() const
+    {
+        return m_joinRowMap;
+    }
+};
+
+// ---------------------------------------------------------------------------
+// class recordsetSorter
+// ---------------------------------------------------------------------------
+class recordsetSorter
+{
+    const std::vector<int>& m_fieldNums;
+
+public:
+    recordsetSorter(const std::vector<int>& fieldNums) : m_fieldNums(fieldNums)
+    {
+    }
+    bool operator()(const row_ptr& l, const row_ptr r) const
+    {
+        std::vector<int>::const_iterator it = m_fieldNums.begin();
+        while (it != m_fieldNums.end())
+        {
+            int ret = (*l)[*it].comp((*r)[*it], 0);
+            if (ret)
+                return (ret < 0);
+            ++it;
+        }
+        return false;
+    }
+};
+
+// ---------------------------------------------------------------------------
+// class recordset
+// ---------------------------------------------------------------------------
+recordset::recordset()
+    : m_fds(fielddefs::create(), &fielddefs::destroy), m_joinRows(0),
+      m_uniqueReadMaxField(0)
+{
+    m_mra.reset(new multiRecordAlocatorImple(this));
+}
+
+recordset::~recordset()
+{
+}
+
+void recordset::registerMemoryBlock(unsigned char* ptr, size_t size,
+                                    size_t recordLen, int addtype,
+                                    const table* tb)
+{
+    autoMemory* am = new autoMemory(ptr, size, 0, true);
+    m_memblock.push_back(boost::shared_ptr<autoMemory>(am));
+    unsigned char* p = am->ptr;
+    // copy fileds
+    if (addtype & mra_nextrows)
+    {
+        if (addtype == mra_nextrows)
+            m_mra->setRowOffset((int)m_recordset.size()); // no join
+        else
+            m_mra->setRowOffset((int)m_joinRows); // Join
+    }
+    else
+    {
+        // assert(tb);
+        m_joinRows = 0;
+        m_mra->setRowOffset(0);
+        m_mra->setCurFirstFiled((int)m_fds->size());
+        if (tb)
+            m_fds->copyFrom(tb);
+        if (tb && (addtype == mra_nojoin))
+        {
+            const keydef& kd = tb->tableDef()->keyDefs[tb->keyNum()];
+            m_uniqueReadMaxField =
+                (kd.segments[0].flags.bit0 == false) ? (short)m_fds->size() : 0;
+        }
+    }
+
+    *(am->endFieldIndex) = (short)m_fds->size();
+    size_t rows = size / recordLen;
+
+    // set record pointer to each record
+    if ((addtype & mra_innerjoin) || (addtype & mra_outerjoin))
+    {
+        // Join optimazing
+        const std::vector<std::vector<int> >* jmap = m_mra->joinRowMap();
+
+        if (jmap)
+        {
+            // At Join that if some base records reference to a joined record
+            //		that the joined record pointer is shared by some base
+            // records.
+            for (int i = 0; i < (int)rows; ++i)
+            {
+                const std::vector<int>& map = (*jmap)[i + m_joinRows];
+                for (int j = 0; j < (int)map.size(); ++j)
+                    m_recordset[map[j]]->setRecordData(
+                        p + recordLen * i, 0, am->endFieldIndex, false);
+            }
+        }
+        else
+        {
+            for (int i = 0; i < (int)rows; ++i)
+                m_recordset[i + m_joinRows]->setRecordData(
+                    p + recordLen * i, 0, am->endFieldIndex, false);
+        }
+        m_joinRows += rows;
+    }
+    else
+    { // create new record
+        size_t reserveSize = m_recordset.size() + rows;
+        m_recordset.reserve(reserveSize);
+        for (int i = 0; i < (int)rows; ++i)
+        {
+            row_ptr rec(memoryRecord::create(*m_fds), &memoryRecord::release);
+            rec->setRecordData(p + recordLen * i, 0, am->endFieldIndex, false);
+            m_recordset.push_back(rec);
+        }
+    }
+}
+
+void recordset::makeSortFields(const _TCHAR* name, std::vector<int>& fieldNums)
+{
+    int index = m_fds->indexByName(name);
+    if (index == -1)
+        THROW_BZS_ERROR_WITH_MSG(_T("oorderBy:Invalid field name"));
+    fieldNums.push_back(index);
+}
+
+int recordset::getMemBlockIndex(unsigned char* ptr) const
+{
+    for (int i = 0; i < (int)m_memblock.size(); ++i)
+    {
+        const boost::shared_ptr<autoMemory>& am = m_memblock[i];
+        if ((ptr >= am->ptr) && (ptr < am->ptr + am->size))
+            return i;
+    }
+    assert(0);
+    return -1;
+}
+
+/* This clone is deep copy.
+   But text and blob field data memory are shared.
+*/
+recordset* recordset::clone() const
+{
+    recordset* p = new recordset();
+    p->m_joinRows = m_joinRows;
+    p->m_uniqueReadMaxField = m_uniqueReadMaxField;
+    p->m_unionFds = m_unionFds;
+    p->m_fds.reset(m_fds->clone(), &fielddefs::destroy);
+
+    std::vector<__int64> offsets;
+    for (int i = 0; i < (int)m_memblock.size(); ++i)
+    {
+        autoMemory* am =
+            new autoMemory(m_memblock[i]->ptr, m_memblock[i]->size, 0, true);
+        *am->endFieldIndex = *m_memblock[i]->endFieldIndex;
+        p->m_memblock.push_back(boost::shared_ptr<autoMemory>(am));
+        offsets.push_back((__int64)(am->ptr - m_memblock[i]->ptr));
+    }
+
+    for (int i = 0; i < (int)m_recordset.size(); ++i)
+    {
+        memoryRecord* row = dynamic_cast<memoryRecord*>(m_recordset[i].get());
+        memoryRecord* mr = memoryRecord::create(*p->m_fds);
+        row_ptr rec(mr, &memoryRecord::release);
+        p->m_recordset.push_back(rec);
+
+        for (int j = 0; j < (int)row->memBlockSize(); ++j)
+        {
+            const autoMemory& mb = row->memBlock(j);
+            int index = getMemBlockIndex(mb.ptr);
+            unsigned char* ptr = mb.ptr + offsets[index];
+            const boost::shared_ptr<autoMemory>& am = p->m_memblock[index];
+            mr->setRecordData(ptr, mb.size, am->endFieldIndex, mb.owner);
+        }
+    }
+    return p;
+}
+
+void recordset::clearRecords()
+{
+    m_recordset.clear();
+    m_uniqueReadMaxField = 0;
+}
+
+void recordset::clear()
+{
+    clearRecords();
+    m_fds->clear();
+    m_unionFds.clear();
+    m_memblock.clear();
+}
+
+recordset& recordset::top(recordset& c, int n)
+{
+    c = *this;
+    c.clearRecords();
+    for (int i = 0; i < n; ++i)
+        c.push_back(m_recordset[i]);
+    return c;
+}
+
+recordset::iterator recordset::begin()
+{
+    return m_recordset.begin();
+}
+
+recordset::iterator recordset::end()
+{
+    return m_recordset.end();
+}
+
+recordset::iterator recordset::erase(size_t index)
+{
+    return m_recordset.erase(m_recordset.begin() + index);
+}
+
+recordset::iterator recordset::erase(const iterator& it)
+{
+    return m_recordset.erase(it);
+}
+
+void recordset::push_back(row_ptr r)
+{
+    m_recordset.push_back(r);
+};
+
+void recordset::readBefore(const table_ptr tb, const aliasMap_type* alias)
+{
+    tb->setMra(m_mra.get());
+    m_fds->setAliases(alias);
+}
+
+recordset::key_type recordset::resolvKeyValue(const std::_tstring& name,
+                                              bool noexception)
+{
+    int index = m_fds->indexByName(name);
+    if (index != -1)
+        return index;
+    if (!noexception)
+        THROW_BZS_ERROR_WITH_MSG(_T("groupQuery:Invalid key name"));
+
+    return (key_type)m_fds->size();
+}
+
+void recordset::removeField(int index)
+{
+    m_fds->remove(index);
+    for (int i = 0; i < (int)m_unionFds.size(); ++i)
+        m_unionFds[i]->remove(index);
+
+    for (int i = 0; i < (int)m_memblock.size(); ++i)
+    {
+        if (*(m_memblock[i]->endFieldIndex) > index)
+        {
+            short v = *(m_memblock[i]->endFieldIndex) - 1;
+            *(m_memblock[i]->endFieldIndex) = v;
+        }
+    }
+}
+
+recordset& recordset::matchBy(recordsetQuery& rq)
+{
+    rq.init(fieldDefs());
+    for (int i = (int)m_recordset.size() - 1; i >= 0; --i)
+        if (!rq.match(m_recordset[i]))
+            erase(i);
+    return *this;
+}
+
+recordset& recordset::groupBy(groupQuery& gq)
+{
+    gq.grouping(*this);
+    return *this;
+}
+
+recordset& recordset::orderBy(const _TCHAR* name1, const _TCHAR* name2,
+                              const _TCHAR* name3, const _TCHAR* name4,
+                              const _TCHAR* name5, const _TCHAR* name6,
+                              const _TCHAR* name7, const _TCHAR* name8)
+{
+    std::vector<int> fieldNums;
+    makeSortFields(name1, fieldNums);
+    if (name2)
+        makeSortFields(name2, fieldNums);
+    if (name3)
+        makeSortFields(name3, fieldNums);
+    if (name4)
+        makeSortFields(name4, fieldNums);
+    if (name5)
+        makeSortFields(name5, fieldNums);
+    if (name6)
+        makeSortFields(name6, fieldNums);
+    if (name7)
+        makeSortFields(name7, fieldNums);
+    if (name8)
+        makeSortFields(name8, fieldNums);
+    std::sort(begin(), end(), recordsetSorter(fieldNums));
+    return *this;
+}
+
+inline recordset& recordset::reverse()
+{
+    std::reverse(begin(), end());
+    return *this;
+}
+
+void recordset::appendCol(const _TCHAR* name, int type, short len)
+{
+    assert(m_fds->size());
+    fielddef fd((*m_fds)[0]);
+    fd.len = len;
+    fd.pos = 0;
+    fd.type = type;
+    fd.setName(name);
+    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);
+}
+
+recordset& recordset::operator+=(const recordset& r)
+{
+    if (!m_fds->canUnion(*r.m_fds))
+        THROW_BZS_ERROR_WITH_MSG(_T("Recordsets are different format"));
+
+    m_recordset.reserve(m_recordset.size() + r.size());
+    m_unionFds.push_back(r.m_fds);
+    for (size_t i = 0; i < r.size(); ++i)
+        m_recordset.push_back(r.m_recordset[i]);
+    for (size_t i = 0; i < r.m_memblock.size(); ++i)
+        m_memblock.push_back(r.m_memblock[i]);
+    return *this;
+}
+
+#ifdef _DEBUG
+void recordset::dump()
+{
+    const fielddefs& fields = *fieldDefs();
+    for (int j = 0; j < (int)fields.size(); ++j)
+        std::tcout << fields[j].name() << _T("\t");
+    std::tcout << _T("\n");
+
+    for (int i = 0; i < (int)size(); ++i)
+    {
+        row& m = (operator[](i));
+        for (int j = 0; j < (int)m.size(); ++j)
+        {
+            std::tcout << m[(short)j].c_str() << _T("\t");
+            if (j == (int)m.size() - 1)
+                std::tcout << _T("\n");
+        }
+    }
+}
+#endif
+
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs