transactd 2.0.1 → 2.1.0

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

@@ -157,11 +157,19 @@ struct recordsetQueryImple
     std::vector<char> combine;
     short endIndex;
     fielddefs compFields;
-    recordsetQueryImple() {}
+    recordsetQueryImple() : row(NULL) {}
     recordsetQueryImple(const recordsetQueryImple& r)
         : row(r.row), compType(r.compType), indexes(r.indexes),
           combine(r.combine), endIndex(r.endIndex), compFields(r.compFields)
     {
+        if (row)
+            row->addref();
+    }
+
+    ~recordsetQueryImple()
+    {
+        if (row)
+            row->release();
     }
 };
 
@@ -214,9 +222,9 @@ void recordsetQuery::init(const fielddefs* fdinfo)
         m_imple->indexes.push_back(index);
         m_imple->compFields.push_back(&((*fdinfo)[index]), true /*rePosition*/);
     }
-    memoryRecord* mr = memoryRecord::create(m_imple->compFields);
-    mr->setRecordData(0, 0, &m_imple->endIndex, true);
-    m_imple->row.reset(mr);
+    m_imple->row = memoryRecord::create(m_imple->compFields);
+    m_imple->row->addref();
+    m_imple->row->setRecordData(autoMemory::create(), 0, 0, &m_imple->endIndex, true);
 
     int index = 0;
     for (int i = 0; i < (int)tokns.size(); i += 4)

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

@@ -91,7 +91,7 @@ void indexDDF::createTable(const _TCHAR* fullpath)
 {
     fileSpec* fs;
     fs = (fileSpec*)malloc(512);
-    memset(fs, 512, 0x00);
+    memset(fs, 0x00, 512);
     fs->recLen = 10;
     fs->pageSize = 4096;
     fs->indexCount = 3;

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

@@ -20,6 +20,8 @@
 
 #include "memRecord.h"
 #include <bzs/db/protocol/tdap/client/trdboostapi.h>
+#include <new>
+
 //---------------------------------------------------------------------------
 #pragma package(smart_init)
 namespace bzs
@@ -33,14 +35,23 @@ namespace tdap
 namespace client
 {
 
-autoMemory::autoMemory() : ptr(0), endFieldIndex(NULL), size(0), owner(false)
+autoMemory::autoMemory() : refarymem(), 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)
-
+void autoMemory::setParams(unsigned char* p, size_t s, short* endIndex, bool own)
 {
+    if (owner)
+    {
+        delete[] ptr;
+        delete endFieldIndex;
+    }
+
+    ptr = p;
+    size = (unsigned int)s;
+    owner = own; 
+    endFieldIndex = endIndex;
     if (owner)
     {
         ptr = new unsigned char[s];
@@ -52,8 +63,7 @@ autoMemory::autoMemory(unsigned char* p, size_t s, short* endIndex, bool own)
         if (endIndex != NULL)
             *endFieldIndex = *endIndex;
     }
-    else
-        endFieldIndex = endIndex;
+        
 }
 
 autoMemory::~autoMemory()
@@ -65,67 +75,146 @@ autoMemory::~autoMemory()
     }
 }
 
-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)
 {
+    if (owner)
+    {
+        delete[] ptr;
+        delete endFieldIndex;
+    }
     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;
 }
 
+void autoMemory::releaseMemory()
+{
+    if (allocType() == MEM_ALLOC_TYPE_ONE)
+        delete this;
+    else
+        delete [] this;
+}
+
+autoMemory* autoMemory::create(int n)
+{
+    assert(n);
+    autoMemory* p =  new autoMemory[n];
+    p->setAllocTypeThis(MEM_ALLOC_TYPE_ARRAY);
+    for (int i = 1; i < n ; ++i)
+    {
+        autoMemory* pp = p + i;
+        pp->setAllocParent(p);
+    }
+    return p;
+}
+
+autoMemory* autoMemory::create()
+{
+    autoMemory* p = new autoMemory();
+    p->setAllocTypeThis(MEM_ALLOC_TYPE_ONE);
+    return p;
+}
+
 //---------------------------------------------------------------------------
 //    class memoryRecord
 //---------------------------------------------------------------------------
