transactd 3.5.0 → 3.6.0

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

@@ -73,7 +73,7 @@ public:
         int index = findTable(name);
         if (index != -1)
             return m_tables[index];
-        table_ptr t = openTable(m_db, name);
+        table_ptr t = openTable(m_db, name, TD_OPEN_NORMAL);
         if (t)
             m_tables.push_back(t);
         return t;
@@ -190,7 +190,7 @@ public:
         int index = findTable(name);
         if (index != -1)
             return m_tables[index];
-        table_ptr t = openTable(m_db, name);
+        table_ptr t = openTable(m_db, name, TD_OPEN_NORMAL);
         if (t)
             m_tables.push_back(t);
         return t;

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

@@ -105,7 +105,7 @@ struct dbdimple
     }
 };
 
-dbdef::dbdef(nsdatabase* pbe, short defType) : nstable(pbe)
+dbdef::dbdef(nsdatabase* pbe, short defType, short mode) : nstable(pbe)
 {
     m_dimpl = new dbdimple();
     m_dimpl->deftype = defType;
@@ -113,6 +113,7 @@ dbdef::dbdef(nsdatabase* pbe, short defType) : nstable(pbe)
     m_keybuflen = 128;
     m_keybuf = &m_dimpl->keybuf[0];
     setShared();
+    setMode((char_td)mode);
 }
 
 dbdef::~dbdef()
@@ -745,6 +746,7 @@ tabledef* dbdef::initReadAfter(short tableIndex, const tabledef* data, uint_td d
     td->setFielddefsPtr();
     td->setKeydefsPtr();
     td->autoIncExSpace = ((database*)nsdb())->defaultAutoIncSpace();
+    td->convertToUtf8Schema();
     //Fix:Bug of maxRecordLen is mistake value saved, recalculate maxRecordLen.
     td->calcReclordlen();
     td->optionFlags.bitC = (td->fieldDefs[td->fieldCount -1].type == ft_myfixedbinary);
@@ -1014,12 +1016,14 @@ short dbdef::findKeynumByFieldNum(short tableIndex, short index)
 short dbdef::tableNumByName(const _TCHAR* tableName)
 {
     char buf[74];
+    const char* p = NULL;
     for (short i = 1; i <= m_dimpl->tableCount; i++)
     {
         tabledef* td = tableDefs(i);
         if (td)
         {
-            const char* p = td->toChar(buf, tableName, 74);
+            if (!p)
+            	p = td->toChar(buf, tableName, 74);
             if (strcmp(td->tableNameA(), p) == 0)
                 return i;
         }
@@ -1277,6 +1281,9 @@ bool dbdef::isPassKey(uchar_td FieldType)
 void dbdef::autoMakeSchema(bool nouseNullkey)
 {
     m_keynum = (int)nouseNullkey;
+    if (database::compatibleMode() & database::CMP_MODE_BINFD_DEFAULT_STR)
+        m_keynum += 2; // binary field defaut string
+
     tdap(TD_AUTOMEKE_SCHEMA);
 }
 
@@ -1591,12 +1598,15 @@ void dbdef::openDdf(const _TCHAR* dir, short Mode, const _TCHAR* OwnerName)
                             insertKey(tbid, tableDefs(tbid)->keyCount);
 
                         KeyDef = &(tableDefs(tbid)->keyDefs[id->keyid]);
-                        if (KeyDef->segmentCount < id->segmentnum + 1)
-                            KeyDef->segmentCount =
-                                (uchar_td)(id->segmentnum + 1);
-                        KeyDef->segments[id->segmentnum].fieldNum =
-                            (uchar_td)FieldIndex;
-                        KeyDef->segments[id->segmentnum].flags.all = id->flag;
+                        if (id->segmentnum < 8)
+                        {
+                            if (KeyDef->segmentCount < id->segmentnum + 1)
+                                KeyDef->segmentCount =
+                                    (uchar_td)(id->segmentnum + 1);
+                            KeyDef->segments[id->segmentnum].fieldNum =
+                                (uchar_td)FieldIndex;
+                            KeyDef->segments[id->segmentnum].flags.all = id->flag;
+                        }
                         id->seekNext();
                     }
                 }
@@ -1813,7 +1823,10 @@ void dbdef::synchronizeSeverSchema(short tableIndex)
     m_pdata = m_dimpl->bdf;
     m_buflen = m_datalen = m_dimpl->bdfLen;
     m_dimpl->bdf->id = tableIndex;
+    m_keynum = SC_SUBOP_TABLEDEF;
     tdap((ushort_td)TD_GET_SCHEMA);
+    m_keybuf = tmp;
+    m_keynum = 0;
     if (m_stat == STATUS_SUCCESS)
     {
         if (m_datalen == 0)
@@ -1831,7 +1844,6 @@ void dbdef::synchronizeSeverSchema(short tableIndex)
             delete tdold;
         }
     }
