transactd 2.2.0 → 2.3.0

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

@@ -209,13 +209,15 @@ public:
             m_tb->m_impl->mraPtr->duplicateRow(row + rowOffset, count);
     }
 
-    inline void resetMra(filter* p, uchar_td* data, unsigned int totalSize,
+    inline void reset(filter* p, uchar_td* data, unsigned int totalSize,
                       const blobHeader* hd)
     {
-        reset(p, data, totalSize, hd);
+        doReset(p, data, totalSize, hd);
+        multiRecordAlocator* mra = m_tb->m_impl->mraPtr;
+        if (!mra) return;
         if (m_rowCount)
         {
-            multiRecordAlocator* mra = m_tb->m_impl->mraPtr;
+
             unsigned char* bd = NULL; //blob data
             if (m_filter->hasManyJoin())
                 hasManyJoinMra(m_rowCount, data);
@@ -258,18 +260,22 @@ public:
                             resultOffset += fd.len;
                         }
                     }
-                    else if (m_tb->valiableFormatType())
-                    {
-                        memset(m_tmpPtr, 0, td->maxRecordLen);
-                        memcpy(m_tmpPtr, m_ptr, m_len);
-                        m_unpackLen = m_tb->unPack((char*)m_tmpPtr, m_len);
-                        m_tb->setBlobFieldPointer((char*)m_tmpPtr, m_hd);
-                        resultOffset = m_unpackLen; 
-                    }
                     else
                     {
-                        memcpy(m_tmpPtr, m_ptr, m_len);
-                        resultOffset = m_len;
+                        if (m_tb->valiableFormatType())
+                        {
+                            memset(m_tmpPtr, 0, td->maxRecordLen);
+                            memcpy(m_tmpPtr, m_ptr, m_len);
+                            m_unpackLen = m_tb->unPack((char*)m_tmpPtr, m_len);
+                            resultOffset = m_unpackLen; 
+                        }
+                        else
+                        {
+                            memcpy(m_tmpPtr, m_ptr, m_len);
+                            resultOffset = m_len;
+                        }
+                        if (bd)
+                            bd = m_tb->setBlobFieldPointer((char*)m_tmpPtr, m_hd, bd);
                     }
                 }
                 ++m_row;
@@ -281,7 +287,7 @@ public:
         setMemblockType(mra_nextrows);
     }
 