-inline memoryRecord::memoryRecord(fielddefs& fdinfo) : fieldsBase(fdinfo)
+inline memoryRecord::memoryRecord() : fieldsBase(NULL)
 {
+#ifdef JOIN_UNLIMIT
+    m_memblock.reserve(ROW_MEM_BLOCK_RESERVE);
+#else
+    m_memblockSize = 0;
+#endif
+}
 
+inline memoryRecord::memoryRecord(fielddefs& fdinfo) : fieldsBase(&fdinfo)
+{
+#ifdef JOIN_UNLIMIT
     m_memblock.reserve(ROW_MEM_BLOCK_RESERVE);
+#else
+    m_memblockSize = 0;
+#endif
 }
 
 memoryRecord::memoryRecord(const memoryRecord& r)
-    : fieldsBase(r.m_fns), m_memblock(r.m_memblock)
+    : fieldsBase(r.m_fns)
+{
+#ifdef JOIN_UNLIMIT
+    m_memblock = r.m_memblock;
+#else
+    m_memblockSize = r.m_memblockSize;
+    for (int i = 0; i < m_memblockSize; ++i)
+        m_memblock[i] = r.m_memblock[i];
+#endif
+    for (int i = 0; i < memBlockSize(); ++i)
+        m_memblock[i]->addref();
+
+}
+
+memoryRecord::~memoryRecord()
 {
+    for (int i = 0; i < memBlockSize(); ++i)
+        m_memblock[i]->release();
 }
 
-void memoryRecord::clear()
+memoryRecord& memoryRecord::operator=(const memoryRecord& r)
 {
-    for (int i = 0; i < (int)m_memblock.size(); ++i)
-        memset(m_memblock[i].ptr, 0, m_memblock[i].size);
+     if (this != &r)
+     {
+         m_fns = r.m_fns;
+#ifdef JOIN_UNLIMIT
+         m_memblock = r.m_memblock;
+#endif
+         for (int i = 0; i < memBlockSize(); ++i)
+         {
+#ifndef JOIN_UNLIMIT
+             m_memblock[i] = r.m_memblock[i];
+#endif
+             m_memblock[i]->addref();
+         }
 
-    m_fns.resetUpdateIndicator();
+     }
+     return *this;
 }
 