-    m_keybuf = tmp;
 }
 
 } // namespace client

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

@@ -74,7 +74,7 @@ class DLLLIB dbdef : private nstable
     void tableDefCopy(tabledef* dest, const tabledef* src, size_t size);
 
     ~dbdef();
-    dbdef(nsdatabase* pbe, short defType);
+    dbdef(nsdatabase* pbe, short defType, short mode);
     void create(const _TCHAR* uri);
     void autoMakeSchema(bool noUseNullkey);
     bool testTablePtr(tabledef* td);

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

@@ -213,11 +213,16 @@ extern "C" PACKAGE_OSX short_td __STDCALL
         case TD_UPDATE_PART:
             client_t->cleanup();
             return 0;
-        case TD_REC_DELETE:
+        
         case TD_CLEAR_OWNERNAME:
         case TD_AUTOMEKE_SCHEMA:
             client_t->req().paramMask = P_MASK_POSBLK | P_MASK_KEYNUM;
             break;
+        case TD_REC_DELETE:
+            client_t->req().paramMask = P_MASK_POSBLK | P_MASK_KEYNUM;
+            if (client_t->req().op > 100)
+                client_t->req().paramMask |= P_MASK_DATA | P_MASK_DATALEN;
+            break;
         case TD_END_TRANSACTION:
         case TD_BEGIN_TRANSACTION:
         case TD_ABORT_TRANSACTION:
@@ -250,7 +255,10 @@ extern "C" PACKAGE_OSX short_td __STDCALL
         case TD_KEY_LE_KO:
         case TD_REC_DELLETEATKEY:
             client_t->req().paramMask = P_MASK_KEYNAVI;
-            if (op > 50)
+            // Send updateTimepstamp value when op = TD_REC_DELLETEATKEY + 100 
+            if (op == TD_REC_DELLETEATKEY && client_t->req().op > 100)
+                client_t->req().paramMask |= P_MASK_DATA;
+            else if (op > 50)
                 client_t->req().paramMask &= ~P_MASK_DATALEN;
             break;
         case TD_KEY_NEXT_MULTI:

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

@@ -314,6 +314,7 @@ public:
 //------------------------------------------------------------------------------
 //       class fieldShare
 //------------------------------------------------------------------------------
+
 struct Imple
 {
     stringConverter* cv;
@@ -359,6 +360,11 @@ void fieldShare::blobClear()
     m_imple->blobs.clear();
 }
 
+void fieldShare::blobResize(size_t size)
+{
+    m_imple->blobs.resize(size);
+}
+
 //------------------------------------------------------------------------------
 //       class fielddefs
 //------------------------------------------------------------------------------
@@ -463,21 +469,27 @@ void fielddefs::push_back(const fielddef* p)
         ++m_imple->mysqlnullEnable;
     // reset update indicator
     pp->enableFlags.bitE = false;
+
+    // For activeTable need replacing name
     aliasing(pp);
     m_imple->map[pp->name()] = index;
 }
 
 void fielddefs::remove(int index)
 {
-    m_imple->map.erase(m_imple->fields[index].name());
     m_imple->fields.erase(m_imple->fields.begin() + index);
     boost::unordered_map<std::_tstring, int>::iterator it =
         m_imple->map.begin();
     while (it != m_imple->map.end())
     {
-        if ((*it).second > index)
-            (*it).second--;
-        ++it;
+        if ((*it).second == index)
+            it = m_imple->map.erase(it);
+        else
+        {
+            if ((*it).second > index)
+                (*it).second--;
+            ++it;
+        }
     }
 }
 
@@ -508,6 +520,14 @@ bool fielddefs::checkIndex(int index) const
     return (index >= 0 && index < (int)m_imple->fields.size());
 }
 
+void fielddefs::addAliasName(int index, const _TCHAR* name)
+{
+    assert(checkIndex(index));
+    //replace original name
+    m_imple->fields[index].setName(name);
+    m_imple->map[name] = index;
+}
+
 int fielddefs::indexByName(const std::_tstring& name) const
 {
     if (m_imple->map.count(name) == 0)
@@ -544,16 +564,20 @@ size_t fielddefs::totalFieldLen() const
     return fd.pos + fd.len + fd.nullbytes();
 }
 