-    inline void reset(filter* p, uchar_td* data, unsigned int totalSize,
+    inline void doReset(filter* p, uchar_td* data, unsigned int totalSize,
                       const blobHeader* hd)
     {
         m_filter = p;
@@ -434,26 +440,6 @@ uchar_td table::charset() const
     return (*m_tableDef)->charsetIndex;
 }
 
-bool table::trimPadChar() const
-{
-    return m_fddefs->trimPadChar;
-}
-
-void table::setTrimPadChar(bool v)
-{
-    m_fddefs->trimPadChar = v;
-}
-
-bool table::usePadChar() const
-{
-    return m_fddefs->usePadChar;
-}
-
-void table::setUsePadChar(bool v)
-{
-    m_fddefs->usePadChar = v;
-}
-
 void* table::dataBak() const
 {
     return m_impl->dataBak;
@@ -709,18 +695,16 @@ void table::btrvGetExtend(ushort_td op)
         stat = STATUS_LIMMIT_OF_REJECT;
 
     const blobHeader* hd = blobFieldUsed() ? getBlobHeader() : NULL;
-    if (m_impl->mraPtr)
-    {
-        m_impl->rc->resetMra(filter, (uchar_td*)m_pdata, m_datalen, hd);
-        m_stat = stat;
-        m_impl->filterPtr->setStat(stat);
-    }
-    else
+
+    // When using MRA,the read data is then copied all to recordset.
+    m_impl->rc->reset(filter, (uchar_td*)m_pdata, m_datalen, hd);
+
+    m_stat = stat;
+    m_impl->filterPtr->setStat(stat);
+
+    if (!m_impl->mraPtr)
     {
-        m_impl->rc->reset(filter, (uchar_td*)m_pdata, m_datalen, hd);
-        m_stat = stat;
-        m_impl->filterPtr->setStat(stat);
-        // There is the right record.
+        // When read one or more record(s), then stat set to 0.
         if (m_impl->rc->rowCount() && (!m_impl->exBookMarking))
         {
             m_pdata = (void*)m_impl->rc->setRow(0);
@@ -733,24 +717,47 @@ void table::btrvGetExtend(ushort_td op)
    
 }
 
-bool table::recordsLoop(ushort_td& op)
+/*
+  Reading continued control
+
+  When MRA enabled and reject=0 and m_stat = STATUS_LIMMIT_OF_REJECT,
+  continuing find operation automaticaly.
+  And when MRA enabled stat=0 too, continuing find operation automaticaly.
+
+  When MRA not enabled, only reject=0 and m_stat = STATUS_LIMMIT_OF_REJECT
+   continuing find operation automaticaly. When stat=0, not continue.
+
+*/
+
+bool table::isReadContinue(ushort_td& op)
 {
     client::filter* filter = m_impl->filterPtr.get();
     filter->setPosTypeNext(true);
-    bool flag = (m_stat == STATUS_LIMMIT_OF_REJECT && (filter->rejectCount() == 0));
-    if (m_impl->mraPtr && !flag)
-    {
-        flag = m_impl->filterPtr->isStatContinue();
-        if (!flag)       
-            m_stat = m_impl->filterPtr->translateStat();//finish
-    }
-    if (flag)
+
+    //reject count control
+    bool isContinue = (m_stat == STATUS_LIMMIT_OF_REJECT &&
+                            (filter->rejectCount() == 0));
+    if (m_impl->mraPtr && !isContinue)
+        isContinue = filter->isStatContinue();
+
+    // limit count control
+    if (isContinue)
     {
-        op = m_impl->filterPtr->isSeeksMode() ? 
-                TD_KEY_SEEK_MULTI : (m_impl->filterPtr->direction() == table::findForword) ?
+        if (filter->isStopAtLimit() && m_impl->rc->rowCount() == filter->maxRows())
+        {
+            m_stat = STATUS_LIMMIT_OF_REJECT;
+            return false;
+        }
+
+        // set next operation type and status
+        op = filter->isSeeksMode() ?
+                TD_KEY_SEEK_MULTI : (filter->direction() == table::findForword) ?
                         TD_KEY_NEXT_MULTI : TD_KEY_PREV_MULTI;
+        return true;
     }
-    return flag;
+    if (m_impl->mraPtr)
+        m_stat = filter->translateStat();
+    return false;
 }
 
 void table::getRecords(ushort_td op)
@@ -758,13 +765,20 @@ void table::getRecords(ushort_td op)
     do
     {
         btrvGetExtend(op);
-    }while (recordsLoop(op));
+    }while (isReadContinue(op));
 
     if ((m_stat == STATUS_REACHED_FILTER_COND) ||
         (m_stat == STATUS_LIMMIT_OF_REJECT))
         m_stat = STATUS_EOF;
 }
 
+short table::statReasonOfFind() const
+{
+    if (m_impl->filterPtr)
+        return m_impl->filterPtr->stat();
+    return stat();
+}
+
 bookmark_td table::bookmarkFindCurrent() const
 {
 
@@ -870,6 +884,13 @@ void table::btrvSeekMulti()
     m_stat = STATUS_EOF;
 }
 
+nstable::eFindType table::lastFindDirection() const
+{
+    if (m_impl->filterPtr)
+        return m_impl->filterPtr->direction();
+    return findForword;
+}
+
 void table::doFind(ushort_td op, bool notIncCurrent)
 {
     /*
@@ -963,9 +984,15 @@ void table::find(eFindType type)
         m_stat = STATUS_FILTERSTRING_ERROR;
         return;
     }
+    bool isContinue = (type == findContinue);
     ushort_td op;
-
-    if (m_impl->filterPtr->isSeeksMode())
+    if (isContinue)
+    {
+        type = m_impl->filterPtr->direction();
+        op =(type == findForword) ? TD_KEY_NEXT_MULTI : TD_KEY_PREV_MULTI;
+        m_stat = 0;
+    }
+    else if (m_impl->filterPtr->isSeeksMode())
     {
         m_impl->filterPtr->resetSeeksWrited();
         op = TD_KEY_SEEK_MULTI;
@@ -974,11 +1001,9 @@ void table::find(eFindType type)
         op =
             (type == findForword) ? TD_KEY_GE_NEXT_MULTI : TD_KEY_LE_PREV_MULTI;
 
+    m_impl->rc->reset();
     if (isUseTransactd())
-    {
-        m_impl->rc->reset();
         doFind(op, true /*notIncCurrent*/);
-    }
     else
     {
         if (op == TD_KEY_SEEK_MULTI)
@@ -991,10 +1016,13 @@ void table::find(eFindType type)
             // TD_KEY_SEEK_MULTI
             return;
         }
