transactd 2.4.5 → 3.0.0

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

@@ -38,7 +38,7 @@ protected:
     /** @cond INTERNAL */
     struct fieldNamesImple* m_impl;
     /** @endcond */
-
+    void doAddValue(const _TCHAR* v, bool isNull);
 public:
     fieldNames();
     fieldNames(const fieldNames& r);
@@ -63,6 +63,16 @@ public:
     void release();
 };
 
+class DLLLIB fieldValues : public fieldNames
+{
+public:
+    fieldValues();
+    fieldValues(const fieldValues& r);
+    fieldValues& operator=(const fieldValues& r);
+    void addValue(const _TCHAR* v, bool isNull);
+    bool isNull(int index) const;
+};
+
 struct sortField
 {
     std::_tstring name;
@@ -99,7 +109,6 @@ class DLLLIB recordsetQuery : protected query
 
     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:
@@ -139,6 +148,42 @@ public:
         return *this;
     }
 
+    inline recordsetQuery& whenIsNull(const _TCHAR* name)
+    {
+        query::whereIsNull(name);
+        return *this;
+    }
+
+    inline recordsetQuery& whenIsNotNull(const _TCHAR* name)
+    {
+        query::whereIsNotNull(name);
+        return *this;
+    }
+
+    inline recordsetQuery& andIsNull(const _TCHAR* name)
+    {
+        query::andIsNull(name);
+        return *this;
+    }
+
+    inline recordsetQuery& andIsNotNull(const _TCHAR* name)
+    {
+        query::andIsNotNull(name);
+        return *this;
+    }
+
+    inline recordsetQuery& orIsNull(const _TCHAR* name)
+    {
+        query::orIsNull(name);
+        return *this;
+    }
+
+    inline recordsetQuery& orIsNotNull(const _TCHAR* name)
+    {
+        query::orIsNotNull(name);
+        return *this;
+    }
+
     inline const _TCHAR* toString() const { return queryBase::toString(); }
 
     inline query* internalQuery() { return this; }
@@ -157,17 +202,19 @@ protected:
     class groupFuncBaseImple* m_imple;
 
     void init(const fielddefs* fdinfo);
-    unsigned char* stringResult(int groupIndex) const;
+    unsigned char* stringResult(int index) 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);
+    virtual void doCalcEachkey(const field& fd, int index);
+    virtual void doCalc(const row_ptr& row, int index);
     virtual void doReset();
     virtual void doInit(const fielddefs* fdinfo);
-    virtual numeric_type numericResult(int groupIndex) const;
-    
+    virtual numeric_type numericResult(int index) const;
+    bool insertFlag() const ;
+    void clearInsertFlag();
 
 public:
     groupFuncBase();
@@ -182,7 +229,10 @@ public:
     void setResultName(const _TCHAR* v);
     int resultKey() const;
     void reset();
+    bool isNull(int index) const;
+    uchar_td decimals() const;
     virtual groupFuncBase* clone() = 0;
+    
 };
 
 class recordsetImple;