-void fielddefs::addAllFileds(const tabledef* def)
+void fielddefs::addAllFields(const tabledef* def)
 {
     m_imple->fields.clear();
     m_imple->mysqlnullEnable = 0;
+    short blobCount = 0;
     for (int i = 0; i < def->fieldCount; ++i)
     {
         const fielddef* fd = &def->fieldDefs[i];
         push_back(fd);
         m_imple->fields[m_imple->fields.size() - 1].setPadCharDefaultSettings();
+        if (fd->isBlob())
+            ++blobCount;
     }
+    blobResize(blobCount);
 }
 
 void fielddefs::addSelectedFields(const table* tb)

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

@@ -66,6 +66,7 @@ protected:
     bzs::rtl::stringBuffer* strBufs() const;
     void blobPushBack(char* p);
     void blobClear();
+    void blobResize(size_t size);
 };
 
 /** @endcond */
@@ -100,13 +101,14 @@ class DLLLIB fielddefs : public fieldShare
 public:
     void clear();
     fielddefs* clone() const;
+    void addAliasName(int index, const _TCHAR* name);
     int indexByName(const std::_tstring& name) const;
     const fielddef& operator[](int index) const;
     const fielddef& operator[](const _TCHAR* name) const;
     const fielddef& operator[](const std::_tstring& name) const;
     bool checkIndex(int index) const;
     size_t size() const;
-    void addAllFileds(const tabledef* def);
+    void addAllFields(const tabledef* def);
     void addSelectedFields(const class table* tb);
     void release();
     static fielddefs* create();

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

@@ -115,6 +115,11 @@ void fdNmaeAlias::reverseAliasNamesQuery(queryBase& q) const
     }
 }
 
+size_t fdNmaeAlias::size() const
+{
+    return m_imple->map.size();
+}
+
 } // namespace client
 } // namespace tdap
 } // namespace protocol

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

@@ -45,6 +45,7 @@ public:
     const _TCHAR* resolv(const _TCHAR* dst) const;
     void clear();
     void reverseAliasNamesQuery(queryBase& q) const;
+    size_t size() const;
 
 };
 

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

@@ -126,6 +126,8 @@ class fieldsBase : public refarymem
     friend class recordsetImple;           // setRecordData  setFielddefs
     friend class recordsetQuery;           // setRecordData
     friend class groupQueryImple;          // setInvalidMemblock
+    friend class recordCache;              // setInvalidMemblock
+    friend class table;                    // setInvalidMemblock
 
     virtual unsigned char* ptr(int index) const = 0;
     virtual unsigned char* nullPtr(int index) const = 0;
@@ -169,8 +171,13 @@ protected:
 
     inline void setInvalidMemblock(short index) 
     { 
-        int num = memoryBlockIndex(index);
-        m_InvalidFlags |= ((2L << num) | 1L);  
+        if (index == -1)
+            m_InvalidFlags = 0;
+        else
+        {
+            int num = memoryBlockIndex(index);
+            m_InvalidFlags |= ((2L << num) | 1L); 
+        }
     }
 
     /** @endcond */

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

@@ -503,11 +503,15 @@ public:
             {
                 if (m_funcs[j]->isNull(i))
                     (*cur).setInvalidMemblock(m_funcs[j]->resultKey());
-                else if (m_funcs[j]->resultType() == ft_float)
-                    setValue(cur, m_funcs[j]->resultKey(), m_funcs[j]->numericResult(i));
                 else
-                    memcpy((*cur)[m_funcs[j]->resultKey()].ptr() ,
-                            m_funcs[j]->stringResult(i), m_funcs[j]->resultLen());
+                {
+                    (*cur).setInvalidMemblock(-1);
+                    if (m_funcs[j]->resultType() == ft_float)
+                        setValue(cur, m_funcs[j]->resultKey(), m_funcs[j]->numericResult(i));
+                    else
+                        memcpy((*cur)[m_funcs[j]->resultKey()].ptr() ,
+                                m_funcs[j]->stringResult(i), m_funcs[j]->resultLen());
+                }
             }
             mdls.push_back(cur);
         }

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

@@ -146,13 +146,16 @@ memoryRecord::memoryRecord(const memoryRecord& r)
 {
 #ifdef JOIN_UNLIMIT
     m_memblock = r.m_memblock;
+    for (int i = 0; i < memBlockSize(); ++i)
+        m_memblock[i]->addref();
 #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();
+    }
+#endif
 
 }
 