-        if (type == findForword)
-            seekGreater(true);
-        else
-            seekLessThan(true);
+        if (!isContinue)
+        {
+            if (type == findForword)
+                seekGreater(true);
+            else if (type == findBackForword)
+                seekLessThan(true);
+        }
         if (m_stat == 0)
         {
             if (type == findForword)
@@ -1556,7 +1584,7 @@ const blobHeader* table::getBlobHeader()
     return p;
 }
 
-void table::setBlobFieldPointer(char* ptr, const blobHeader* hd)
+unsigned char* table::setBlobFieldPointer(char* ptr, const blobHeader* hd, unsigned char* to)
 {
     if (hd)
     {
@@ -1567,14 +1595,25 @@ void table::setBlobFieldPointer(char* ptr, const blobHeader* hd)
             fielddef& fd = (*m_tableDef)->fieldDefs[f->fieldNum];
             char* fdptr = ptr + fd.pos;
             int sizeByte = fd.blobLenBytes();
+
+            //copy size byte
             memcpy(fdptr, &f->size, sizeByte);
             const char* data = f->data();
+            //copy data
+            if (to)
+            {
+                memcpy(to, data, f->size);
+                data = (char*)to;
+                to += f->size;
+            }
+            //copy address
             memcpy(fdptr + sizeByte, &data, sizeof(char*));
             f = f->next();
         }
         ++hd->curRow;
         hd->nextField = (blobField*)f;
     }
+    return to;
 }
 
 void table::onReadAfter()
@@ -2081,7 +2120,7 @@ struct impl
     impl()
         : m_reject(1), m_limit(0), m_joinKeySize(0),
           m_optimize(queryBase::none), m_direction(table::findForword),
-          m_nofilter(false), m_withBookmark(false)
+          m_nofilter(false), m_withBookmark(false), m_stopAtLimit(false)
     {
     }
 
@@ -2096,7 +2135,11 @@ struct impl
     queryBase::eOptimize m_optimize;
     table::eFindType m_direction;
     bool m_nofilter;
-    bool m_withBookmark;
+    struct
+    {
+        bool m_withBookmark : 1;
+        bool m_stopAtLimit : 1;
+    };
 };
 
 queryBase::queryBase() : m_impl(new impl)
@@ -2179,7 +2222,6 @@ void queryBase::addSeekKeyValue(const _TCHAR* value, bool reset)
         m_impl->m_keyValuesPtr.clear();
     }
     m_impl->m_keyValues.push_back(value);
-    // m_impl->m_reject = 1;
     m_impl->m_nofilter = false;
 }
 
@@ -2386,6 +2428,17 @@ bool queryBase::isAll() const
     return m_impl->m_nofilter;
 }
 