-void memoryRecord::setRecordData(unsigned char* ptr, size_t size,
-                                 short* endFieldIndex, bool owner)
+void memoryRecord::clear()
+{
+    for (int i = 0; i < memBlockSize(); ++i)
+        memset(m_memblock[i]->ptr, 0, m_memblock[i]->size);
+    m_fns->resetUpdateIndicator();
+}
+
+void memoryRecord::setRecordData(autoMemory* am, unsigned char* ptr,
+                                 size_t size, short* endFieldIndex, bool owner)
 {
     if ((size == 0) && owner)
     {
-        size = m_fns.totalFieldLen();
-        *endFieldIndex = (short)m_fns.size();
+        size = m_fns->totalFieldLen();
+        *endFieldIndex = (short)m_fns->size();
     }
-    autoMemory am(ptr, size, endFieldIndex, owner);
+    am->setParams(ptr, size, endFieldIndex, owner);
+    am->addref();
+#ifdef JOIN_UNLIMIT
     m_memblock.push_back(am);
+#else
+    m_memblock[m_memblockSize] = am;
+    ++m_memblockSize;
+#endif
 }
 
 void memoryRecord::copyToBuffer(table* tb, bool updateOnly) const
 {
     if (!updateOnly)
-        memcpy(tb->fieldPtr(0), ptr(0), m_fns.totalFieldLen());
+        memcpy(tb->fieldPtr(0), ptr(0), m_fns->totalFieldLen());
     else
     {
-        for (int i = 0; i < (int)m_fns.size(); ++i)
+        for (int i = 0; i < (int)m_fns->size(); ++i)
         {
-            const fielddef& fd = m_fns[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);
@@ -135,12 +224,64 @@ void memoryRecord::copyToBuffer(table* tb, bool updateOnly) const
 
 memoryRecord* memoryRecord::create(fielddefs& fdinfo)
 {
-    return new memoryRecord(fdinfo);
+    memoryRecord* p = new memoryRecord(fdinfo);
+    p->setAllocTypeThis(MEM_ALLOC_TYPE_ONE);
+#ifdef DEBUG_TRACE_FIELDBASE_REFCOUNT
+    _TCHAR tmp[50];
+    wsprintf(tmp, _T("memoryRecord create one %p\n"), p);
+    OutputDebugString(tmp);
+#endif
+    return p;
 }
 
-void memoryRecord::release(fieldsBase* p)
+memoryRecord* memoryRecord::create(fielddefs& fdinfo, int n)
 {
-    delete p;
+    assert(n);
+    memoryRecord* p =  new memoryRecord[n];
+    p->setFielddefs(&fdinfo);
+    p->setAllocTypeThis(MEM_ALLOC_TYPE_ARRAY);
+
+    for (int i = 1; i < n ; ++i)
+    {
+        memoryRecord* pp = p + i;
+        pp->setFielddefs(&fdinfo);
+        pp->setAllocParent(p);
+    }
+#ifdef DEBUG_TRACE_FIELDBASE_REFCOUNT
+    _TCHAR tmp[50];
+    wsprintf(tmp, _T("memoryRecord create n %p\n"), p);
+    OutputDebugString(tmp);
+#endif
+    return p;
+}
+
+//copy constractor
+memoryRecord* memoryRecord::create(const memoryRecord& m, int n)
+{
+    assert(n);
+    memoryRecord* p =  new memoryRecord[n];
+    *p = m;
+    p->setAllocTypeThis(MEM_ALLOC_TYPE_ARRAY);
+    for (int i = 1; i < n ; ++i)
+    {
+        memoryRecord* pp = p + i;
+        *pp = m;
+        pp->setAllocParent(p);
+    }
+#ifdef DEBUG_TRACE_FIELDBASE_REFCOUNT
+    _TCHAR tmp[50];
+    wsprintf(tmp, _T("memoryRecord create copy n %p\n"), p);
+    OutputDebugString(tmp);
+#endif
+    return p;
+}
+
+void memoryRecord::releaseMemory()
+{
+    if (allocType() == MEM_ALLOC_TYPE_ONE)
+        delete this;
+    else
+        delete [] this;
 }
 
 //---------------------------------------------------------------------------
@@ -154,7 +295,7 @@ writableRecord::writableRecord(table* tb, const aliasMap_type* alias)
     m_fddefs->clear();
     m_fddefs->setAliases(alias);
     m_fddefs->copyFrom(m_tb);
-    setRecordData(0, 0, &m_endIndex, true);
+    setRecordData(autoMemory::create(), 0, 0, &m_endIndex, true);
 }
 
 fielddefs* writableRecord::fddefs()
@@ -221,9 +362,26 @@ void writableRecord::save()
 
 writableRecord* writableRecord::create(table* tb, const aliasMap_type* alias)
 {
-    return new writableRecord(tb, alias);
+    writableRecord* p = new writableRecord(tb, alias);
+    p->setAllocTypeThis(MEM_ALLOC_TYPE_ONE);
+    
+#ifdef DEBUG_TRACE_FIELDBASE_REFCOUNT
+    _TCHAR tmp[50];
+    wsprintf(tmp, _T("writableRecord create one %p\n"), p);
+    OutputDebugString(tmp);
+#endif
+    return p;
 }
 
+void writableRecord::releaseMemory()
+{
+    if (allocType() == MEM_ALLOC_TYPE_ONE)
+        delete this;
+    else
+        delete [] this;
+}
+
+
 } // namespace client
 } // namespace tdap
 } // namespace protocol

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

@@ -33,19 +33,23 @@ namespace client
 
 /** @cond INTERNAL */
 