@@ -166,10 +169,15 @@ memoryRecord& memoryRecord::operator=(const memoryRecord& r)
 {
      if (this != &r)
      {
-         m_fns = r.m_fns;
+         for (int i = 0; i < memBlockSize(); ++i)
+             m_memblock[i]->release();
+         fieldsBase::operator=(r);
+         //m_fns = r.m_fns;
          m_blockIndexCache = r.m_blockIndexCache;
 #ifdef JOIN_UNLIMIT
          m_memblock = r.m_memblock;
+#else
+         m_memblockSize = r.m_memblockSize;
 #endif
          for (int i = 0; i < memBlockSize(); ++i)
          {
@@ -178,7 +186,6 @@ memoryRecord& memoryRecord::operator=(const memoryRecord& r)
 #endif
              m_memblock[i]->addref();
          }
-
      }
      return *this;
 }
@@ -203,6 +210,8 @@ void memoryRecord::setRecordData(autoMemory* am, unsigned char* ptr,
 #ifdef JOIN_UNLIMIT
     m_memblock.push_back(am);
 #else
+    if (m_memblockSize == JOINLIMIT_PER_RECORD)
+        THROW_BZS_ERROR_WITH_MSG(_T("The number of Join limit has been exceeded."));
     m_memblock[m_memblockSize] = am;
     ++m_memblockSize;
 #endif
@@ -358,6 +367,7 @@ void writableRecord::del(bool KeysetAlrady, bool noSeek)
         if (m_tb->stat())
             nstable::throwError(_T("activeTable delete "), m_tb->stat());
     }
+    if (m_tb->updateConflictCheck()) copyToBuffer(m_tb);
     deleteRecord(m_tb);
 }
 
@@ -371,7 +381,7 @@ void writableRecord::update(bool KeysetAlrady, bool noSeek)
         if (m_tb->stat())
             nstable::throwError(_T("activeTable update "), m_tb->stat());
     }
-    copyToBuffer(m_tb, true /*only changed*/);
+    copyToBuffer(m_tb, !m_tb->updateConflictCheck() /*only changed*/);
     updateRecord(m_tb);
 }
 
@@ -380,7 +390,10 @@ void writableRecord::save()
     copyToBuffer(m_tb);
     m_tb->seek();
     if (m_tb->stat() == STATUS_NOT_FOUND_TI)
+    {
         insertRecord(m_tb);
+        copyFromBuffer(m_tb);
+    }
     else
     {
         copyToBuffer(m_tb);

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

@@ -59,7 +59,7 @@ public:
 #define ROW_MEM_BLOCK_RESERVE 4
 
 #ifndef JOINLIMIT_PER_RECORD
-#define JOINLIMIT_PER_RECORD 0
+#define JOINLIMIT_PER_RECORD 14
 #endif
 #if (JOINLIMIT_PER_RECORD < 1)
 #define JOIN_UNLIMIT
@@ -141,7 +141,6 @@ protected:
     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)
     {
@@ -153,6 +152,7 @@ protected:
     /** @endcond */
 public:
     void clear(); // orverride
+    memoryRecord& operator=(const memoryRecord& r); // For SWIG
     static memoryRecord* create(fielddefs& fdinfo); // For SWIG
 };
 

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

@@ -51,7 +51,7 @@ struct nstimpl
 {
     nstimpl()
         : bulkIns(NULL), refCount(1), percentage(0), bookmarkLen(0), tableid(0), mode(0),
-            shared(false), isOpen(false)
+            shared(false), isOpen(false), updateConflictCheck(false)
     {
         memset(posblk, 0 ,POS_BLOCK_SIZE);
         uri[0] = 0x00;
@@ -68,6 +68,7 @@ struct nstimpl
     char_td mode;
     bool shared;
     bool isOpen;
+    bool updateConflictCheck;
 };
 
 // -----------------------------------------------------------------
@@ -180,6 +181,11 @@ void nstable::setIsOpen(bool v)
     m_impl->isOpen = v;
 }
 
+void nstable::setMode(char_td v)
+{
+    m_impl->mode = v;
+}
+
 bool nstable::isOpen() const
 {
     return m_impl->isOpen;
@@ -452,6 +458,17 @@ clean:
     m_pdata = data_bak;
 }
 
+bool nstable::setUpdateConflictCheck(bool v)
+{
+    m_impl->updateConflictCheck = v;
+    return getUpdateStampEnable();
+}
+
+bool nstable::updateConflictCheck() const
+{
+    return m_impl->updateConflictCheck;
+}
+
 void nstable::doUpdate(eUpdateType type)
 {
     int trnCount = nsdb()->enableTrn();
@@ -480,11 +497,11 @@ void nstable::doUpdate(eUpdateType type)
     else
         m_keylen = writeKeyData();
     m_datalen = getWriteImageLen();
-
-    if (m_impl->nsdb->isUseTransactd() && (type == changeInKey))
-        tdap(TD_REC_UPDATEATKEY);
-    else
-        tdap(TD_REC_UPDATE);
+    short op = (m_impl->nsdb->isUseTransactd() && (type == changeInKey)) ?
+                    TD_REC_UPDATEATKEY : TD_REC_UPDATE;
+    if (m_impl->updateConflictCheck) op += 100;
+        
+    tdap(op);
     m_keynum = keynum;
     onUpdateAfter(option);
 }