+bool queryBase::isStopAtLimit() const
+{
+    return m_impl->m_stopAtLimit;
+}
+
+queryBase& queryBase::stopAtLimit(bool v)
+{
+    m_impl->m_stopAtLimit = v;
+    return *this;
+}
+
 const std::vector<std::_tstring>& queryBase::getSelects() const
 {
     return m_impl->m_selects;

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

@@ -93,7 +93,8 @@ class DLLLIB table : public nstable
     bool checkIndex(short index) const;
     void getKeySpec(keySpec* ks, bool SpecifyKeyNum = false);
     const bzs::db::blobHeader* getBlobHeader();
-    void setBlobFieldPointer(char* ptr, const ::bzs::db::blobHeader* p);
+    unsigned char* setBlobFieldPointer(char* ptr, const ::bzs::db::blobHeader* p,
+                                        unsigned char* to=NULL);
     void addSendBlob(const bzs::db::blob* blob);
     void addBlobEndRow();
     void resetSendBlob();
@@ -111,7 +112,8 @@ class DLLLIB table : public nstable
     void btrvSeekMulti();
     bool doSeekMultiAfter(int row);
     void* doDdba(uint_td size);
-    bool recordsLoop(ushort_td& op);
+    bool isReadContinue(ushort_td& op);
+
 protected:
     explicit table(nsdatabase* pbe); // Inheritance is impossible
     virtual ~table();
@@ -167,10 +169,6 @@ public:
 
     bool logicalToString() const;
     void setLogicalToString(bool v);
-    bool trimPadChar() const;
-    void setTrimPadChar(bool v);
-    bool usePadChar() const;
-    void setUsePadChar(bool v);
     void* optionalData() const;
     void setOptionalData(void* v);
     bool myDateTimeValueByBtrv() const;
@@ -188,6 +186,8 @@ public:
     void findLast();
     void findNext(bool notIncCurrent = true);
     void findPrev(bool notIncCurrent = true);
+    short statReasonOfFind() const ;
+    eFindType lastFindDirection() const;
     bookmark_td bookmarkFindCurrent() const;
     pq_handle setQuery(const queryBase* query, bool serverPrepare=false);
     pq_handle prepare(const queryBase* query, bool serverPrepare=false)
@@ -340,7 +340,7 @@ public:
     queryBase& optimize(eOptimize v);
     queryBase& bookmarkAlso(bool v);
     queryBase& joinKeySize(int v);
-
+    queryBase& stopAtLimit(bool v);
     const _TCHAR* toString() const;
     table::eFindType getDirection() const;
     int getReject() const;
@@ -348,6 +348,7 @@ public:
     bool isAll() const;
     int getJoinKeySize() const;
     eOptimize getOptimize() const;
+    bool isStopAtLimit() const;
     bool isBookmarkAlso() const;
     short selectCount() const;
     const _TCHAR* getSelect(short index) const;

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

@@ -495,6 +495,25 @@ public:
     {
         return q.getDirection();
     }
+
+    template <class Any_Map_type>
+    activeObject& readMapMore(Any_Map_type& map)
+    {
+        mraResetter mras(m_tb);
+        map.init(m_option, m_fdi, m_map, m_tb, &m_alias);
+        m_tb->find(table::findContinue);
+        if (m_tb->lastFindDirection() == table::findForword)
+        {
+            findIterator itsf(*m_tb);
+            for_each(itsf, map);
+        }
+        else
+        {
+            findRvIterator itsf(*m_tb);
+            for_each(itsf, map);
+        }
+        return *this;
+    }
  
     template <class Any_Map_type , class Query>
     activeObject& readMap(Any_Map_type& map, Query& q)
@@ -520,7 +539,7 @@ public:
         return *this;
     }
 
-   template <class Any_Map_type, class Query>
+    template <class Any_Map_type, class Query>
     activeObject& readMap(Any_Map_type& map, Query& q, validationFunc func)
     {
         mraResetter mras(m_tb);
@@ -553,6 +572,19 @@ public:
         return readMap(map, q, func);
     }
 
+    activeObject& readMore(collection_vec_type& mdls)
+    {
+        mdlsHandler<MAP, collection_vec_type> map(mdls);
+        return readMapMore(map);
+    }
+
+    template <class Container>
+    activeObject& readMore(Container& mdls)
+    {
+        typename MAP::collection_orm_typename map(mdls);
+        return readMapMore(map);
+    }
+
     template <class Query> 
     activeObject& read(collection_vec_type& mdls, Query& q)
     {

data/source/bzs/db/protocol/tdap/fieldComp.h

@@ -93,7 +93,7 @@ inline int compareWvartype(const char* l, const char* r, bool bin, char logType)
                          tmp);
     else if (bin)
         tmp =
-            memcmp((char16_t*)(l + sizeof(T)), (char16_t*)(r + sizeof(T)), tmp);
+            wmemcmp16((char16_t*)(l + sizeof(T)), (char16_t*)(r + sizeof(T)), tmp);
     else
         tmp = wcsncmp16((char16_t*)(l + sizeof(T)), (char16_t*)(r + sizeof(T)),
                         tmp);

data/source/bzs/db/protocol/tdap/mysql/databaseSchema.cpp

@@ -194,6 +194,8 @@ short schemaBuilder::insertMetaRecord(table* mtb, table* src, int id)
             fd.type = convFieldType(src->fieldRealType(i), src->fieldFlags(i),
                                     isBinary(src->fieldCharset(i)),
                                     isUnicode(src->fieldCharset(i)));
+            bool usePadChar = ((fd.type == ft_mychar) || (fd.type == ft_mywchar)); 
+            fd.setPadCharSettings(usePadChar, true);
             fd.setCharsetIndex(charsetIndex(src->fieldCharset(i).csname));
             pos += fd.len;
             datalen =
@@ -230,7 +232,7 @@ short schemaBuilder::insertMetaRecord(table* mtb, table* src, int id)
                         isBinary(src->fieldCharset(i)),
                         isUnicode(src->fieldCharset(sg.fieldNum)))))
                     sg.flags.bitA =
