transactd 2.0.1 → 2.1.0

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

@@ -58,33 +58,33 @@ class indexNavi
 {
 
 public:
-    inline static void increment(table& tb)
+    inline static void increment(table& tb, ushort_td lockBias)
     {
-        tb.seekNext();
+        tb.seekNext(lockBias);
         readStatusCheck(tb, _T("Seek next"));
     }
 
-    inline static void decrement(table& tb)
+    inline static void decrement(table& tb, ushort_td lockBias)
     {
-        tb.seekPrev();
+        tb.seekPrev(lockBias);
         readStatusCheck(tb, _T("Seek prev"));
     }
 };
 
+
 class indexRvNavi
 {
 
 public:
-    inline static void increment(table& tb)
+    inline static void increment(table& tb, ushort_td lockBias)
     {
-        tb.seekPrev();
+        tb.seekPrev(lockBias);
         readStatusCheck(tb, _T("Seek next"));
     }
 
-    inline static void decrement(table& tb)
+    inline static void decrement(table& tb, ushort_td lockBias)
     {
-
-        tb.seekNext();
+        tb.seekNext(lockBias);
         readStatusCheck(tb, _T("Seek prev"));
     }
 };
@@ -93,13 +93,13 @@ class indexFindNavi
 {
 
 public:
-    inline static void increment(table& tb)
+    inline static void increment(table& tb, ushort_td /*lockBias*/)
     {
         tb.findNext();
         readStatusCheck(tb, _T("Find next"));
     }
 
-    inline static void decrement(table& tb)
+    inline static void decrement(table& tb, ushort_td /*lockBias*/)
     {
         tb.findPrev();
         readStatusCheck(tb, _T("Find prev"));
@@ -110,13 +110,13 @@ class indexRvFindNavi
 {
 
 public:
-    inline static void increment(table& tb)
+    inline static void increment(table& tb, ushort_td /*lockBias*/)
     {
         tb.findPrev();
         readStatusCheck(tb, _T("Find next"));
     }
 
-    inline static void decrement(table& tb)
+    inline static void decrement(table& tb, ushort_td /*lockBias*/)
     {
         tb.findNext();
         readStatusCheck(tb, _T("Find prev"));
@@ -127,30 +127,30 @@ class stepNavi
 {
 
 public:
-    inline static void increment(table& tb)
+    inline static void increment(table& tb, ushort_td lockBias)
     {
-        tb.stepNext();
+        tb.stepNext(lockBias);
         readStatusCheck(tb, _T("Step next"));
     }
-    inline static void decrement(table& tb)
+    inline static void decrement(table& tb, ushort_td lockBias)
     {
-        tb.stepPrev();
+        tb.stepPrev(lockBias);
         readStatusCheck(tb, _T("Step prev"));
     }
 };
 
 class stepRvNavi
 {
-
+   
 public:
-    inline static void increment(table& tb)
+    inline static void increment(table& tb, ushort_td lockBias)
     {
-        tb.stepPrev();
+        tb.stepPrev(lockBias);
         readStatusCheck(tb, _T("Step next"));
     }
-    inline static void decrement(table& tb)
+    inline static void decrement(table& tb, ushort_td lockBias)
     {
-        tb.stepNext();
+        tb.stepNext(lockBias);
         readStatusCheck(tb, _T("Step prev"));
     }
 };

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

@@ -22,6 +22,7 @@
 #include "fieldNameAlias.h"
 #include "memRecord.h"
 #include "groupComp.h"
+#include "filter.h"
 #include <boost/shared_array.hpp>
 #include <vector>
 
@@ -328,6 +329,11 @@ class activeObject : boost::noncopyable
     }
 
     void init(database* db, const _TCHAR* name) { m_tb = openTable(db, name); }
+    
+    void prepare(const pq_handle& q)
+    {
+        m_tb->setPrepare(q);
+    }
 
 protected:
     table_ptr m_tb;
@@ -480,18 +486,28 @@ public:
         return *this;
     }
 
-    template <class Any_Map_type>
-    activeObject& readMap(Any_Map_type& map, queryBase& q)
+    table::eFindType direction(const pq_handle& q)
+    {
+        return q->direction();
+    }
+
+    table::eFindType direction(const queryBase& q)
+    {
+        return q.getDirection();
+    }
+ 
+    template <class Any_Map_type , class Query>
+    activeObject& readMap(Any_Map_type& map, Query& q)
     {
         mraResetter mras(m_tb);
-        m_alias.reverseAliasNamesQuery(q);
-        m_tb->setQuery(&q);
+        prepare(q);
         if (m_tb->stat())
             nstable::throwError(_T("Query is inaccurate"), &(*m_tb));
 
         map.init(m_option, m_fdi, m_map, m_tb, &m_alias);
-        m_tb->find(q.getDirection());
-        if (q.getDirection() == table::findForword)
+        table::eFindType direc = direction(q);
+        m_tb->find(direc);
+        if (direc == table::findForword)
         {
             findIterator itsf(*m_tb);
             for_each(itsf, map);
@@ -504,18 +520,17 @@ public:
         return *this;
     }
 
-    template <class Any_Map_type>
-    activeObject& readMap(Any_Map_type& map, queryBase& q, validationFunc func)
+   template <class Any_Map_type, class Query>
+    activeObject& readMap(Any_Map_type& map, Query& q, validationFunc func)
     {
         mraResetter mras(m_tb);
-        m_alias.reverseAliasNamesQuery(q);
-
-        m_tb->setQuery(&q);
+        prepare(q);
         if (m_tb->stat())
             nstable::throwError(_T("Query is inaccurate"), &(*m_tb));
         map.init(m_option, m_fdi, m_map, m_tb, &m_alias);
-        m_tb->find(q.getDirection());
-        if (q.getDirection() == table::findForword)
+        table::eFindType direc = direction(q);
+        m_tb->find(direc);
+        if (direc == table::findForword)
         {
             findIterator itsf(*m_tb);
             filterdFindIterator it(itsf, func);
@@ -530,27 +545,30 @@ public:
         return *this;
     }
 
-    activeObject& read(collection_vec_type& mdls, queryBase& q,
+    template <class Query> 
+    activeObject& read(collection_vec_type& mdls, Query& q,
                        validationFunc func)
     {
         mdlsHandler<MAP, collection_vec_type> map(mdls);
         return readMap(map, q, func);
     }
 
-    activeObject& read(collection_vec_type& mdls, queryBase& q)
+    template <class Query> 
+    activeObject& read(collection_vec_type& mdls, Query& q)
     {
         mdlsHandler<MAP, collection_vec_type> map(mdls);
         return readMap(map, q);
     }
 
-    template <class Container> activeObject& read(Container& mdls, queryBase& q)
+    template <class Container, class Query> 
+    activeObject& read(Container& mdls, Query& q)
     {
         typename MAP::collection_orm_typename map(mdls);
         return readMap(map, q);
     }
 
-    template <class Container>
-    activeObject& read(Container& mdls, queryBase& q, validationFunc func)
+    template <class Container, class Query>
+    activeObject& read(Container& mdls, Query& q, validationFunc func)
     {
         typename MAP::collection_orm_typename map(mdls);
         return readMap(map, q, func);
@@ -802,6 +820,13 @@ public:
         m_alias.clear();
         return *this;
     }
+
+    pq_handle prepare(queryBase& q, bool serverPrepare=false)
+    {
+        m_alias.reverseAliasNamesQuery(q);  
+        return m_tb->prepare(&q, serverPrepare);
+    }
+
 };
 
 } // namespace client

data/source/bzs/db/protocol/tdap/client/trnsctcl.def

@@ -2,9 +2,9 @@
 
 EXPORTS
    BTRCALLID	@1
-   BTRCALL		@2
-   BTRVID		@3
-   BTRV			@4
+   BTRCALL	@2
+   BTRVID	@3
+   BTRV		@4
    BTRCALLID32	@5
    BTRCALL32	@6
    CallbackRegist @7

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

@@ -16,6 +16,7 @@
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
    02111-1307, USA.
 =================================================================*/
+#include <my_config.h>
 #include <boost/filesystem.hpp>
 #include <boost/shared_array.hpp>
 #include <bzs/db/engine/mysql/database.h>

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

@@ -59,7 +59,6 @@ public:
     inline char* fieldPtr(const resultField* rf) const;
     inline bool isBlobField(const resultField* rf) const;
     inline void addBlobBuffer(int fieldNum) { m_tb->addBlobBuffer(fieldNum); };
-    inline void setBlobFieldCount(int v) { m_tb->setBlobFieldCount(v); };
     inline unsigned short packLen(const resultField* rf) const;
     inline const char* record() const { return m_record; }
     inline ulong recordLenCl() const { return m_tb->recordLenCl(); }
@@ -82,9 +81,9 @@ public:
     {
         return m_tb->fieldSizeByte(fieldNum);
     }
-    inline ushort fieldPackCopy(unsigned char* dest, short filedNum)
+    inline ushort fieldPackCopy(unsigned char* dest, short fieldNum)
     {
-        return m_tb->fieldPackCopy(dest, filedNum);
+        return m_tb->fieldPackCopy(dest, fieldNum);
     }
 };
 
@@ -106,6 +105,11 @@ struct extResultDef
     unsigned short maxRows;
     unsigned short fieldCount;
     resultField field[1]; // variable
+
+    int memSize() const
+    {
+        return 4 + (sizeof(resultField) * fieldCount);
+    }
 };
 
 inline position::position() : m_tb(NULL), m_record(NULL){};
@@ -446,7 +450,7 @@ public:
         return compareBlobType(l, r, type == ft_myblob, logType, sizeByte);
     }
 