@@ -500,15 +517,26 @@ void nstable::doDel(bool inkey)
         return;
 
     m_datalen = m_buflen;
+    if (inkey && !isUniqeKey(m_keynum))
+    {
+        m_stat = STATUS_INVALID_KEYNUM;
+        return;
+    }
+    __int64 v = m_impl->updateConflictCheck ? getUpdateStampValue() : 0;
+    short op = v ? 100 : 0;
     if (m_impl->nsdb->isUseTransactd() && inkey)
     {
-        if (!isUniqeKey(m_keynum))
+        m_keylen = writeKeyData();
+        void* data_bak = m_pdata;
+        if (v)
         {
-            m_stat = STATUS_INVALID_KEYNUM;
-            return;
+            m_datalen = sizeof(__int64);
+            m_pdata = &v;
         }
-        m_keylen = writeKeyData();
-        tdap(TD_REC_DELLETEATKEY);
+        op += TD_REC_DELLETEATKEY;
+        tdap(op);
+        m_pdata = data_bak;
+        m_datalen = m_buflen;
     }
     else
     {
@@ -516,10 +544,15 @@ void nstable::doDel(bool inkey)
         {
             m_keylen = writeKeyData();
             seek();
-            if (m_stat)
+            if (m_stat) return;
+            if (v && v != getUpdateStampValue())
+            {
+                m_stat = STATUS_CHANGE_CONFLICT;
                 return;
+            }
         }
-        tdap(TD_REC_DELETE);
+        op += TD_REC_DELETE;
+        tdap(op);
     }
 }
 

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

@@ -99,6 +99,7 @@ protected:
     const _TCHAR* uri() const;
     const uchar_td* posblk() const;
     void setIsOpen(bool v);
+    void setMode(char_td v); //For dbdef in noschema mode.
 
     bulkInsert* bulkIns() const;
     virtual bool isUniqeKey(char_td keynum)
@@ -132,6 +133,8 @@ protected:
     virtual short_td doBtrvErr(HWND hWnd, _TCHAR* retbuf);
     virtual ushort_td doCommitBulkInsert(bool autoCommit);
     virtual void doAbortBulkInsert();
+    virtual __int64 getUpdateStampValue() const {return 0;}
+    virtual bool getUpdateStampEnable() const {return false;}
     inline void open(const _TCHAR* uri, char_td mode = 0,
                      const _TCHAR* ownerName = NULL)
     {
@@ -229,6 +232,8 @@ public:
     void unlock();
     char_td mode() const;
     void setTimestampMode(int mode);
+    bool setUpdateConflictCheck(bool v);
+    bool updateConflictCheck() const;
     static _TCHAR* getFileName(const _TCHAR* uri, _TCHAR* retbuf);
     static short_td tdapErr(HWND hWnd, short_td status,
                             const _TCHAR* tableName = NULL,

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

@@ -180,6 +180,11 @@ recordset& recordset::reverse()
     return *this;
 }
 
+void recordset::reserve(size_t size)
+{
+    m_imple->reserve(size);
+}
+
 void recordset::appendField(const _TCHAR* name, int type, short len)
 {
     m_imple->appendField(name, type, len);

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

@@ -71,6 +71,7 @@ public:
                        const _TCHAR* name7 = NULL, const _TCHAR* name8 = NULL);
     recordset& orderBy(const sortFields& orders);
     recordset& reverse();
+    void reserve(size_t size);
     void appendField(const _TCHAR* name, int type, short len);
     recordset& operator+=(const recordset& r);
     void release();

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

@@ -289,8 +289,7 @@ private:
         }
         else
         { // create new record
-            size_t reserveSize = m_recordset.size() + rows;
-            m_recordset.reserve(reserveSize);
+            m_recordset.reserve(m_recordset.size() + rows);
             memoryRecord* rec = memoryRecord::create(*m_fds, (int)rows);
             autoMemory* ama = autoMemory::create((int)rows);
             for (int i = 0; i < (int)rows; ++i)
@@ -693,6 +692,11 @@ public:
         m_fds->strBufs()->clear();
     }
 
+    inline void reserve(size_t size)
+    {
+        m_recordset.reserve(size);
+    }
+
 #ifdef _DEBUG
     void dump()
     {