-                        !(src->fieldFlags(sg.fieldNum) & BINCMP_FLAG);
+                        !(src->fieldFlags(sg.fieldNum) & BINARY_FLAG);// case in-sencitive
                 if (src->fieldDataLen(sg.fieldNum) != ks.length)
                 {
                     fielddef& fd = tdef.fieldDefs[sg.fieldNum];

data/source/bzs/db/protocol/tdap/mysql/recordsetReader.h

@@ -206,7 +206,7 @@ inline int compareWvartype(const char* l, const char* r, bool bin, char logType)
                          tmp);
     else if (bin)
         tmp =
-            memcmp((char16_t*)(l + sizeof(T)), (char16_t*)(r + sizeof(T)), tmp);
+            wmemcmp16((const char16_t*)(l + sizeof(T)), (const char16_t*)(r + sizeof(T)), tmp);
     else
         tmp = wcsncmp16((char16_t*)(l + sizeof(T)), (char16_t*)(r + sizeof(T)),
                         tmp);
@@ -365,10 +365,10 @@ public:
         case ft_wstring:
         case ft_wzstring:
             if (logType & CMPLOGICAL_CASEINSENSITIVE)
-                return wcsnicmp16((char16_t*)l, (char16_t*)r, len);
+                return wcsnicmp16((char16_t*)l, (char16_t*)r, len/sizeof(char16_t));
             if ((type == ft_wstring) || (type == ft_mywchar))
                 return memcmp(l, r, len);
-            return wcsncmp16((char16_t*)l, (char16_t*)r, len);
+            return wcsncmp16((char16_t*)l, (char16_t*)r, len/sizeof(char16_t));
         case ft_lstring:
         case ft_myvarchar:
         case ft_myvarbinary:
@@ -633,6 +633,16 @@ class fieldAdapter
     mutable bool m_judge : 1;
     mutable bool m_matched : 1;
     };
+#ifdef COMP_USE_FUNCTION_POINTER
+    void setWstringCompLen()
+    {
+        if ((m_compFunc == &logicalField::compiWString) ||
+            (m_compFunc == &logicalField::compWString))
+            const_cast<logicalField*>(m_fd)->len /= sizeof(char16_t);
+    }
+#else
+    void setWstringCompLen(){};
+#endif
 public:
     friend class fields;
 
@@ -659,6 +669,7 @@ public:
             const_cast<logicalField*>(fd)->opr &= ~FILTER_COMBINE_PREPARE;
 #ifdef COMP_USE_FUNCTION_POINTER
         m_compFunc = fd->getCompFunc(m_sizeBytes);
+        setWstringCompLen();
 #endif
         if (fd->opr == 2)
         {
@@ -678,7 +689,11 @@ public:
                     bool gt = (comp == eGreater) || (comp == eGreaterEq);
                     bool le = (comp == eLess) || (comp == eLessEq);
                     bool valid = !(forword ? gt : le);
-                    if (valid)
+                    
+                    // case in-sencitive, Index judge need clinet and server are same option.
+                    bool is_cl = ((fd->logType & CMPLOGICAL_CASEINSENSITIVE) != 0);
+                    bool is_srv = ((key->key_part[segmentIndex].field->flags & BINARY_FLAG) == 0);
+                    if (valid && (is_cl == is_srv))
                     {
                         m_keySeg = (unsigned char)segmentIndex + 1;
                         m_judgeType = (comp == eEqual) ? 2 : 1;
@@ -695,6 +710,7 @@ public:
     {
         const_cast<logicalField*>(p)->opr = opr;
         m_fd = p;
+        setWstringCompLen();
     }
 
     inline int checkNomore(bool typeNext, eCompType log) const

data/source/bzs/db/protocol/tdap/mysql/request.h

@@ -88,6 +88,13 @@ public:
 
         p += sizeof(unsigned int); // space of totalLen
 
+        //add posblk bookmark
+        if ((P_MASK_POSBLK & paramMask) && tb->cursor())
+        {
+            paramMask |= P_MASK_PB_BOOKMARK;
+            if (tb->isDelayAutoCommit())
+                paramMask |= P_MASK_PB_LOCKED;
+        }
         memcpy(p, (const char*)(&paramMask), sizeof(ushort_td));
         p += sizeof(ushort_td);
 
@@ -99,6 +106,13 @@ public:
         {
             memcpy(p, (const char*)pbk, TD_POSBLK_TRANSMIT_SIZE);
             p += TD_POSBLK_TRANSMIT_SIZE;
+            if (P_MASK_PB_BOOKMARK & paramMask)
+            {
+                uint v = tb->posPtrLenRaw();
+                memcpy(p++, &v, 1);
+                memcpy(p, tb->position(true), v);
+                p += v;
+            }
         }
 
         if (P_MASK_DATALEN & paramMask)