-class DLLLIB autoMemory
+class autoMemory : public refarymem
 {
+    void releaseMemory();
 
-public:
     autoMemory();
-    explicit autoMemory(unsigned char* p, size_t s, short* endIndex, bool own);
     autoMemory(const autoMemory& p);
     ~autoMemory();
+public:
+    void setParams(unsigned char* p, size_t s, short* endIndex, bool own);
+
     autoMemory& operator=(const bzs::db::protocol::tdap::client::autoMemory& p);
     unsigned char* ptr;
     short* endFieldIndex;
-    unsigned int size;
-    bool owner;
+    unsigned int size ;
+    bool owner ;
+    static autoMemory* create(int n);
+    static autoMemory* create();
 };
 
 /** @endcond */
@@ -54,25 +58,45 @@ public:
 #pragma warning(disable : 4275)
 #define ROW_MEM_BLOCK_RESERVE 4
 
+#ifndef JOINLIMIT_PER_RECORD
+#define JOINLIMIT_PER_RECORD 0
+#endif
+#if (JOINLIMIT_PER_RECORD < 1)
+#define JOIN_UNLIMIT
+#endif
+
 class DLLLIB memoryRecord : public fieldsBase
 {
     friend class multiRecordAlocatorImple;
     friend class recordsetImple;
+    friend class recordsetQuery;
+
+#ifdef JOIN_UNLIMIT
+    std::vector<autoMemory*> m_memblock;
+#else
+    autoMemory* m_memblock[JOINLIMIT_PER_RECORD];
+    int m_memblockSize;
+#endif
 
-    std::vector<autoMemory> m_memblock;
+    static memoryRecord* create(fielddefs& fdinfo, int n);
+    static memoryRecord* create(const memoryRecord& m, int n);
 
 protected:
     /** @cond INTERNAL */
+
+    inline memoryRecord();
     inline memoryRecord(fielddefs& fdinfo);
     memoryRecord(const memoryRecord& r);
+    ~memoryRecord();
+    memoryRecord& operator=(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;
+            if (*(m_memblock[i]->endFieldIndex) > index)
+                return m_memblock[i]->ptr;
         assert(0);
         return NULL;
     }
@@ -80,33 +104,47 @@ protected:
     inline const autoMemory& memBlockByField(int index) const
     {
         for (int i = 0; i < memBlockSize(); ++i)
-            if (*(m_memblock[i].endFieldIndex) > index)
-                return m_memblock[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];
+        return *m_memblock[index];
     }
-
+#ifdef JOIN_UNLIMIT
     inline int memBlockSize() const { return (int)m_memblock.size(); }
-
+#else
+    inline int memBlockSize() const { return m_memblockSize; }
+#endif
     inline void copyFromBuffer(const table* tb)
     {
-        memcpy(ptr(0), tb->fieldPtr(0), m_fns.totalFieldLen());
+        memcpy(ptr(0), tb->fieldPtr(0), m_fns->totalFieldLen());
+    }
+
+    void removeLastMemBlock() 
+    { 
+        if (memBlockSize())
+        {
+            m_memblock[memBlockSize()-1]->release();
+#ifdef JOIN_UNLIMIT
+            m_memblock.pop_back(); 
+#else
+            --m_memblockSize; 
+#endif
+        }
     }
-    void removeLastMemBlock() { m_memblock.pop_back(); }
+
+    void setRecordData(autoMemory* am, unsigned char* ptr, size_t size,
+                       short* endFieldIndex, bool owner = false);
+    void releaseMemory();
 
     /** @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);
+    static memoryRecord* create(fielddefs& fdinfo); // For SWIG
 };
 
 #pragma warning(default : 4275)
@@ -115,25 +153,29 @@ public:
 /* non copyable*/
 class DLLLIB writableRecord : public memoryRecord
 {
+    friend class activeTableImple;
+
     fielddefs* m_fddefs;
     table* m_tb;
     short m_endIndex;
 
+    static writableRecord* create(table* tb, const aliasMap_type* alias);
     writableRecord(table* tb, const aliasMap_type* alias);
     writableRecord(const writableRecord&);
     writableRecord& operator=(const writableRecord&);
 
     fielddefs* fddefs();
+    void releaseMemory();
+    ~writableRecord();
 
 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