@@ -217,10 +267,10 @@ public:
 class DLLLIB sum : public groupFuncBase
 {
 protected:
-    void doCalc(const row_ptr& row, int index);
+    virtual void doCalcEachkey(const field& fd, int index);
     groupFuncBase* clone();
 public:
-    sum() {}
+    sum() : groupFuncBase() {}
     sum(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
     static sum* create(const fieldNames& targetNames,
                        const _TCHAR* resultName = NULL);
@@ -230,54 +280,56 @@ class DLLLIB count : public groupFuncBase
 {
 protected:
     groupFuncBase* clone();
+    void doCalcEachkey(const field& fd, int index);
     void doCalc(const row_ptr& row, int index);
-
+    void initResultVariable(int index);
 public:
-    count() {}
+    count(): groupFuncBase(){}
     count(const _TCHAR* resultName);
+    count(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
     static count* create(const _TCHAR* resultName);
+    static count* create(const fieldNames& targetNames,
+                       const _TCHAR* resultName = NULL);
 };
 
-class DLLLIB avg : public sum
+class DLLLIB avg : public groupFuncBase
 {
     void initResultVariable(int index);
-    void doCalc(const row_ptr& row, int index);
+    void doCalcEachkey(const field& fd, int index);
     numeric_type numericResult(int index) const;
     groupFuncBase* clone();
-
 public:
-    avg() {}
+    avg();
     avg(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
     static avg* create(const fieldNames& targetNames,
                        const _TCHAR* resultName = NULL);
+
 };
 
 #undef min
-class DLLLIB min : public sum
+class DLLLIB min : public groupFuncBase
 {
 protected:
-    bool m_flag;
-    void doCalc(const row_ptr& row, int index);
+    void doCalcEachkey(const field& fd, int index);
     groupFuncBase* clone();
     min& operator=(const min& r);
 
 public:
-    min() {}
+    min() : groupFuncBase() {}
     min(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
     static min* create(const fieldNames& targetNames,
                        const _TCHAR* resultName = NULL);
 };
 
 #undef max
-class DLLLIB max : public sum
+class DLLLIB max : public groupFuncBase
 {
-    bool m_flag;
-    void doCalc(const row_ptr& row, int index);
+    void doCalcEachkey(const field& fd, int index);
     groupFuncBase* clone();
     max& operator=(const max& r);
 
 public:
-    max() {}
+    max() : groupFuncBase(){}
     max(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
     static max* create(const fieldNames& targetNames,
                        const _TCHAR* resultName = NULL);
@@ -290,8 +342,9 @@ protected:
     void doCalc(const row_ptr& row, int index);
     void doInit(const fielddefs* fdinfo);
     groupFuncBase* clone();
+    void storeValue(const row_ptr& row, int index);
 public:
-    last() {}
+    last() : groupFuncBase(){}
     last(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
     static last* create(const fieldNames& targetNames,
                        const _TCHAR* resultName = NULL);
@@ -300,14 +353,13 @@ public:
 
 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() : last() {}
     first(const fieldNames& targetNames, const _TCHAR* resultName = NULL);
     static first* create(const fieldNames& targetNames,
                        const _TCHAR* resultName = NULL);

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

@@ -54,7 +54,7 @@ void autoMemory::setParams(unsigned char* p, size_t s, short* endIndex, bool own
     endFieldIndex = endIndex;
     if (owner)
     {
-        ptr = new unsigned char[s];
+        ptr = new unsigned char[s+1];
         if (p)
             memcpy(ptr, p, size);
         else
@@ -122,7 +122,7 @@ autoMemory* autoMemory::create()
 //---------------------------------------------------------------------------
 //    class memoryRecord
 //---------------------------------------------------------------------------
-inline memoryRecord::memoryRecord() : fieldsBase(NULL)
+inline memoryRecord::memoryRecord() : fieldsBase(NULL), m_blockIndexCache(0)
 {
 #ifdef JOIN_UNLIMIT
     m_memblock.reserve(ROW_MEM_BLOCK_RESERVE);
@@ -131,7 +131,8 @@ inline memoryRecord::memoryRecord() : fieldsBase(NULL)
 #endif
 }
 
-inline memoryRecord::memoryRecord(fielddefs& fdinfo) : fieldsBase(&fdinfo)
+inline memoryRecord::memoryRecord(fielddefs& fdinfo) : fieldsBase(&fdinfo),
+        m_blockIndexCache(0)
 {
 #ifdef JOIN_UNLIMIT
     m_memblock.reserve(ROW_MEM_BLOCK_RESERVE);
@@ -141,7 +142,7 @@ inline memoryRecord::memoryRecord(fielddefs& fdinfo) : fieldsBase(&fdinfo)
 }
 
 memoryRecord::memoryRecord(const memoryRecord& r)
-    : fieldsBase(r.m_fns)
+    : fieldsBase(r.m_fns),m_blockIndexCache(r.m_blockIndexCache)
 {
 #ifdef JOIN_UNLIMIT
     m_memblock = r.m_memblock;
@@ -166,6 +167,7 @@ memoryRecord& memoryRecord::operator=(const memoryRecord& r)
      if (this != &r)
      {
          m_fns = r.m_fns;
+         m_blockIndexCache = r.m_blockIndexCache;
 #ifdef JOIN_UNLIMIT
          m_memblock = r.m_memblock;
 #endif
@@ -204,20 +206,30 @@ void memoryRecord::setRecordData(autoMemory* am, unsigned char* ptr,
     m_memblock[m_memblockSize] = am;
     ++m_memblockSize;
 #endif
+    m_InvalidFlags &= ~1L;  
 }
 
 void memoryRecord::copyToBuffer(table* tb, bool updateOnly) const
 {
-    if (!updateOnly)
-        memcpy(tb->fieldPtr(0), ptr(0), m_fns->totalFieldLen());
-    else
+    if (m_fns->size())
     {
-        for (int i = 0; i < (int)m_fns->size(); ++i)
+        short index = 0;
+        if (!updateOnly)
+            memcpy(tb->fields()[index].nullPtr(), nullPtr(index),
+                    m_fns->totalFieldLen());
+        else
         {
-            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);
+            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);
+                    //copy null bits
+                    tb->setFVNull(i, operator[](i).isNull());
+                }
+            }
         }
     }
 }
@@ -294,7 +306,7 @@ writableRecord::writableRecord(table* tb, const aliasMap_type* alias)
     m_tb->clearBuffer();
     m_fddefs->clear();
     m_fddefs->setAliases(alias);
-    m_fddefs->copyFrom(m_tb);
+    m_fddefs->addSelectedFields(m_tb);
     setRecordData(autoMemory::create(), 0, 0, &m_endIndex, true);
 }
 
@@ -376,6 +388,12 @@ void writableRecord::save()
     }
 }
 
+void writableRecord::clear()
+{
+    m_tb->clearBuffer(table::defaultNull);
+    copyFromBuffer(m_tb);
+}
+
 writableRecord* writableRecord::create(table* tb, const aliasMap_type* alias)
 {
     writableRecord* p = new writableRecord(tb, alias);

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

@@ -77,37 +77,38 @@ class DLLLIB memoryRecord : public fieldsBase
     autoMemory* m_memblock[JOINLIMIT_PER_RECORD];
     int m_memblockSize;
 #endif
-
+    mutable int m_blockIndexCache;
     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;
+    /** @cond INTERNAL */
 
     /* return memory block first address which not field ptr address */
     inline unsigned char* ptr(int index) const
     {
+        return nullPtr(index) + (*m_fns)[index].nullbytes();
+    }
+
+    inline unsigned char* nullPtr(int index) const
+    {
+        return m_memblock[memoryBlockIndex(index)]->ptr;
+    }
+
+    inline int memoryBlockIndex(int index) const 
+    { 
         for (int i = 0; i < memBlockSize(); ++i)
             if (*(m_memblock[i]->endFieldIndex) > index)
-                return m_memblock[i]->ptr;
+                return m_blockIndexCache = i;
         assert(0);
-        return NULL;
+        return 0;
     }
 
+    int memoryBlockIndexCache() const { return m_blockIndexCache;}
+
     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);
+        return *m_memblock[memoryBlockIndex(index)];
     }
 
     inline const autoMemory& memBlock(int index) const
@@ -119,10 +120,6 @@ protected:
 #else
     inline int memBlockSize() const { return m_memblockSize; }
 #endif
-    inline void copyFromBuffer(const table* tb)
-    {
-        memcpy(ptr(0), tb->fieldPtr(0), m_fns->totalFieldLen());
-    }
 
     void removeLastMemBlock() 
     { 
@@ -137,9 +134,21 @@ protected:
         }
     }
 
+    void releaseMemory();
+
+protected:
+    inline memoryRecord();
+    inline memoryRecord(fielddefs& fdinfo);
+    memoryRecord(const memoryRecord& r);
+    ~memoryRecord();
+    memoryRecord& operator=(const memoryRecord& r);
+    void copyToBuffer(table* tb, bool updateOnly = false) const;
+    inline void copyFromBuffer(const table* tb)
+    {
+        memcpy(nullPtr(0), tb->data(), m_fns->totalFieldLen());
+    }
     void setRecordData(autoMemory* am, unsigned char* ptr, size_t size,
                        short* endFieldIndex, bool owner = false);
-    void releaseMemory();
 
     /** @endcond */
 public:
@@ -176,6 +185,7 @@ public:
     void del(bool KeysetAlrady = false, bool noSeek = false);
     void update(bool KeysetAlrady = false, bool noSeek = false);
     void save();
+    void clear();// orverride
 
 };
 

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

@@ -934,7 +934,7 @@ const char* nsdatabase::toServerUri(char* buf, int buflen, const _TCHAR* src,
     if (trd)
     {
         stringConverter cv(CP_UTF8, GetACP());
-        cv.convert(buf, buflen, src, strlen_t(src));
+        cv.convert(buf, buflen, src, strlen_t(src)+1);// convert include null.
         return buf;
     }
 #endif

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

@@ -55,7 +55,10 @@ DLLLIB BTRCALLID_PTR getTrnsctdEntryPoint();
 class DLLLIB nsdatabase
 {
     friend class nstable;
+    friend class dbdef;
+/** @cond INTERNAL */
     friend bool reconnectSharedConnection(const void* ptr);
+/** @endcond */
     struct nsdbimpl* m_nsimpl;
     nsdatabase(const nsdatabase&);
     static unsigned int m_execCodepage;
@@ -79,7 +82,7 @@ protected:
     void internalRelease() { nsdatabase::release(); }
     void doReconnect(nstable* tb);
     virtual bool doReopenDatabaseSchema(){ return true; }
-    
+    virtual void* getExtendBufferForOpen(uint_td& size){ return NULL; };
 public:
     nsdatabase();
     virtual void release();

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

@@ -30,10 +30,11 @@
 #pragma package(smart_init)
 
 /* TODO: To be support internal started transction with original flag.*/
-#ifdef __x86_64__
-#define MEM_FREED_MAGIC_NUMBER (nstimpl*)0x0FEEEFEEEFEEEFEEE
-#else
+
+#if (defined(__x86_32__) || defined(__APPLE_32__))
 #define MEM_FREED_MAGIC_NUMBER (nstimpl*)0x0FEEEFEEE
+#else
+#define MEM_FREED_MAGIC_NUMBER (nstimpl*)0x0FEEEFEEEFEEEFEEE
 #endif
 namespace bzs
 {
@@ -49,14 +50,15 @@ namespace client
 struct nstimpl
 {
     nstimpl()
-        : refCount(1), bulkIns(NULL), percentage(0),bookmarkLen(0),mode(0),
+        : bulkIns(NULL), refCount(1), percentage(0), bookmarkLen(0), tableid(0), mode(0),
             shared(false), isOpen(false)
     {
         memset(posblk, 0 ,POS_BLOCK_SIZE);
+        uri[0] = 0x00;
     }
-    int refCount;
     bulkInsert* bulkIns;
     nsdatabase* nsdb;
+    int refCount;
     percentage_td percentage;
     ushort_td bookmarkLen;
     bookmark_td bookmark;
@@ -211,7 +213,6 @@ void nstable::addref(void)
 
 void nstable::release()
 {
-
     /* If before called database::drop() database::close() etc then
        nstable::destory called.
        Client cache nstable pointer that is invalid.
@@ -227,6 +228,7 @@ void nstable::release()
     }
     catch (...)
     {
+
     }
 }
 
@@ -240,7 +242,8 @@ void nstable::doClose()
 {
     if (test(this) && m_impl && (m_impl->isOpen))
     {
-        tdap(TD_CLOSETABLE);
+        if (m_impl->nsdb->btrvFunc())
+            tdap(TD_CLOSETABLE);
         if (m_stat == STATUS_SUCCESS)
             m_impl->isOpen = false;
     }
@@ -366,7 +369,7 @@ void nstable::doOpen(const _TCHAR* name, char_td mode, const _TCHAR* ownerName)
     else
 #endif
     {
-        if (m_impl->uri != name)
+        if (_tcscmp(m_impl->uri, name))
             _tcscpy_s(m_impl->uri, MAX_PATH, name);
     }
     // for trnasctd
@@ -396,27 +399,35 @@ void nstable::doOpen(const _TCHAR* name, char_td mode, const _TCHAR* ownerName)
     else
         m_keynum = mode;
 
-    char ownerNameBuf[OWNERNAME_SIZE] = { 0x00 };
-
+    char ownerNameBuf[OWNERNAME_SIZE];// = { 0x00 };
+    uint_td size = 0;
+    char* buf = (char*)nsdb()->getExtendBufferForOpen(size);
+    if (!buf)
+        buf = ownerNameBuf;
+    
+    m_pdata = (void*)buf;
     if (NULL != ownerName && 0x00 != ownerName[0])
     {
-        const char* p2 = toChar(ownerNameBuf, ownerName, OWNERNAME_SIZE);
-        m_pdata = (void*)p2;
-        m_datalen = (uint_td)strlen(p2) + 1;
+        toCharCpy(buf, ownerName, OWNERNAME_SIZE);
+        m_datalen = (uint_td)strlen(buf) + 1;
+        
         if (m_datalen > 11)
         {
             m_stat = STATUS_TOO_LONG_OWNERNAME;
             goto clean;
         }
-        if (m_datalen < sizeof(unsigned int))
-            m_datalen = sizeof(unsigned int);/* for bookmarklen*/
+        if (m_datalen < sizeof(ushort_td))
+            m_datalen = sizeof(ushort_td);/* for bookmarklen*/
     }
     else
     {
         m_impl->bookmarkLen = 0;
-        m_pdata = &m_impl->bookmarkLen;
+        memcpy(buf, &m_impl->bookmarkLen, sizeof(ushort_td));
+        //m_pdata = &m_impl->bookmarkLen;
         m_datalen = sizeof(ushort_td);/* for bookmarklen*/
     }
+    if (size)
+        m_datalen = size;
     tdap(TD_OPENTABLE);
     if (m_stat == STATUS_SUCCESS)
     {
@@ -424,10 +435,15 @@ void nstable::doOpen(const _TCHAR* name, char_td mode, const _TCHAR* ownerName)
         m_impl->mode = mode;
         if (!isUseTransactd())
             m_impl->bookmarkLen = BTRV_BOOKMARK_SIZE;
-        else if (m_impl->bookmarkLen == 0)
-            m_impl->bookmarkLen = BTRV_BOOKMARK_SIZE;
-        else if (m_impl->bookmarkLen == 0xFFFF) //No primary
-            m_impl->bookmarkLen = 0;
+        else
+        {
+            ushort_td* p = (ushort_td*)m_pdata;
+            m_impl->bookmarkLen = *p;
+            if (m_impl->bookmarkLen == 0)
+                m_impl->bookmarkLen = BTRV_BOOKMARK_SIZE;
+            else if (m_impl->bookmarkLen == 0xFFFF) //No primary
+                m_impl->bookmarkLen = 0;
+        }
     }
 clean:
     m_keybuf = svm_keybuf;
@@ -896,7 +912,7 @@ short_td nstable::tdapErr(HWND hWnd, short_td status, const _TCHAR* TableName,
     }
 #pragma warning(default : 4996)
 
-    if ((int)hWnd <= 0)
+    if (hWnd == 0)
         return errorCode;
 
 #ifdef _WIN32
@@ -937,9 +953,11 @@ _TCHAR* nstable::getDirURI(const _TCHAR* path, _TCHAR* buf)
         _tfullpath(buf, path, MAX_PATH);
     else
 #endif
-        stripAuth(path, buf, MAX_PATH);
-    _TUCHAR* p = (_TUCHAR*)_tcsmrchr((const _TUCHAR*)buf, PSEPARATOR_C);
-    _TUCHAR* p2 = (_TUCHAR*)_tcsmrchr((const _TUCHAR*)buf, '=');
+    stripAuth(path, buf, MAX_PATH);
+    _TUCHAR* p = _tcsmrchr((_TUCHAR*)buf, PSEPARATOR_C);
+    _TUCHAR* p1 = _tcsmrchr((_TUCHAR*)buf, '?');
+    if (p1 && (p1 > p)) p = p1;
+    _TUCHAR* p2 = _tcsmrchr((_TUCHAR*)buf, '=');
     if (p && p2)
     {
         if (p2 > p)
@@ -951,6 +969,14 @@ _TCHAR* nstable::getDirURI(const _TCHAR* path, _TCHAR* buf)
         *p = 0x00;
     if (p2)
         *(p2 + 1) = 0x00;
+    if (uri && !_tcsstr(buf, _T("dbfile=")))
+    {
+        p = _tcsmrchr((_TUCHAR*)buf, '?');
+        if (!p)
+            _tcscat(buf, _T("?dbfile="));
+        else
+            _tcscat(buf, _T("dbfile="));
+    }
     return buf;
 }
 
@@ -1006,6 +1032,25 @@ bool nstable::test(nstable* p)
     return false;
 }
 
+void nstable::test_store(const char* values)
+{
+    void* svm_pdata = m_pdata;
+    m_stat = STATUS_SUCCESS;
+    m_keylen = m_keybuflen;
+    m_datalen = (uint_td)strlen(values) + 1;
+    m_pdata = (void*)values;
+    tdap(TD_STORE_TEST);
+    m_pdata = svm_pdata;
+}
+
+void nstable::setTimestampMode(int mode)
+{
+    char_td keynum = m_keynum;
+    m_keynum = (char_td)mode;
+    tdap(TD_SET_TIMESTAMP_MODE);
+    m_keynum = keynum;
+}
+
 } // namespace client
 } // namespace tdap
 } // namespace protocol

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

@@ -72,9 +72,9 @@ private:
 
 protected:
     void* m_pdata;
+    void* m_keybuf;
     uint_td m_buflen;
     uint_td m_datalen;
-    void* m_keybuf;
     ushort_td m_op;
     keylen_td m_keybuflen;
     keylen_td m_keylen;
@@ -225,6 +225,7 @@ public:
     void unlock(bookmark_td& bm);
     void unlock();
     char_td mode() const;
+    void setTimestampMode(int mode);
     static _TCHAR* getFileName(const _TCHAR* uri, _TCHAR* retbuf);
     static short_td tdapErr(HWND hWnd, short_td status,
                             const _TCHAR* tableName = NULL,
@@ -235,6 +236,7 @@ public:
     static bool existsFile(const _TCHAR* filename);
     /** @cond INTERNAL */
     static bool test(nstable* p);
+    void test_store(const char* values);
     /** @endcond*/
 };
 

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

@@ -91,6 +91,7 @@ const fielddefs* recordset::fieldDefs() const
 row& recordset::operator[](size_t index) const
 {
     m_imple->checkIndex(index);
+    m_imple->clearStringBuffer();
     return (*m_imple)[index];
 }