-    compFunc getCompFunc(int sizeByte)
+    compFunc getCompFunc(int sizeByte) const
     {
         switch (type)
         {
@@ -540,7 +544,7 @@ public:
 #endif
     extResultDef* resultDef() const
     {
-        if (opr == 0)
+        if ((opr == 0) || (opr == FILTER_COMBINE_PREPARE))
             return (extResultDef*)next();
         return next()->resultDef();
     }
@@ -550,7 +554,11 @@ struct extRequest
 {
     int ilen : 28;
     int itype : 4;
-    unsigned short rejectCount;
+    union
+    {
+        unsigned short rejectCount;
+        unsigned short preparedId;
+    };
     unsigned short logicalCount;
     logicalField field;
 
@@ -564,8 +572,8 @@ struct extRequest
 
 struct extRequestSeeks
 {
-    int ilen : 28;
-    int itype : 4;
+    unsigned int ilen : 28;
+    unsigned int itype : 4;
     unsigned short rejectCount;
     unsigned short logicalCount;
     seek seekData;
@@ -609,33 +617,46 @@ bool isMatch6(int v)
 class fields;
 class fieldAdapter
 {
-    logicalField* m_fd;
+    const logicalField* m_fd;
     fieldAdapter* m_next;
     bool (*m_isMatchFunc)(int);
 #ifdef COMP_USE_FUNCTION_POINTER
     compFunc m_compFunc;
 #endif
+    unsigned short m_placeHolderNum;
     unsigned char m_keySeg;
-    mutable bool m_judge;
     char m_judgeType;
     char m_sizeBytes;
-    mutable bool m_matched;
-
+    char opr;
+    struct
+    {
+    mutable bool m_judge : 1;
+    mutable bool m_matched : 1;
+    };
 public:
     friend class fields;
-    fieldAdapter()
-        : m_keySeg(0xff), m_judge(false), m_judgeType(0), m_sizeBytes(0),
-          m_matched(false)
+
+    void reset()
     {
+        m_keySeg = 0xff;
+        m_judgeType = 0;
+        m_sizeBytes = 0;
+        m_judge = false;
+        m_matched = false;
+        m_placeHolderNum = 0;
     }
 
-    int init(logicalField* fd, position& position, const KEY* key, bool forword)
+    int init(const logicalField* fd, position& position, const KEY* key, bool forword)
     {
+        reset();
         m_fd = fd;
         int num = position.getFieldNumByPos(fd->pos);
         if (num == -1)
             return STATUS_INVALID_FIELD_OFFSET;
         m_sizeBytes = (char)position.fieldSizeByte(num);
+        m_placeHolderNum = fd->opr & FILTER_COMBINE_PREPARE;// temporary marking
+        if (m_placeHolderNum)
+            const_cast<logicalField*>(fd)->opr &= ~FILTER_COMBINE_PREPARE;
 #ifdef COMP_USE_FUNCTION_POINTER
         m_compFunc = fd->getCompFunc(m_sizeBytes);
 #endif
@@ -670,6 +691,12 @@ public:
         return 0;
     }
 
+    inline void supplyValue(const logicalField* p)
+    {
+        const_cast<logicalField*>(p)->opr = opr;
+        m_fd = p;
+    }
+
     inline int checkNomore(bool typeNext, eCompType log) const
     {
         if (m_judge)
@@ -720,30 +747,32 @@ public:
             return this < &r; // no change order
         return m_keySeg < r.m_keySeg;
     }
+    void oprCache() { opr = m_fd->opr; }
 };
 
 class fields
 {
-    fieldAdapter* m_fields;
+    std::vector<fieldAdapter> m_fields;
 
 public:
-    fields() : m_fields(NULL){};
-
-    ~fields() { delete[] m_fields; }
 
-    void init(extRequest& req, position& position, const KEY* key, bool forword)
+    void init(const extRequest& req, position& position, const KEY* key, bool forword)
     {
         if (req.logicalCount == 0)
-            return;
+            return ;
 
-        logicalField* fd = &req.field;
-        delete[] m_fields;
-        m_fields = new fieldAdapter[req.logicalCount];
+        const logicalField* fd = &req.field;
+        if (m_fields.size() != req.logicalCount)
+            m_fields.resize(req.logicalCount);
         int lastIndex = req.logicalCount;
+
         for (int i = 0; i < req.logicalCount; ++i)
         {
             fieldAdapter& fda = m_fields[i];
             fda.init(fd, position, key, forword);
+
+            fda.m_placeHolderNum = i;
+            
             eCompType log = (eCompType)(fd->logType & 0xF);
             switch (log)
             {
@@ -773,14 +802,16 @@ public:
         }
         if (key)
         {
-            fieldAdapter* begin = &m_fields[0], *cur = &m_fields[0],
-                          *end = &m_fields[lastIndex];
+            std::vector<fieldAdapter>::iterator begin = m_fields.begin();
+            std::vector<fieldAdapter>::iterator cur = m_fields.begin();
+            std::vector<fieldAdapter>::iterator end = begin + lastIndex;
+
             char tmpOpr = (lastIndex != req.logicalCount) ? end->m_fd->opr : 0;
             std::sort(begin, end);
             bool flag = true;
             while (cur != end)
             {
-                cur->m_fd->opr = 1; // and
+                const_cast<logicalField*>(cur->m_fd)->opr = 1; // and
                 if (flag && cur->m_judgeType == 2)
                     cur->m_judge = true;
                 else
@@ -794,7 +825,7 @@ public:
 
             if (lastIndex == req.logicalCount)
                 --end;
-            end->m_fd->opr = tmpOpr;
+            const_cast<logicalField*>(end->m_fd)->opr = tmpOpr;
         }
         for (int i = 0; i < req.logicalCount - 1; ++i)
             m_fields[i].m_next = &m_fields[i + 1];
@@ -804,12 +835,103 @@ public:
     {
         return m_fields[0].match(record, typeNext);
     }
+
+    bool setSupplyValues(const extRequest& req)
+    {
+        const logicalField* fd = &req.field;
+        for (int i = 0; i < req.logicalCount; ++i)
+        {
+            for (int j=0;j<(int)m_fields.size();++j)
+            {
+                fieldAdapter& fa = m_fields[j];
+                if (fa.m_placeHolderNum == i)
+                {
+                    fa.supplyValue(fd);
+                    break;
+                }
+            }
+            fd = fd->next();
+        }
+        return true;
+    }
+
+    void setNextPtr()
+    {
+        for (int i = 0; i < (int)m_fields.size() - 1; ++i)
+        {
+            m_fields[i].m_next = &m_fields[i + 1];
+            m_fields[i].oprCache();
+        }
+        m_fields[m_fields.size() - 1].oprCache(); 
+    }
+    
+};
+
+
+class prepared : public engine::mysql::IPrepare
+{
+public:
+    fields* fds;
+    extResultDef* rd;
+    unsigned char* readMap;
+    int  blobs;
+    unsigned short rejectCount;
+    int readMapSize;
+    prepared() : fds(NULL), rd(NULL), readMap(NULL), readMapSize(0){}
+
+    ~prepared()
+    {
+        if (fds)
+            delete fds;
+        if (readMap)
+            delete [] readMap;
+        if (rd)
+            free(rd);
+    }
+
+    void copyBitmapTo(MY_BITMAP* bm)
+    {
+        if (readMap)
+            memcpy(bm->bitmap, readMap, readMapSize);
+    }
+
+    void assignBitmap(MY_BITMAP* bm)
+    {
+        if (bm)
+        {
+            assert(readMap == NULL);
+            readMapSize = ((bm->n_bits + 7)/ 8);
+            readMap = new unsigned char[readMapSize];
+            memcpy(readMap, (unsigned char*)bm->bitmap, readMapSize);
+        }
+    }
+
+    void assignResultDef(const extResultDef* src)
+    {
+        assert(rd == NULL);
+        rd = (extResultDef*)malloc(src->memSize());
+        memcpy(rd, src, src->memSize());
+    }
+
+    void assignFields(const fields* src)
+    {
+        assert(fds == NULL);
+        fds = new fields();
+        *(fds) = *src;
+        fds->setNextPtr();
+        
+    }
+    
+    void release()
+    {
+        delete this;
+    }
 };
 
 class resultWriter
 {
     netsvc::server::netWriter* m_nw;
-    extResultDef* m_def;
+    const extResultDef* m_def;
     bool m_noBookmark;
 
     short doWrite(position* pos, unsigned int bookmark)
@@ -846,7 +968,7 @@ class resultWriter
                 // write each fields by field num.
                 for (int i = 0; i < m_def->fieldCount; i++)
                 {
-                    resultField& fd = m_def->field[i];
+                    const resultField& fd = m_def->field[i];
                     if (m_nw->bufferSpace() > fd.len)
                     {
                         uint len = pos->fieldPackCopy(
@@ -872,16 +994,20 @@ class resultWriter
     }
 
 public:
-    resultWriter(netsvc::server::netWriter* nw, extResultDef* def,
+
+    void init(netsvc::server::netWriter* nw, const extResultDef* def,
                  bool noBookmark)
-        : m_nw(nw), m_def(def), m_noBookmark(noBookmark)
     {
+         m_nw = nw;
+         m_def = def;
+         m_noBookmark = noBookmark;
     }
 
     short write(position* pos, unsigned int bookmark)
     {
         return doWrite(pos, bookmark);
     }
+
     inline unsigned int end()
     {
         m_nw->asyncWrite(NULL, 0, netsvc::server::netWriter::writeEnd);
@@ -889,61 +1015,140 @@ public:
     }
 
     const char* resultBuffer() { return m_nw->ptr(); }
+
 };
 
 class ReadRecordsHandler : public engine::mysql::IReadRecordsHandler
 {
-    boost::shared_ptr<resultWriter> m_writer;
-    extRequest* m_req;
-    extResultDef* m_resultDef;
+    resultWriter m_writer;
+    const extRequest* m_req;
     position m_position;
-    fields m_fields;
+    fields* m_fields;
+    fields* m_defaultFields;
     engine::mysql::fieldBitmap bm;
+    unsigned short m_maxRows;
     bool m_seeksMode;
 
 public:
-    short begin(engine::mysql::table* tb, extRequest* req, bool fieldCache,
-                netsvc::server::netWriter* nw, bool forword, bool noBookmark,
-                bool seeksMode)
+    ReadRecordsHandler():m_defaultFields(new fields())
+    {
+         
+    }
+
+    ~ReadRecordsHandler()
+    {
+        delete m_defaultFields;
+    }
+
+    short beginPreparExecute(engine::mysql::table* tb, const extRequest* req, bool fieldCache,
+                netsvc::server::netWriter* nw, bool noBookmark, prepared* p)
+    {
+        m_seeksMode = !fieldCache;
+        m_position.setTable(tb);
+        m_req = req;
+        m_fields = p->fds;
+        const_cast<extRequest*>(m_req)->rejectCount = p->rejectCount;
+        if (!m_seeksMode)
+        {
+            if (!m_fields->setSupplyValues(*req))
+                return STATUS_INVALID_SUPPLYVALUES;
+        }
+
+        if(p->readMapSize)
+        {
+            bm.setTable(tb);
+            if (m_seeksMode)
+                addKeysegFieldMap(tb);
+            if (p->readMapSize)
+                p->copyBitmapTo(bm.getReadBitmap());
+        }
+        
+        tb->indexInit();
+        tb->blobBuffer()->clear();
+        tb->setBlobFieldCount(p->blobs);
+        nw->beginExt(tb->blobFields() != 0);
+        const extResultDef* rd = p->rd;
+        m_writer.init(nw, rd, noBookmark);
+        m_maxRows = p->rd->maxRows;
+        return 0;
+    }
+
+    short prepare(engine::mysql::table* tb, const extRequest* req, bool fieldCache,
+                netsvc::server::netWriter* nw, bool forword, bool noBookmark, prepared* p)
+    {
+        // Important! cache resultdef first.
+        const extResultDef* srcRd = req->resultDef();
+
+        short ret = begin(tb, req, fieldCache, nw, forword, noBookmark);
+        p->assignResultDef(srcRd);
+        p->assignFields(m_fields);
+        if (bm.isUsing())
+             p->assignBitmap(bm.getReadBitmap());
+        p->blobs = tb->getBlobFieldCount();
+        p->rejectCount = m_req->rejectCount;
+        end();
+        return ret;
+    }
+    
+    short begin(engine::mysql::table* tb, const extRequest* req, bool fieldCache,
+                netsvc::server::netWriter* nw, bool forword, bool noBookmark)
     {
         short ret = 0;
-        m_seeksMode = seeksMode;
+        m_seeksMode = !fieldCache;
         m_position.setTable(tb);
         m_req = req;
-        m_resultDef = seeksMode ? ((extRequestSeeks*)m_req)->resultDef()
+        m_fields = m_defaultFields;
+        const extResultDef* rd = m_seeksMode ? ((extRequestSeeks*)m_req)->resultDef()
                                 : m_req->resultDef();
         if (fieldCache)
         {
             const KEY* key = NULL;
             if (tb->keyNum() >= 0)
                 key = &tb->keyDef(tb->keyNum());
-            m_fields.init(*m_req, m_position, key, forword);
+            m_fields->init(*m_req, m_position, key, forword);
         }
-        if ((m_resultDef->fieldCount > 1) ||
-            ((m_resultDef->fieldCount == 1) &&
-             (m_resultDef->field[0].len < m_position.recordLenCl())))
-            ret = convResultPosToFieldNum(tb, noBookmark, seeksMode);
+        if ((rd->fieldCount > 1) ||
+            ((rd->fieldCount == 1) &&
+             (rd->field[0].len < m_position.recordLenCl())))
+            ret = convResultPosToFieldNum(tb, noBookmark, rd, m_seeksMode);
 
         nw->beginExt(tb->blobFields() != 0);
-        m_writer.reset(new resultWriter(nw, m_resultDef, noBookmark));
+        m_writer.init(nw, rd, noBookmark);
+        m_maxRows = rd->maxRows; 
         // DEBUG_RECORDS_BEGIN(m_resultDef, m_req)
 
         return ret;
     }
 
+    void addKeysegFieldMap(engine::mysql::table* tb)
+    {
+        const KEY* key = &tb->keyDef(tb->keyNum());
+        if (key)
+        {
+            int sgi = 0;
+            int segments = std::min<uint>(MAX_KEY_SEGMENT,
+                                            key->user_defined_key_parts);
+            while (sgi < segments)
+            {
+                bm.setReadBitmap(key->key_part[sgi].field->field_index);
+                ++sgi;
+            }
+        }
+    }
+
     // TODO This convert is move to client. but legacy app is need this
     short convResultPosToFieldNum(engine::mysql::table* tb, bool noBookmark,
-                                  bool seeksMode)
+                                  const extResultDef* rd, bool seeksMode)
     {
         int blobs = 0;
         bm.setTable(tb);
-        for (int i = 0; i < m_resultDef->fieldCount; i++)
+        for (int i = 0; i < rd->fieldCount; i++)
         {
-            resultField& fd = m_resultDef->field[i];
+            const resultField& fd = rd->field[i];
             int num = m_position.getFieldNumByPos(fd.pos);
             if (num == -1)
                 return STATUS_INVALID_FIELD_OFFSET;
-            fd.fieldNum = num;
+            const_cast<resultField&>(fd).fieldNum = num;
             bm.setReadBitmap(num);
             if (m_position.isBlobField(&fd))
                 ++blobs;
@@ -951,7 +1156,7 @@ public:
 
         if (!seeksMode)
         {
-            logicalField* fd = &m_req->field;
+            const logicalField* fd = &m_req->field;
             for (int i = 0; i < m_req->logicalCount; ++i)
             {
                 bm.setReadBitmap(m_position.getFieldNumByPos(fd->pos));
@@ -959,20 +1164,7 @@ public:
             }
         }
         else
-        {
-            const KEY* key = &tb->keyDef(tb->keyNum());
-            if (key)
-            {
-                int sgi = 0;
-                int segments = std::min<uint>(MAX_KEY_SEGMENT,
-                                              key->user_defined_key_parts);
-                while (sgi < segments)
-                {
-                    bm.setReadBitmap(key->key_part[sgi].field->field_index);
-                    ++sgi;
-                }
-            }
-        }
+            addKeysegFieldMap(tb);
 
         // if need bookmark , add primary key fields
         if (!noBookmark)
@@ -992,15 +1184,15 @@ public:
         }
 
         tb->indexInit();
-        m_position.setBlobFieldCount(blobs);
+        tb->blobBuffer()->clear();
+        tb->setBlobFieldCount(blobs);
         return 0;
     }
 
     unsigned int end()
     {
-        unsigned int len = m_writer->end();
+        unsigned int len = m_writer.end();
         // DEBUG_RECORDS_END(m_writer.get())
-        m_writer.reset();
         bm.setTable(NULL);
         return len;
     }
@@ -1008,7 +1200,7 @@ public:
     int match(bool typeNext) const
     {
         if (m_req->logicalCount)
-            return m_fields.match(m_position.record(), typeNext);
+            return m_fields->match(m_position.record(), typeNext);
         return REC_MACTH;
     }
 
@@ -1022,7 +1214,7 @@ public:
         if (bmPtr == NULL)
         {
             // bookmark = stat;
-            return m_writer->write(NULL, bookmark);
+            return m_writer.write(NULL, bookmark);
         }
         else
         {
@@ -1040,12 +1232,14 @@ public:
             case 1:
                 bookmark = *((unsigned short*)bmPtr) & 0x0FF;
                 break;
+            default:
+                break;
             }
-            return m_writer->write(&m_position, bookmark);
+            return m_writer.write(&m_position, bookmark);
         }
     }
     unsigned short rejectCount() const { return m_req->rejectCount; };
-    unsigned short maxRows() const { return m_resultDef->maxRows; };
+    unsigned short maxRows() const { return m_maxRows; };
 };
 
 } // namespace mysql