transactd 1.0.1

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

@@ -0,0 +1,2613 @@
+/* =================================================================
+ Copyright (C) 2000-2013 BizStation Corp All rights reserved.
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+ ================================================================= */
+#include <bzs/env/tstring.h>
+#pragma hdrstop
+
+#include "table.h"
+#include "filter.h"
+#include "database.h"
+#include "bulkInsert.h"
+#include "stringConverter.h"
+#include <bzs/rtl/strtrim.h>
+#include <bzs/rtl/stringBuffers.h>
+#include <bzs/db/protocol/tdap/myDateTime.cpp>
+#include <bzs/db/blobStructs.h>
+#include <vector>
+#include <algorithm>
+#include <boost/timer.hpp>
+#include <boost/shared_array.hpp>
+
+#pragma package(smart_init)
+
+#ifdef __BCPLUSPLUS__
+#define _strupr strupr
+#endif
+
+using namespace bzs::db;
+using namespace bzs::rtl;
+using namespace bzs::db::protocol::tdap;
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+namespace client
+{
+
+#ifdef _WIN32
+#ifdef _INICODE
+#define EXEC_CODEPAGE CP_UTF16
+#else
+#define EXEC_CODEPAGE GetACP()
+#endif
+#else
+#define EXEC_CODEPAGE CP_UTF8
+#endif
+
+#define BOOKMARK_ALLOC_SIZE 40960
+#define BOOKMARK_SIZE 4
+#define DATASIZE_BYTE 2
+
+class CFiledNameIndex
+{
+
+public:
+    CFiledNameIndex(short i, std::_tstring n);
+    bool operator < (const CFiledNameIndex& rt) const ;
+
+    short index;
+
+    std::_tstring name;
+};
+
+class recordCache;
+
+
+struct tbimpl
+{
+    stringConverter* cv;
+    void* bookMarks;
+    filter* filterPtr;
+    recordCache* rc;
+    void* dataBak;
+    void* smartUpDate;
+    void* bfAtcPtr;
+	void* optionalData;
+    int bookMarksMemSize;
+    int maxBookMarkedCount;
+    char keybuf[MAX_KEYLEN];
+    char exNext;
+    char keyNumIndex[128];
+    short exSlideStat;
+
+    struct
+    {
+    unsigned char exBookMarking : 1;
+    unsigned char myDateTimeValueByBtrv: 1;
+    unsigned char trimPadChar: 1;
+    unsigned char usePadChar: 1;
+    unsigned char smartUpDateFlag: 1;
+    unsigned char logicalToString: 1;
+    unsigned char dataPacked: 1;
+    };
+
+    std::vector<boost::shared_array<char> >blobs;
+    ::bzs::rtl::stringBuffer strBufs;
+    std::vector<CFiledNameIndex>fields;
+
+    tbimpl() : strBufs(4096), bookMarks(NULL),bfAtcPtr(NULL), maxBookMarkedCount(0), bookMarksMemSize(0),
+        filterPtr(NULL), rc(NULL), dataBak(NULL), optionalData(NULL),myDateTimeValueByBtrv(true), trimPadChar(true),
+        usePadChar(true), smartUpDate(NULL), smartUpDateFlag(false)
+        , logicalToString(false),dataPacked(false)
+    {
+        memset(&keyNumIndex[0], 0, 128);
+
+    }
+
+    ~tbimpl()
+    {
+
+        if (dataBak)
+            free(dataBak);
+        if (smartUpDate)
+            free(smartUpDate);
+        if (bookMarks)
+            free(bookMarks);
+
+        delete filterPtr;
+    }
+};
+
+// ---------------------------------------------------------------------------
+// class recordCache
+// ---------------------------------------------------------------------------
+
+unsigned int hash(const char *s, int len)
+{
+    unsigned int h = 0;
+    for (int i = 0; i < len; i++)
+        h = h * 137 + *(s + i);
+    return h % 1987;
+}
+
+class recordCache
+{
+    table* m_tb;
+    filter* m_pFilter;
+    unsigned int m_row;
+    unsigned int m_len;
+    unsigned int m_unpackLen;
+    unsigned int m_rowCount;
+    bookmark_td m_bookmark;
+    char* m_ptr;
+    char* m_tmpPtr;
+    blobHeader* m_hd;
+
+public:
+    inline recordCache(table* tb) : m_tb(tb) {reset();}
+
+    inline void reset()
+    {
+        m_pFilter = NULL;
+        m_row = 0;
+        m_rowCount = 0;
+        m_ptr = NULL;
+        m_len = 0;
+        m_tmpPtr = NULL;
+    }
+
+    inline void reset(filter* p, char* data, unsigned int totalSize, const blobHeader* hd)
+    {
+        m_pFilter = p;
+        m_row = 0;
+        m_rowCount = *((unsigned short*)data);
+        m_ptr = data + DATASIZE_BYTE;
+        m_len = m_unpackLen = *((unsigned short*)m_ptr); // Not include bookmark and size bytes.
+        m_ptr += DATASIZE_BYTE;
+        m_bookmark = *((bookmark_td*)(m_ptr));
+        m_ptr += BOOKMARK_SIZE;
+        m_tmpPtr = data + totalSize;
+        m_hd = const_cast<blobHeader*>(hd);
+    }
+
+    inline const char* moveRow(int count)
+    {
+        for (int i = 0; i < count; i++)
+        {
+            m_ptr += m_len;
+            m_len = m_unpackLen = *((unsigned short*)m_ptr);
+            m_ptr += DATASIZE_BYTE;
+            m_bookmark = *((bookmark_td*)(m_ptr));
+            m_ptr += BOOKMARK_SIZE;
+
+            if (m_hd)
+            {
+                m_hd->nextField = (blobField*)m_hd->nextField->next();
+                ++m_hd->curRow;
+            }
+        }
+        m_tb->m_impl->strBufs.clear();
+        if (m_pFilter->fieldSelected())
+        {
+            int offset = 0;
+            memset(m_tmpPtr, 0, m_len);
+            for (int i = 0; i < m_pFilter->fieldCount(); i++)
+            {
+                memcpy((char*)m_tmpPtr + m_pFilter->fieldOffset(i), m_ptr + offset,
+                    m_pFilter->fieldLen(i));
+                offset += m_pFilter->fieldLen(i);
+            }
+            m_tb->setBlobFieldPointer(m_tmpPtr, m_hd);
+            return m_tmpPtr;
+        }
+        else if (m_tb->valiableFormatType())
+        {
+            memcpy(m_tmpPtr, m_ptr, m_len);
+            m_unpackLen = m_tb->unPack((char*)m_tmpPtr, m_len);
+            m_tb->setBlobFieldPointer(m_tmpPtr, m_hd);
+            return m_tmpPtr;
+        }
+        else
+        {
+            m_tb->setBlobFieldPointer(m_ptr, m_hd);
+            return m_ptr;
+        }
+    }
+
+    inline const char* setRow(unsigned int rowNum)
+    {
+        if (rowNum < m_rowCount)
+        {
+            unsigned int moveCount = rowNum - m_row;
+            m_row = rowNum;
+            return moveRow(moveCount);
+        }
+        return NULL;
+    }
+
+    inline unsigned int len() const {return m_unpackLen;};
+    inline bookmark_td bookmarkCurRow() const {return m_bookmark;};
+    inline int row() const {return m_row;}
+
+    inline int rowCount() const {return m_rowCount;}
+    inline bool isEndOfRow(unsigned int row) const {return  (m_rowCount && (row == m_rowCount));}
+	inline bool withinCache(unsigned int row) const {return (row < m_rowCount);}
+};
+
+// ---------------------------------------------------------------------------
+// class CFiledNameIndex
+// ---------------------------------------------------------------------------
+CFiledNameIndex::CFiledNameIndex(short i, std::_tstring n) : index(i), name(n)
+{
+
+}
+
+bool CFiledNameIndex:: operator < (const CFiledNameIndex& rt) const
+{
+    return name < rt.name;
+};
+
+
+inline __int64 getValue64(const fielddef& fd, const uchar_td* ptr)
+{
+    __int64 ret = 0;
+    switch (fd.type)
+    {
+    case ft_integer:
+    case ft_autoinc:
+        switch (fd.len)
+        {
+        case 1: ret = *((char*)(ptr + fd.pos));
+            break;
+        case 2: ret = *((short*)(ptr + fd.pos));
+            break;
+        case 4: ret = *((int*)(ptr + fd.pos));
+            break;
+        case 8: ret = *((__int64*)(ptr + fd.pos));
+            break;
+        }
+    case ft_uinteger:
+    case ft_logical:
+    case ft_bit:
+    case ft_currency:
+    case ft_date:
+    case ft_time:
+    case ft_timestamp:
+    case ft_mydate:
+    case ft_mytime:
+    case ft_mydatetime:
+    case ft_mytimestamp:
+        switch (fd.len)
+        {
+        case 1: ret = *((unsigned char*)(ptr + fd.pos));
+            break;
+        case 2: ret = *((unsigned short*)(ptr + fd.pos));
+            break;
+        case 4: ret = *((unsigned int*)(ptr + fd.pos));
+            break;
+        case 3:
+        case 5:
+        case 6:
+        case 7: memcpy(&ret, ptr + fd.pos, fd.len);
+            break;
+        case 8: ret = *((__int64*)(ptr + fd.pos));
+            break;
+        }
+    }
+    return ret;
+}
+
+inline void setValue(const fielddef& fd, uchar_td* ptr, __int64 value)
+{
+    switch (fd.type)
+    {
+    case ft_integer:
+    case ft_autoinc:
+        {
+            switch (fd.len)
+            {
+            case 1: *((char*)(ptr + fd.pos)) = (char)value;
+                break;
+            case 2: *((short*)(ptr + fd.pos)) = (short)value;
+                break;
+            case 4: *((int*)(ptr + fd.pos)) = (int)value;
+                break;
+            case 8: *((__int64*)(ptr + fd.pos)) = (int)value;
+                break;
+            }
+        }
+    case ft_uinteger:
+    case ft_logical:
+    case ft_bit:
+    case ft_currency:
+    case ft_date:
+    case ft_time:
+    case ft_timestamp:
+    case ft_mytime:
+    case ft_mydate:
+    case ft_mydatetime:
+    case ft_mytimestamp: memcpy(ptr + fd.pos, &value, fd.len);
+        break;
+    }
+}
+
+
+
+
+
+table::table(nsdatabase *pbe) : nstable(pbe)
+{
+    m_impl = new tbimpl();
+
+    m_impl->cv = new stringConverter(nsdatabase::execCodePage(), nsdatabase::execCodePage());
+
+    m_impl->rc = new recordCache(this);
+
+    m_keybuflen = MAX_KEYLEN;
+    m_pdata = NULL;
+    m_keybuf = &m_impl->keybuf[0];
+    m_keynum = 0;
+
+}
+
+table::~table()
+{
+    delete m_impl->rc;
+    delete m_impl->cv;
+    delete m_impl;
+
+}
+
+inline uchar_td table::charset() const {return m_tableDef->charsetIndex;};
+
+bool table::trimPadChar() const {return m_impl->trimPadChar;}
+
+void table::setTrimPadChar(bool v) {m_impl->trimPadChar = v;}
+
+bool table::usePadChar() const {return m_impl->usePadChar;};
+
+void table::setUsePadChar(bool v) {m_impl->usePadChar = v;};
+
+void* table::dataBak() const {return m_impl->dataBak;};
+
+void table::setDataBak(void* v) {m_impl->dataBak = v;};
+
+void* table::optionalData() const {return m_impl->optionalData;}
+
+void table::setOptionalData(void* v) {m_impl->optionalData = v;}
+
+bool table::myDateTimeValueByBtrv() const {return m_impl->myDateTimeValueByBtrv;}
+
+bool table::logicalToString() const {return m_impl->logicalToString;};
+
+void table::setLogicalToString(bool v) {m_impl->logicalToString = v;}
+
+void table::setBookMarks(int StartId, void* Data, ushort_td Count)
+{
+    long size = (StartId + Count) * 6;
+    if (m_impl->bookMarksMemSize < size)
+    {
+
+        m_impl->bookMarks = realloc(m_impl->bookMarks, size + BOOKMARK_ALLOC_SIZE);
+        m_impl->bookMarksMemSize = size + BOOKMARK_ALLOC_SIZE;
+    }
+    if (m_impl->bookMarks)
+    {
+        if (StartId + Count - 1 > m_impl->maxBookMarkedCount)
+            m_impl->maxBookMarkedCount = StartId + Count - 1;
+        memcpy((void*)((char*)m_impl->bookMarks + ((StartId - 1) * 6)), Data, Count * 6);
+    }
+    else
+        m_stat = STATUS_CANT_ALLOC_MEMORY;
+    return;
+
+}
+
+inline short calcNextReadRecordCount(ushort_td curCount, int eTime)
+{
+    ushort_td ret = curCount;
+    if (eTime == 0)
+        ret = (ushort_td)(curCount * (short)2);
+    else
+        ret = (ushort_td)(curCount * ((float)100 / (float)eTime));
+
+    if (ret > 10000)
+        return 10000;
+    if (ret == 0)
+        return 1;
+    return ret;
+}
+
+uint_td table::doRecordCount(bool estimate, bool fromCurrent)
+{
+    uint_td result = 0;
+
+    if (m_impl->filterPtr)
+    {
+        short curStat = m_stat;
+        m_impl->exBookMarking = true;
+        ushort_td recCountOnce = 50;
+
+        bookmark_td bm = bookmark();
+        ushort_td tmpFieldCount = m_impl->filterPtr->fieldCount();
+        ushort_td tmpRejectCount = m_impl->filterPtr->rejectCount();
+        ushort_td tmpRecCount = m_impl->filterPtr->recordCount();
+        _TCHAR* str = new _TCHAR[_tcslen(filterStr()) + 1];
+        if (str)
+        {
+            _tcscpy(str, filterStr());
+            m_impl->filterPtr->setFieldCount(0);
+            m_stat = 0;
+            m_impl->filterPtr->setFilter(str, tmpRejectCount, 10000);
+            if (m_stat != 0)
+            {
+                // restore filter string
+                m_impl->filterPtr->setFieldCount(tmpFieldCount);
+                m_impl->filterPtr->setFilter(str, tmpRejectCount, tmpRecCount);
+                delete[]str;
+                str = NULL;
+            }
+        }
+        else
+            assert(0);
+        m_impl->maxBookMarkedCount = 0;
+        if (fromCurrent)
+            m_stat = curStat;
+        else
+            seekFirst();
+
+        *(m_impl->filterPtr->recordCountDirect()) = recCountOnce;
+        if (m_stat == 0)
+        {
+            m_impl->filterPtr->setPosTypeNext(false);
+            boost::timer t;
+            btrvGetExtend(TD_KEY_NEXT_MULTI);
+            int eTime = (int)(t.elapsed() * 1000);
+            while ((m_stat == 0) || (m_stat == STATUS_LIMMIT_OF_REJECT) || (m_stat == STATUS_EOF)
+                        || (m_stat == STATUS_REACHED_FILTER_COND))
+            {
+                bool Complete = false;
+                if ((m_stat == STATUS_EOF) || (m_stat == STATUS_REACHED_FILTER_COND))
+                {
+                    Complete = true;
+                    m_stat = STATUS_EOF;
+                }
+                else if (m_stat == STATUS_LIMMIT_OF_REJECT)
+                {
+                    if (tmpRejectCount != 0)
+                    {
+                        if (tmpRejectCount == 1)
+                            m_stat = STATUS_EOF;
+                        Complete = true;
+                    }
+                }
+                recCountOnce = calcNextReadRecordCount(recCountOnce, eTime);
+
+                *(m_impl->filterPtr->recordCountDirect()) = recCountOnce;
+                result += *((ushort_td*)m_impl->dataBak);
+                setBookMarks(m_impl->maxBookMarkedCount + 1, (void*)((char*)m_impl->dataBak + 2),
+                    *((ushort_td*)m_impl->dataBak));
+                m_impl->maxBookMarkedCount = result;
+
+                onRecordCounting(result, Complete);
+                if (Complete)
+                    break;
+                t.restart();
+                m_impl->filterPtr->setPosTypeNext(true);
+                btrvGetExtend(TD_KEY_NEXT_MULTI);
+                eTime = (int)(t.elapsed() * 1000);
+            }
+        }
+        short tmpStat = m_stat;
+        if (str)
+        {
+            setFilter(str, tmpRejectCount, tmpRecCount);
+            delete[]str;
+        }
+        if (bm)
+            seekByBookmark(bm);
+        m_impl->exBookMarking = false;
+        m_stat = tmpStat;
+    }
+    else
+        return nstable::doRecordCount(estimate, fromCurrent);
+
+    return result;
+}
+
+void table::btrvGetExtend(ushort_td op)
+{
+
+    if (op >= TD_KEY_GE_NEXT_MULTI)
+        m_keylen = writeKeyData();
+    m_pdata = m_impl->dataBak;
+    m_impl->filterPtr->WriteBuffer();
+    m_datalen = m_impl->filterPtr->exDataBufLen();
+    tdap(op);
+    short stat = m_stat;
+    m_impl->rc->reset(m_impl->filterPtr, (char*)m_impl->dataBak, m_datalen, blobFieldUsed() ?
+        getBlobHeader() : NULL);
+
+    m_stat = stat;
+    m_impl->exSlideStat = m_stat;
+    //There is the right record.
+    if (m_impl->rc->rowCount() && (!m_impl->exBookMarking))
+    {
+        m_pdata = (void*)m_impl->rc->setRow(0);
+        m_datalen = m_impl->rc->len();
+
+        m_stat = STATUS_SUCCESS;
+    }else if ((m_stat == STATUS_LIMMIT_OF_REJECT) && (m_impl->filterPtr->rejectCount()>=1))
+        m_stat = STATUS_EOF;
+
+
+}
+
+void table::getRecords(ushort_td op)
+{
+    do
+    {
+        btrvGetExtend(op);
+        m_impl->filterPtr->setPosTypeNext(true);
+
+    }while (m_stat == STATUS_LIMMIT_OF_REJECT && (m_impl->filterPtr->rejectCount()==0));
+    if ((m_stat == STATUS_REACHED_FILTER_COND) || (m_stat == STATUS_LIMMIT_OF_REJECT))
+        m_stat = STATUS_EOF;
+}
+
+bookmark_td table::bookmarkFindCurrent() const
+{
+
+    if (!m_impl->rc->isEndOfRow(m_impl->rc->row()))
+        return m_impl->rc->bookmarkCurRow();
+    return 0;
+
+}
+
+void table::find(eFindType type)
+{
+    if (nsdb()->isUseTransactd())
+    {
+        m_impl->rc->reset();
+        ushort_td op = (type == findForword) ? TD_KEY_GE_NEXT_MULTI:TD_KEY_LE_PREV_MULTI;
+        doFind(op, true/*notIncCurrent*/);
+    }
+    else
+    {
+        if (type == findForword)
+            seekGreater(true);
+        else
+            seekLessThan(true);
+        if (m_stat == 0)
+        {
+            if (type == findForword)
+                findNext(true);
+            else
+                findPrev(true);
+        }
+    }
+
+
+}
+
+void table::findFirst()
+{
+    seekFirst();
+    if (m_stat == 0)
+    {
+        if (m_impl->filterPtr)
+        {
+            m_impl->exNext = 1;
+            m_impl->filterPtr->setPosTypeNext(false);
+            getRecords(TD_KEY_NEXT_MULTI);
+        }
+    }
+}
+
+void table::findLast()
+{
+    seekLast();
+    if (m_stat == 0)
+    {
+        if (m_impl->filterPtr)
+        {
+            m_impl->exNext = -1;
+            m_impl->filterPtr->setPosTypeNext(false);
+            getRecords(TD_KEY_PREV_MULTI);
+        }
+    }
+}
+
+void table::doFind( ushort_td op, bool notIncCurrent)
+{
+        /*
+        First, read from cache.
+        If whole row readed from cache then select operation by m_impl->exSlideStat
+
+        */
+        m_stat = 0;
+        int row = m_impl->rc->row() + 1;
+
+        if (m_impl->rc->withinCache(row) && (!m_impl->exBookMarking))
+        {   /* read from cache */
+            m_pdata = (void*)m_impl->rc->setRow(row);
+            m_datalen = m_impl->rc->len();
+        }
+        else if (m_impl->rc->isEndOfRow(row))
+        {
+            /* whole row readed */
+            /* A special situation that if rejectCount() == 0 and status = STATUS_LIMMIT_OF_REJECT
+                then it continues . */
+            if ((m_impl->exSlideStat == 0)
+                || ((m_impl->exSlideStat == STATUS_LIMMIT_OF_REJECT)
+                            && (m_impl->filterPtr->rejectCount() == 0)))
+            {
+                getRecords(op);
+                return;
+            }
+            if ((m_impl->exSlideStat == STATUS_LIMMIT_OF_REJECT) ||
+                    (m_impl->exSlideStat == STATUS_REACHED_FILTER_COND))
+                    m_stat = STATUS_EOF;
+            else
+                m_stat = m_impl->exSlideStat;
+             m_impl->exSlideStat = 0;
+        }
+        else
+        {
+            m_impl->exNext = ((op == TD_KEY_NEXT_MULTI) || (op == TD_KEY_GE_NEXT_MULTI)) ? 1: -1;
+            m_impl->filterPtr->setPosTypeNext(notIncCurrent);
+            getRecords(op);
+        }
+
+}
+
+void table::findNext(bool notIncCurrent)
+{
+
+    if (m_impl->filterPtr)
+        doFind(TD_KEY_NEXT_MULTI, notIncCurrent);
+    else if (notIncCurrent == true)
+        seekNext();
+}
+
+void table::findPrev(bool notIncCurrent)
+{
+    if (m_impl->filterPtr)
+        doFind(TD_KEY_PREV_MULTI, notIncCurrent);
+    else if (notIncCurrent == true)
+        seekPrev();
+
+}
+
+void table::setFilter(const _TCHAR* str, ushort_td RejectCount, ushort_td CashCount)
+{
+
+    m_stat = 0;
+    m_pdata = m_impl->dataBak;
+    m_impl->rc->reset();
+    m_impl->exBookMarking = false;
+    m_impl->exSlideStat = 0;
+    m_impl->exNext = 0;
+    if (str[0] == 0x00)
+    {
+        m_impl->maxBookMarkedCount = 0;
+        delete m_impl->filterPtr;
+        m_impl->filterPtr = NULL;
+        return;
+    }
+    if (m_impl->filterPtr)
+        m_impl->filterPtr->init(this);
+    else
+        m_impl->filterPtr = new filter(this);
+    if (m_impl->filterPtr == NULL)
+    {
+        m_stat = STATUS_CANT_ALLOC_MEMORY;
+        return;
+
+    }
+    if (!m_impl->filterPtr->setFilter(str, RejectCount, CashCount))
+    {
+        m_stat = STATUS_FILTERSTRING_ERROR;
+        delete m_impl->filterPtr;
+        m_impl->filterPtr = NULL;
+        return;
+    }
+    if (!m_impl->bookMarks)
+    {
+        m_impl->bookMarks = malloc(40960);
+        if (m_impl->bookMarks)
+            m_impl->bookMarksMemSize = 40960;
+        else
+        {
+            m_stat = STATUS_FILTERSTRING_ERROR;
+            delete m_impl->filterPtr;
+            m_impl->filterPtr = NULL;
+        }
+    }
+}
+
+const _TCHAR* table::filterStr()
+{
+    if (m_impl->filterPtr)
+        return m_impl->filterPtr->filterStr();
+    else
+        return NULL;
+}
+
+void table::clearBuffer()
+{
+    memset(m_pdata, 0x00, m_buflen);
+    if (blobFieldUsed())
+        resetSendBlob();
+
+}
+
+void table::getKeySpec(keySpec* ks, bool SpecifyKeyNum)
+{
+    keydef* KeyDef;
+    short FieldNum;
+    int j;
+
+    KeyDef = &m_tableDef->keyDefs[m_keynum];
+    for (j = 0; j < KeyDef->segmentCount; j++)
+    {
+        FieldNum = KeyDef->segments[j].fieldNum;
+        ks[j].keyPos = (ushort_td)(m_tableDef->fieldDefs[FieldNum].pos + 1);
+        ks[j].keyLen = m_tableDef->fieldDefs[FieldNum].len;
+        ks[j].keyFlag.all = KeyDef->segments[j].flags.all;
+        ks[j].keyCount = 0;
+        ks[j].keyType = m_tableDef->fieldDefs[FieldNum].type;
+
+        if (ks[j].keyFlag.bit3 == true)
+            ks[j].nullValue = m_tableDef->fieldDefs[FieldNum].nullValue;
+        else
+            ks[j].nullValue = 0;
+        ks[j].reserve2[0] = 0;
+        ks[j].reserve2[1] = 0;
+
+        if (SpecifyKeyNum == true)
+            ks[j].keyNo = m_keynum;
+        else
+            ks[j].keyNo = 0;
+
+        ks[j].acsNo = 0;
+    }
+}
+
+void table::doCreateIndex(bool SpecifyKeyNum)
+{
+    int segmentCount = m_tableDef->keyDefs[m_keynum].segmentCount;
+    keySpec* ks = new keySpec[segmentCount];
+    getKeySpec(ks, SpecifyKeyNum);
+    m_pdata = ks;
+    m_datalen = sizeof(keySpec) * segmentCount;
+    nstable::doCreateIndex(SpecifyKeyNum);
+    m_pdata = m_impl->dataBak;
+    delete[]ks;
+}
+
+void table::smartUpdate()
+{ 
+    if (!m_impl->smartUpDate)
+        m_impl->smartUpDate = malloc(m_buflen);
+    if (m_impl->smartUpDate)
+    {
+        memcpy(m_impl->smartUpDate, data(), m_buflen);
+        m_impl->smartUpDateFlag = true;
+    }
+    else
+        m_impl->smartUpDateFlag = false;
+}
+
+bool table::isUniqeKey(char_td keynum)
+{
+    if ((keynum>=0) && (keynum < m_tableDef->keyCount))
+    {
+        keydef* kd = &m_tableDef->keyDefs[m_keynum];
+        return !(kd->segments[0].flags.bit0);
+    }
+    return false;
+}
+
+bool table::onUpdateCheck(eUpdateType type)
+{
+    //Check uniqe key
+    if (type == changeInKey)
+    {
+        if (!isUniqeKey(m_keynum))
+        {
+            m_stat = STATUS_INVALID_KEYNUM;
+            return false;
+        }else
+        {
+            if (nsdb()->isUseTransactd()==false)
+            {
+                //backup update data
+                smartUpdate();
+                seek();
+                m_impl->smartUpDateFlag = false;
+                if (m_stat)
+                    return false;
+                memcpy(m_pdata, m_impl->smartUpDate, m_datalen);
+            }
+        }
+    }
+    else if (m_impl->smartUpDateFlag)
+    {
+        m_stat = 0;
+        if (memcmp(m_impl->smartUpDate, data(), m_buflen) == 0)
+        {
+            m_impl->smartUpDateFlag = false;
+            return false;
+        }
+    }
+    return true;
+}
+
+void table::onUpdateAfter(int beforeResult)
+{
+    if (blobFieldUsed())
+        resetSendBlob();
+    if (valiableFormatType() && m_impl->dataPacked)
+        m_datalen = unPack((char*)m_pdata, m_datalen);
+
+}
+
+bool table::onDeleteCheck(bool inkey)
+{
+    client::database *db = static_cast<client::database*>(nsdb());
+    deleteRecordFn func = db->onDeleteRecord();
+	if (func)
+	{
+		if (func(db, this, inkey))
+		{
+			m_stat = STATUS_CANT_DEL_FOR_REL;
+			return false;
+		}
+	}
+    return true;
+}
+
+ushort_td table::doCommitBulkInsert(bool autoCommit)
+{
+    ushort_td ret = nstable::doCommitBulkInsert(autoCommit);
+    if (blobFieldUsed())
+        resetSendBlob();
+    return ret;
+}
+
+void table::onInsertAfter(int beforeResult)
+{
+    if (valiableFormatType() && m_impl->dataPacked)
+        m_datalen = unPack((char*)m_pdata, m_datalen);
+    if (blobFieldUsed())
+        resetSendBlob();
+}
+
+void* table::attachBuffer(void* NewPtr, bool unpack, size_t size)
+{
+    void* oldptr;
+    if (!m_impl->bfAtcPtr)
+        m_impl->bfAtcPtr = m_pdata;
+    oldptr = m_pdata;
+    m_pdata = NewPtr;
+    ushort_td len = recordLength();
+    if (len < m_tableDef->maxRecordLen)
+        len = m_tableDef->maxRecordLen;
+    if (unpack)
+		len = unPack((char*)m_pdata, size);
+	m_datalen = len;
+    return oldptr;
+}
+
+void table::dettachBuffer()
+{
+    if (m_impl->bfAtcPtr)
+        m_pdata = m_impl->bfAtcPtr;
+    m_impl->bfAtcPtr = NULL;
+
+}
+
+void table::init(tabledef* Def, short fnum, bool regularDir) {doInit(Def, fnum, regularDir);}
+
+void table::doInit(tabledef* Def, short fnum, bool /*regularDir*/)
+{
+    m_tableDef = Def;
+    ushort_td len;
+
+    m_impl->cv->setCodePage(mysql::codePage(m_tableDef->charsetIndex));
+
+    if ((len = recordLength()) < m_tableDef->maxRecordLen)
+        len = m_tableDef->maxRecordLen;
+
+    if (len == 0)
+    {
+        m_stat = STATUS_INVALID_RECLEN;
+        return;
+    }
+
+    for (short i = 0; i < m_tableDef->keyCount; i++)
+    {
+        if (m_tableDef->flags.bitA == true)
+            m_impl->keyNumIndex[m_tableDef->keyDefs[i].keyNumber] = (char)i;
+        else
+            m_impl->keyNumIndex[i] = (char)i;
+    }
+    if (m_impl->dataBak)
+        free(m_impl->dataBak);
+    m_impl->dataBak = (void*) malloc(len);
+
+    if (m_impl->dataBak == NULL)
+    {
+        if (m_impl->dataBak)
+            free(m_impl->dataBak);
+        m_impl->dataBak = NULL;
+        m_stat = STATUS_CANT_ALLOC_MEMORY;
+        return;
+    }
+    m_pdata = m_impl->dataBak;
+    m_buflen = len;
+    m_datalen = len;
+    setTableid(fnum);
+
+}
+
+keylen_td table::writeKeyData()
+{
+    if (m_tableDef->keyCount)
+    {
+        keydef& keydef = m_tableDef->keyDefs[(short)m_impl->keyNumIndex[m_keynum]];
+        uchar_td* to = (uchar_td*)m_impl->keybuf;
+
+        for (int j = 0; j < keydef.segmentCount; j++)
+        {
+            int fdnum = keydef.segments[j].fieldNum;
+            fielddef& fd = m_tableDef->fieldDefs[fdnum];
+            uchar_td* from = (uchar_td*)m_pdata + fd.pos;
+            to = fd.keyCopy(to, from);
+        }
+        return (keylen_td)(to - (uchar_td*)m_impl->keybuf);
+    }
+    return 0;
+}
+
+uint_td table::pack(char*ptr, size_t size)
+{
+    char* pos = ptr;
+    char* end = pos + size;
+    int movelen;
+    for (int i = 0; i < m_tableDef->fieldCount; i++)
+    {
+        fielddef& fd = m_tableDef->fieldDefs[i];
+        int blen = fd.varLenBytes();
+        int dl = fd.len; // length
+        if (blen == 1)
+            dl = *((unsigned char*)(pos)) + blen;
+        else if (blen == 2)
+            dl = *((unsigned short*)(pos)) + blen;
+        pos += dl;
+        if ((movelen = fd.len - dl) != 0)
+        {
+            end -= movelen;
+            memmove(pos, pos + movelen, end - pos);
+        }
+    }
+    m_impl->dataPacked  = true;
+    return (uint_td)(pos - ptr);
+}
+
+uint_td table::doGetWriteImageLen()
+{
+    if (!blobFieldUsed() && !valiableFormatType() && (m_tableDef->flags.bit0 == false))
+        return m_buflen;
+    // Make blob pointer list
+    if (blobFieldUsed())
+    {
+        for (ushort_td i = 0; i < m_tableDef->fieldCount; i++)
+        {
+            fielddef& fd = m_tableDef->fieldDefs[i];
+            uint_td bytes = fd.blobLenBytes();
+            if (bytes)
+            {
+                uchar_td* fdptr = (uchar_td*)m_pdata + fd.pos;
+                blob b(fd.blobDataLen(fdptr), i, fd.blobDataPtr(fdptr));
+                addSendBlob(&b);
+            }
+        }
+        addBlobEndRow(); // end row
+    }
+    else
+        addSendBlob(NULL);
+
+    if (valiableFormatType())
+        return pack((char*)m_pdata, m_buflen);
+    else
+    {
+        fielddef* FieldDef = &m_tableDef->fieldDefs[m_tableDef->fieldCount - 1];
+        size_t len = 0;
+        short* pos;
+
+        if (FieldDef->type == ft_note)
+            len = strlen((char*)fieldPtr((short)(m_tableDef->fieldCount - 1))) + 1;
+        else if (FieldDef->type == ft_lvar)
+        {
+            // xx................xx.............00
+            // ln--data----------ln-----data----00
+            pos = (short*)fieldPtr((short)(m_tableDef->fieldCount - 1));
+            while (*pos)
+            {
+                len += 2; // size
+                len += *pos;
+                pos = (short*)((char*)pos + (*pos + 2)); // next position
+
+            }
+            len += 2;
+        }
+        else
+            len = FieldDef->len;
+
+        len += FieldDef->pos;
+
+        return (uint_td)len;
+    }
+}
+
+uint_td table::unPack(char* ptr, size_t size)
+{
+    char* pos = ptr;
+    const char* end = pos + size;
+    const char* max = pos + m_buflen;
+    int movelen;
+    for (int i = 0; i < m_tableDef->fieldCount; i++)
+    {
+        fielddef& fd = m_tableDef->fieldDefs[i];
+        int blen = fd.varLenBytes();
+        int dl = fd.len; // length
+        if (blen == 1)
+            dl = *((unsigned char*)(pos)) + blen;
+        else if (blen == 2)
+            dl = *((unsigned short*)(pos)) + blen;
+        if ((movelen = fd.len - dl) != 0)
+        {
+            if (max < end + movelen)
+                return 0;
+            const char* src = pos + dl;
+            memmove(pos + fd.len, src, end - src);
+            end += movelen;
+        }
+        pos += fd.len;
+    }
+    m_impl->dataPacked  = false;
+    return (uint_td)(pos - ptr);
+}
+
+void table::addBlobEndRow()
+{
+    char_td knum = m_keynum;
+    m_keynum = TD_ASBLOB_ENDROW;
+    addSendBlob(NULL);
+    m_keynum = knum;
+}
+
+void table::resetSendBlob()
+{
+    addSendBlob(NULL);
+    m_impl->blobs.clear();
+
+}
+
+void table::addSendBlob(const blob* blob)
+{
+    short stat = m_stat;
+    const void *tmp = data();
+    setData((void*)blob);
+    tdap(TD_ADD_SENDBLOB);
+    setData((void*)tmp);
+    m_stat = stat;
+}
+
+const blobHeader* table::getBlobHeader()
+{
+    short stat = m_stat;
+    const blobHeader* p;
+    const void *tmp = data();
+    setData(&p);
+    tdap(TD_GET_BLOB_BUF);
+    setData((void*)tmp);
+    std::swap(stat, m_stat);
+
+    if (stat)
+        return NULL;
+    return p;
+
+}
+
+void table::setBlobFieldPointer(char* ptr, const blobHeader* hd)
+{
+    if (hd)
+    {
+        assert(hd->curRow < hd->rows);
+        const blobField* f = hd->nextField;
+        for (int i = 0; i < hd->fieldCount; i++)
+        {
+            fielddef& fd = m_tableDef->fieldDefs[f->fieldNum];
+            char* fdptr = ptr + fd.pos;
+            int sizeByte = fd.blobLenBytes();
+            memcpy(fdptr, &f->size, sizeByte);
+            const char* data = f->data();
+            memcpy(fdptr + sizeByte, &data, sizeof(char*));
+            f = f->next();
+        }
+        ++hd->curRow;
+        hd->nextField = (blobField*)f;
+    }
+
+}
+
+void table::onReadAfter()
+{
+    m_impl->strBufs.clear();
+    if (valiableFormatType())
+    {
+        m_datalen = unPack((char*)m_pdata, m_datalen);
+        if (m_datalen == 0)
+            m_stat = 22;
+    }
+    if (blobFieldUsed())
+    {
+        const blobHeader* hd = getBlobHeader();
+        setBlobFieldPointer((char*)m_pdata, hd);
+    }
+    if (m_buflen - m_datalen > 0)
+        memset((char*)m_pdata + m_datalen, 0, m_buflen - m_datalen);
+
+}
+
+short table::fieldNumByName(const _TCHAR* name)
+{
+    short i=0;
+    if (name == 0) return i;
+    if (m_impl->fields.size() == 0)
+    {
+#ifdef _UNICODE
+        wchar_t buf[74];
+        for (i = 0; i < m_tableDef->fieldCount; i++)
+            m_impl->fields.push_back(CFiledNameIndex(i, m_tableDef->fieldDefs[i].name(buf)));
+#else
+        for (i = 0; i < m_tableDef->fieldCount; i++)
+            m_impl->fields.push_back(CFiledNameIndex(i, m_tableDef->fieldDefs[i].name()));
+#endif
+
+        sort(m_impl->fields.begin(), m_impl->fields.end());
+    }
+    if (binary_search(m_impl->fields.begin(), m_impl->fields.end(), CFiledNameIndex(0, name)))
+    {
+        std::vector<CFiledNameIndex>::iterator p;
+        p = lower_bound(m_impl->fields.begin(), m_impl->fields.end(), CFiledNameIndex(0, name));
+        return m_impl->fields[p - m_impl->fields.begin()].index;
+    }
+
+    return -1;
+}
+
+void* table::fieldPtr(short index)
+{
+    if (checkIndex(index) == false)
+        return NULL;
+    return (void*)((char*) m_pdata + m_tableDef->fieldDefs[index].pos);
+}
+
+void table::setFVA(short index, const char* data)
+{
+
+    __int64 value;
+    double fltValue;
+    if (checkIndex(index) == false)
+        return;
+    fielddef& fd = m_tableDef->fieldDefs[index];
+
+    char* p = (char*)m_pdata + fd.pos;
+    if (data == NULL)
+    {
+        memset(p, 0, fd.len);
+        return;
+    }
+
+    switch (fd.type)
+    {
+    case ft_string:
+        return store<stringStore, char, char>(p, data, fd, m_impl->cv, m_impl->usePadChar);
+    case ft_note:
+    case ft_zstring: return store<zstringStore, char, char>(p, data, fd, m_impl->cv);
+    case ft_wzstring: return store<wzstringStore, WCHAR, char>(p, data, fd, m_impl->cv);
+    case ft_wstring:
+        return store<wstringStore, WCHAR, char>(p, data, fd, m_impl->cv, m_impl->usePadChar);
+    case ft_mychar: return store<myCharStore, char, char>(p, data, fd, m_impl->cv);
+    case ft_myvarchar: return store<myVarCharStore, char, char>(p, data, fd, m_impl->cv);
+    case ft_lstring:
+    case ft_myvarbinary: return store<myVarBinaryStore, char, char>(p, data, fd, m_impl->cv);
+    case ft_mywchar: return store<myWcharStore, WCHAR, char>(p, data, fd, m_impl->cv);
+    case ft_mywvarchar: return store<myWvarCharStore, WCHAR, char>(p, data, fd, m_impl->cv);
+    case ft_mywvarbinary: return store<myWvarBinaryStore, WCHAR, char>(p, data, fd, m_impl->cv);
+    case ft_myblob:
+    case ft_mytext:
+        {
+            char* tmp = blobStore<char>(p, data, fd, m_impl->cv);
+            m_impl->blobs.push_back(boost::shared_array<char>(tmp));
+            return;
+        }
+    case ft_decimal:
+    case ft_money:
+    case ft_numeric:
+    case ft_bfloat:
+    case ft_numericsts:
+    case ft_numericsa:
+    case ft_currency: // currecy
+    case ft_float:    // float double
+        fltValue = atof(data);
+        setFV(index, fltValue);
+        return;
+    case ft_lvar: // Lvar
+        return;
+
+    case ft_date: // date mm/dd/yy
+        value = /*StrToBtrDate*/atobtrd((const char*) data).i;
+        break;
+    case ft_time: // time hh:nn:ss
+        value = /*StrToBtrTime*/atobtrt((const char*)data).i;
+        break;
+    case ft_uinteger:
+    case ft_integer:
+    case ft_autoinc:
+    case ft_bit: value = _atoi64(data);
+        break;
+    case ft_logical:
+        if (m_impl->logicalToString)
+        {
+            char tmp[5];
+            strncpy(tmp, data, 5);
+            if (strcmp(_strupr(tmp), "YES") == 0)
+                value = 1;
+            else
+                value = 0;
+        }
+        else
+            value = atol(data);
+        break;
+    case ft_timestamp:
+    case ft_mytimestamp: value = 0;
+        break;
+    case ft_mydate:
+        {
+            myDate d;
+            d = data;
+            value = d.getValue();
+            break;
+        }
+    case ft_mytime:
+        {
+            myTime t(fd.len);
+            t = data;
+            value = t.getValue();
+            break;
+        }
+
+    case ft_mydatetime:
+        {
+            myDateTime t(fd.len);
+            t = data;
+            value = t.getValue();
+            break;
+        }
+    default: return;
+    }
+    setValue(fd, (uchar_td*)m_pdata, value);
+}
+
+#ifdef _WIN32
+
+void table::setFVW(short index, const wchar_t* data)
+{
+
+    int value;
+    double fltValue;
+    if (checkIndex(index) == false)
+        return;
+    fielddef& fd = m_tableDef->fieldDefs[index];
+
+    char* p = (char*)m_pdata + fd.pos;
+    if (data == NULL)
+    {
+        memset(p, 0, fd.len);
+        return;
+    }
+
+    switch (fd.type)
+    {
+    case ft_string:
+        return store<stringStore, char, WCHAR>(p, data, fd, m_impl->cv, m_impl->usePadChar);
+    case ft_note:
+    case ft_zstring: return store<zstringStore, char, WCHAR>(p, data, fd, m_impl->cv);
+    case ft_wzstring: return store<wzstringStore, WCHAR, WCHAR>(p, data, fd, m_impl->cv);
+    case ft_wstring:
+        return store<wstringStore, WCHAR, WCHAR>(p, data, fd, m_impl->cv, m_impl->usePadChar);
+    case ft_mychar: return store<myCharStore, char, WCHAR>(p, data, fd, m_impl->cv);
+    case ft_myvarchar: return store<myVarCharStore, char, WCHAR>(p, data, fd, m_impl->cv);
+    case ft_lstring:
+    case ft_myvarbinary: return store<myVarBinaryStore, char, WCHAR>(p, data, fd, m_impl->cv);
+    case ft_mywchar: return store<myWcharStore, WCHAR, WCHAR>(p, data, fd, m_impl->cv);
+    case ft_mywvarchar: return store<myWvarCharStore, WCHAR, WCHAR>(p, data, fd, m_impl->cv);
+    case ft_mywvarbinary: return store<myWvarBinaryStore, WCHAR, WCHAR>(p, data, fd, m_impl->cv);
+    case ft_myblob:
+    case ft_mytext:
+        {
+            char* tmp = blobStore<WCHAR>(p, data, fd, m_impl->cv);
+            m_impl->blobs.push_back(boost::shared_array<char>(tmp));
+            return;
+        }
+
+    case ft_date: // date mm/dd/yy
+        value = /*StrToBtrDate*/atobtrd(data).i;
+        setFV(index, value);
+        break;
+    case ft_time: // time hh:nn:ss
+        value = /*StrToBtrTime*/atobtrt(data).i;
+        setFV(index, value);
+        return;
+
+    case ft_uinteger:
+    case ft_integer:
+    case ft_autoinc:
+    case ft_bit:
+        {
+            __int64 v = _wtoi64(data);
+            setFV(index, v);
+            break;
+        }
+    case ft_logical:
+        if (m_impl->logicalToString)
+        {
+            wchar_t tmp[5];
+            wcsncpy(tmp, data, 5);
+
+            if (wcscmp(_wcsupr(tmp), L"YES") == 0)
+                value = 1;
+            else
+                value = 0;
+        }
+        else
+            value = _wtol(data);
+        setFV(index, value);
+        break;
+
+    case ft_decimal:
+    case ft_money:
+    case ft_numeric:
+    case ft_bfloat:
+    case ft_numericsts:
+    case ft_numericsa:
+    case ft_currency:
+    case ft_float: fltValue = _wtof(data);
+        setFV(index, fltValue);
+        break;
+    case ft_timestamp:
+        {
+            __int64 v = 0;
+            setFV(index, v);
+            return;
+        }
+    case ft_mydate:
+        {
+            myDate d;
+            d = data;
+            setValue(fd, (uchar_td *)m_pdata, d.getValue());
+            return;
+        }
+    case ft_mytime:
+        {
+            myTime t(fd.len);
+            t = data;
+            setValue(fd, (uchar_td*)m_pdata, t.getValue());
+            return;
+        }
+    case ft_mydatetime:
+        {
+            myDateTime t(fd.len);
+            t = data;
+            setFV(index, t.getValue());
+            return;
+        }
+    case ft_mytimestamp:
+    case ft_lvar: break;
+    }
+
+}
+
+void table::setFVW(const _TCHAR* FieldName, const wchar_t* data)
+{
+    short index = fieldNumByName(FieldName);
+    setFVW(index, data);
+}
+
+#endif //_WIN32
+
+void table::setFV(short index, unsigned char data)
+{
+    int value = (long)data;
+    setFV(index, value);
+}
+
+void table::setFV(short index, int data)
+{
+    char buf[20];
+    double d;
+    if (checkIndex(index) == false)
+        return;
+    int v = data;
+    fielddef& fd = m_tableDef->fieldDefs[index];
+    switch (fd.type)
+    {
+
+    case ft_mydate:
+        {
+            myDate myd;
+            myd.setValue(data, m_impl->myDateTimeValueByBtrv);
+            setValue(fd, (uchar_td*)m_pdata, myd.getValue());
+            break;
+        }
+    case ft_mytime:
+        {
+            myTime myt(fd.len);
+            myt.setValue(data, m_impl->myDateTimeValueByBtrv);
+            setValue(fd, (uchar_td*)m_pdata, myt.getValue());
+            break;
+        }
+    case ft_integer:
+    case ft_date:
+    case ft_time:
+    case ft_uinteger:
+    case ft_logical:
+    case ft_autoinc:
+    case ft_bit:
+    case ft_mydatetime:
+        switch (m_tableDef->fieldDefs[index].len)
+        {
+        case 1: *((char*)((char*)m_pdata + fd.pos)) = (char) v;
+            break;
+        case 2: *((short*)((char*)m_pdata + fd.pos)) = (short)v;
+            break;
+        case 3: memcpy((char*)m_pdata + fd.pos, &v, 3);
+            break;
+        case 4: *((int*)((char*)m_pdata + fd.pos)) = v;
+            break;
+        case 8: *((__int64*)((char*)m_pdata + fd.pos)) = v;
+            break;
+        }
+        break;
+
+    case ft_timestamp:
+        {
+            __int64 v = 0;
+            setFV(index, v);
+            return;
+        }
+    case ft_decimal:
+    case ft_money:
+    case ft_numeric:
+    case ft_bfloat:
+    case ft_numericsts:
+    case ft_numericsa:
+
+    case ft_currency:
+    case ft_float: d = (double)data;
+        setFV(index, d);
+        break;
+    case ft_string:
+    case ft_zstring:
+    case ft_note:
+    case ft_myvarbinary:
+    case ft_myvarchar:
+    case ft_mychar:
+        if (data == 0)
+            setFVA(index, "");
+        else
+        {
+            _ltoa_s(data, buf, 20, 10);
+            setFVA(index, buf);
+        }
+        break;
+    case ft_mywvarbinary:
+    case ft_mywvarchar:
+    case ft_mywchar:
+    case ft_wstring:
+    case ft_wzstring:
+        {
+            if (data == 0)
+                setFV(index, _T(""));
+            else
+            {
+                _TCHAR buf[30];
+                _ltot_s(data, buf, 30, 10);
+                setFV(index, buf);
+            }
+            break;
+        }
+    case ft_lvar: break;
+
+    }
+}
+
+void table::setFV(short index, double data)
+{
+    char buf[20];
+    __int64 i64;
+    if (checkIndex(index) == false)
+        return;
+
+    switch (m_tableDef->fieldDefs[index].type)
+    {
+    case ft_currency: // currency
+        i64 = (__int64)(data * 10000 + 0.5);
+        setFV(index, i64);
+        break;
+    case ft_bfloat: // bfloat
+    case ft_float:
+        switch (m_tableDef->fieldDefs[index].len)
+        {
+        case 4: *((float*)((char*)m_pdata + m_tableDef->fieldDefs[index].pos)) = (float)data;
+            break;
+        case 8: *((double*)((char*)m_pdata + m_tableDef->fieldDefs[index].pos)) = data;
+            break;
+        default:
+            break;
+        }
+        break;
+    case ft_decimal:
+    case ft_money: setFVDecimal(index, data);
+        break;
+    case ft_numeric:
+    case ft_numericsts:
+    case ft_numericsa: setFVNumeric(index, data);
+        break;
+
+    case ft_integer:
+    case ft_date:
+    case ft_time:
+    case ft_uinteger:
+    case ft_logical:
+    case ft_autoinc:
+    case ft_timestamp:
+    case ft_bit:
+    case ft_mydate:
+    case ft_mytime:
+    case ft_mydatetime:
+    case ft_mytimestamp: i64 = (__int64)data;
+        setFV(index, i64);
+        break;
+    case ft_string:
+    case ft_zstring:
+    case ft_note:
+    case ft_myvarbinary:
+    case ft_myvarchar:
+    case ft_mychar:
+        if (data == 0)
+            setFVA(index, "");
+        else
+        {
+            sprintf(buf, "%f", data);
+            setFVA(index, buf);
+            break;
+        }
+    case ft_lvar: break;
+    case ft_mywvarbinary:
+    case ft_mywvarchar:
+    case ft_mywchar:
+    case ft_wstring:
+    case ft_wzstring:
+        {
+            if (data == 0)
+                setFV(index, _T(""));
+            else
+            {
+                _TCHAR buf[40];
+                _stprintf_s(buf, 40, _T("%f"), data);
+                setFV(index, buf);
+            }
+            break;
+        }
+    }
+}
+
+void table::setFV(short index, bool data)
+{
+    int value = (int)data;
+    setFV(index, value);
+}
+
+void table::setFV(short index, short data)
+{
+    int value = (int)data;
+    setFV(index, value);
+}
+
+void table::setFV(short index, float data)
+{
+    double value = (double)data;
+    setFV(index, value);
+
+}
+
+short table::getFVsht(short index) {return (short)getFVlng(index);}
+
+int table::getFVlng(short index)
+{
+    int ret = 0;
+
+    if (checkIndex(index) == false)
+        return 0;
+    fielddef& fd = m_tableDef->fieldDefs[index];
+    switch (fd.type)
+    {
+    case ft_integer:
+    case ft_autoinc:
+        switch (fd.len)
+        {
+        case 1: ret = *(((char*)m_pdata + fd.pos));
+            break;
+        case 2: ret = *((short*)((char*)m_pdata + fd.pos));
+            break;
+        case 3: memcpy(&ret, (char*)m_pdata + fd.pos, 3);
+            ret = ((ret & 0xFFFFFF) << 8) / 0x100;
+            break;
+        case 8:
+        case 4: ret = *((int*)((char*)m_pdata + fd.pos));
+            break;
+        }
+        break;
+    case ft_uinteger:
+    case ft_logical:
+    case ft_bit:
+    case ft_date:
+    case ft_time:
+    case ft_timestamp:
+    case ft_mydatetime:
+    case ft_mytimestamp:
+        switch (fd.len)
+        {
+        case 1: ret = *((unsigned char*)((char*)m_pdata + fd.pos));
+            break;
+        case 2: ret = *((unsigned short*)((char*)m_pdata + fd.pos));
+            break;
+        case 3: memcpy(&ret, (char*)m_pdata + fd.pos, 3);
+            break;
+        case 8:
+        case 4:
+            ret = *((unsigned int*)((char*)m_pdata + fd.pos));
+            break;
+        }
+        break;
+    case ft_mydate:
+        {
+            myDate myd;
+            myd.setValue((int)getValue64(fd, (const uchar_td*)m_pdata));
+            ret = myd.getValue(m_impl->myDateTimeValueByBtrv);
+            break;
+        }
+    case ft_mytime:
+        {
+            myTime myt(fd.len);
+            myt.setValue((int)getValue64(fd, (const uchar_td*)m_pdata));
+            ret = (int)myt.getValue(m_impl->myDateTimeValueByBtrv);
+            break; ;
+        }
+    case ft_string:
+    case ft_zstring:
+    case ft_note:
+    case ft_myvarbinary:
+    case ft_myvarchar:
+    case ft_mychar: ret = atol(getFVAstr(index));
+        break;
+    case ft_wstring:
+    case ft_wzstring:
+    case ft_mywvarbinary:
+    case ft_mywvarchar:
+    case ft_mywchar: ret = _ttol(getFVstr(index));
+        break;
+    case ft_currency: ret = (long)(*((__int64*)((char*)m_pdata + fd.pos)) / 10000);
+        break;
+    case ft_bfloat:
+    case ft_float: ret = (long)getFVdbl(index);
+        break;
+    case ft_decimal:
+    case ft_money: ret = (long)getFVDecimal(index);
+        break;
+    case ft_numeric:
+    case ft_numericsts:
+    case ft_numericsa: ret = (long)getFVnumeric(index);
+        break;
+
+    case ft_lvar: break;
+    default: return 0;
+    }
+    return ret;
+}
+
+float table::getFVflt(short index) {return (float) getFVdbl(index);}
+
+double table::getFVdbl(short index)
+{
+    double ret = 0;
+    if (checkIndex(index) == false)
+        return 0;
+    switch (m_tableDef->fieldDefs[index].type)
+    {
+    case ft_currency:
+        ret = (double) * ((__int64*)((char*)m_pdata + m_tableDef->fieldDefs[index].pos));
+        ret = ret / 10000;
+        break;
+
+    case ft_bfloat:
+    case ft_timestamp:
+    case ft_float:
+        switch (m_tableDef->fieldDefs[index].len)
+        {
+        case 4: ret = (double) * ((float*)((char*)m_pdata + m_tableDef->fieldDefs[index].pos));
+            break;
+        case 10: // long double
+        case 8: ret = (double) * ((double*)((char*)m_pdata + m_tableDef->fieldDefs[index].pos));
+            break;
+        }
+        break;
+    case ft_string:
+    case ft_zstring:
+    case ft_note:
+    case ft_myvarbinary:
+    case ft_myvarchar:
+    case ft_mychar: ret = atof(getFVAstr(index));
+        break;
+    case ft_wstring:
+    case ft_wzstring:
+    case ft_mywvarbinary:
+    case ft_mywvarchar:
+    case ft_mywchar: ret = _ttof(getFVstr(index));
+        break;
+    case ft_integer:
+    case ft_date:
+    case ft_time:
+    case ft_uinteger:
+    case ft_logical:
+    case ft_autoinc:
+    case ft_bit:
+    case ft_mydate:
+    case ft_mytime:
+    case ft_mydatetime:
+    case ft_mytimestamp: ret = (double)getFV64(index);
+        break;
+
+    case ft_decimal:
+    case ft_money: ret = getFVDecimal(index);
+        break;
+    case ft_numeric:
+    case ft_numericsts:
+    case ft_numericsa: ret = getFVnumeric(index);
+        break;
+    case ft_lvar: break;
+    default: return 0;
+    }
+    return ret;
+}
+
+unsigned char table::getFVbyt(short index) {return (unsigned char)getFVlng(index);}
+
+#ifdef _WIN32
+
+const wchar_t* table::getFVWstr(short index)
+{
+
+    if (checkIndex(index) == false)
+        return NULL;
+
+    fielddef& fd = m_tableDef->fieldDefs[index];
+    char* data = (char*)m_pdata + fd.pos;
+    switch (fd.type)
+    {
+    case ft_string:
+        return read<stringStore, char, WCHAR>(data, &m_impl->strBufs, fd, m_impl->cv,
+            m_impl->trimPadChar);
+    case ft_note:
+    case ft_zstring: return read<zstringStore, char, WCHAR>(data, &m_impl->strBufs, fd, m_impl->cv);
+    case ft_wzstring:
+        return read<wzstringStore, WCHAR, WCHAR>(data, &m_impl->strBufs, fd, m_impl->cv);
+    case ft_wstring:
+        return read<wstringStore, WCHAR, WCHAR>(data, &m_impl->strBufs, fd, m_impl->cv,
+            m_impl->trimPadChar);
+    case ft_mychar:
+        return read<myCharStore, char, WCHAR>(data, &m_impl->strBufs, fd, m_impl->cv,
+            m_impl->trimPadChar);
+    case ft_myvarchar:
+        return read<myVarCharStore, char, WCHAR>(data, &m_impl->strBufs, fd, m_impl->cv);
+    case ft_lstring:
+    case ft_myvarbinary:
+        return read<myVarBinaryStore, char, WCHAR>(data, &m_impl->strBufs, fd, m_impl->cv);
+    case ft_mywchar:
+        return read<myWcharStore, WCHAR, WCHAR>(data, &m_impl->strBufs, fd, m_impl->cv,
+            m_impl->trimPadChar);
+    case ft_mywvarchar:
+        return read<myWvarCharStore, WCHAR, WCHAR>(data, &m_impl->strBufs, fd, m_impl->cv);
+    case ft_mywvarbinary:
+        return read<myWvarBinaryStore, WCHAR, WCHAR>(data, &m_impl->strBufs, fd, m_impl->cv);
+    case ft_myblob:
+    case ft_mytext: return readBlob<WCHAR>(data, &m_impl->strBufs, fd, m_impl->cv);
+    }
+    wchar_t* p = (wchar_t*) m_impl->strBufs.getPtrW(max(fd.len * 2, 50));
+
+	wchar_t buf[10] = L"%0.";
+
+    switch (fd.type)
+    {
+
+    case ft_integer:
+    case ft_bit:
+    case ft_autoinc: _i64tow_s(getFV64(index), p, 50, 10);
+        return p;
+    case ft_logical:
+        if (m_impl->logicalToString)
+        {
+            if (getFVlng(index))
+                return L"Yes";
+            else
+                return L"No";
+        }
+        else
+            _i64tow_s(getFV64(index), p, 50, 10);
+
+    case ft_bfloat:
+    case ft_float:
+    case ft_currency:
+        {
+
+            swprintf_s(p, 50, L"%lf", getFVdbl(index));
+			int k = (int)wcslen(p) - 1;
+			while (k >= 0)
+            {
+                if (p[k] == L'0')
+                    p[k] = 0x00;
+                else if (p[k] == L'.')
+                {
+                    p[k] = 0x00;
+                    break;
+                }
+				else
+                    break;
+                k--;
+            }
+            break;
+        }
+    case ft_uinteger: swprintf_s(p, 50, L"%u", getFVlng(index));
+        break;
+    case ft_date: return btrdtoa(getFVlng(index), p);
+    case ft_time: return btrttoa(getFVlng(index), p);
+    case ft_mydate:
+        {
+            myDate d;
+            d.setValue((int)getValue64(fd, (const uchar_td*)m_pdata));
+            return d.toStr(p, m_impl->myDateTimeValueByBtrv);
+        }
+    case ft_mytime:
+        {
+
+            myTime t(fd.len);
+            t.setValue(getValue64(fd, (const uchar_td*)m_pdata));
+            return t.toStr(p);
+
+        }
+    case ft_mydatetime:
+        {
+            myDateTime t(fd.len);
+            t.setValue(getFV64(index));
+            return t.toStr(p);
+        }
+    case ft_mytimestamp:
+        {
+            myTimeStamp ts(fd.len);
+            ts.setValue(getFV64(index));
+            return ts.toStr(p);
+        }
+    case ft_decimal:
+    case ft_money:
+    case ft_numeric:
+    case ft_numericsts:
+    case ft_numericsa: _ltow_s(fd.decimals, p, 50, 10);
+        wcscat(buf, p);
+        wcscat(buf, L"lf");
+        swprintf(p, 50, buf, getFVdbl(index));
+        break;
+    case ft_lvar: return NULL;
+    case ft_timestamp: return btrTimeStamp(getFV64(index)).toString(p);
+    default: p[0] = 0x00;
+    }
+    return p;
+}
+
+const wchar_t* table::getFVWstr(const _TCHAR* FieldName)
+{
+    short index = fieldNumByName(FieldName);
+    return getFVWstr(index);
+
+}
+#endif //_WIN32
+
+const char* table::getFVAstr(short index)
+{
+    char buf[10] = "%0.";
+
+    if (checkIndex(index) == false)
+        return NULL;
+    fielddef& fd = m_tableDef->fieldDefs[index];
+
+    char* data = (char*)m_pdata + fd.pos;
+    switch (fd.type)
+    {
+
+    case ft_string:
+        return read<stringStore, char, char>(data, &m_impl->strBufs, fd, m_impl->cv,
+            m_impl->trimPadChar);
+    case ft_note:
+    case ft_zstring: return read<zstringStore, char, char>(data, &m_impl->strBufs, fd, m_impl->cv);
+    case ft_wzstring:
+        return read<wzstringStore, WCHAR, char>(data, &m_impl->strBufs, fd, m_impl->cv);
+    case ft_wstring:
+        return read<wstringStore, WCHAR, char>(data, &m_impl->strBufs, fd, m_impl->cv,
+            m_impl->trimPadChar);
+    case ft_mychar:
+        return read<myCharStore, char, char>(data, &m_impl->strBufs, fd, m_impl->cv,
+            m_impl->trimPadChar);
+    case ft_myvarchar:
+        return read<myVarCharStore, char, char>(data, &m_impl->strBufs, fd, m_impl->cv);
+    case ft_lstring:
+    case ft_myvarbinary:
+        return read<myVarBinaryStore, char, char>(data, &m_impl->strBufs, fd, m_impl->cv);
+    case ft_mywchar:
+        return read<myWcharStore, WCHAR, char>(data, &m_impl->strBufs, fd, m_impl->cv,
+            m_impl->trimPadChar);
+    case ft_mywvarchar:
+        return read<myWvarCharStore, WCHAR, char>(data, &m_impl->strBufs, fd, m_impl->cv);
+    case ft_mywvarbinary:
+        return read<myWvarBinaryStore, WCHAR, char>(data, &m_impl->strBufs, fd, m_impl->cv);
+    case ft_myblob:
+    case ft_mytext: return readBlob<char>(data, &m_impl->strBufs, fd, m_impl->cv);
+    }
+    char* p = m_impl->strBufs.getPtrA(max(fd.len * 2, 50));
+    switch (fd.type)
+    {
+    case ft_integer:
+    case ft_bit:
+    case ft_autoinc: _i64toa_s(getFV64(index), p, 50, 10);
+        return p;
+    case ft_logical:
+        if (m_impl->logicalToString)
+        {
+            if (getFVlng(index))
+                return "Yes";
+            else
+                return "No";
+        }
+        else
+            _i64toa_s(getFV64(index), p, 50, 10);
+        break;
+    case ft_bfloat:
+    case ft_float:
+    case ft_currency:
+        {
+            sprintf(p, "%lf", getFVdbl(index));
+            size_t k = strlen(p) - 1;
+            while (1)
+            {
+                if (p[k] == '0')
+                    p[k] = 0x00;
+                else if (p[k] == '.')
+                {
+                    p[k] = 0x00;
+                    break;
+                }
+                else
+                    break;
+                k--;
+            }
+            break;
+        }
+    case ft_date: return btrdtoa(getFVlng(index), p);
+    case ft_time: return btrttoa(getFVlng(index), p);
+    case ft_uinteger: sprintf(p, "%u", getFVlng(index));
+        break;
+
+    case ft_mydate:
+        {
+            myDate d;
+            d.setValue((int)getValue64(fd, (const uchar_td*)m_pdata));
+            return d.toStr(p, m_impl->myDateTimeValueByBtrv);
+        }
+    case ft_mytime:
+        {
+            myTime t(fd.len);
+            t.setValue(getValue64(fd, (const uchar_td*)m_pdata));
+            return t.toStr(p);
+        }
+    case ft_mytimestamp:
+        {
+            myTimeStamp ts(fd.len);
+            ts.setValue(getFV64(index));
+            return ts.toStr(p);
+        }
+    case ft_mydatetime:
+        {
+            myDateTime t(fd.len);
+            t.setValue(getFV64(index));
+            return t.toStr(p);
+        }
+    case ft_decimal:
+    case ft_money:
+    case ft_numeric:
+    case ft_numericsts:
+    case ft_numericsa: _ltoa_s(fd.decimals, p, 50, 10);
+        strcat(buf, p);
+        strcat(buf, "lf");
+        sprintf_s(p, 50, buf, getFVdbl(index));
+        break;
+    case ft_lvar: return NULL;
+    case ft_timestamp: return btrTimeStamp(getFV64(index)).toString(p);
+    default: p[0] = 0x00;
+    }
+    return p;
+}
+
+int table::getFVint(short index) {return (int)getFVlng(index);}
+
+int table::getFVint(const _TCHAR* FieldName)
+{
+    short index = fieldNumByName(FieldName);
+    return (int)getFVlng(index);
+
+}
+
+int table::getFVlng(const _TCHAR* FieldName)
+{
+    short index = fieldNumByName(FieldName);
+    return getFVlng(index);
+}
+
+const char* table::getFVAstr(const _TCHAR* FieldName)
+{
+    short index = fieldNumByName(FieldName);
+    return getFVAstr(index);
+}
+
+double table::getFVdbl(const _TCHAR* FieldName)
+{
+    short index = fieldNumByName(FieldName);
+    return getFVdbl(index);
+}
+
+unsigned char table::getFVbyt(const _TCHAR* FieldName)
+{
+    short index = fieldNumByName(FieldName);
+    return getFVbyt(index);
+}
+
+short table::getFVsht(const _TCHAR* FieldName)
+{
+    short index = fieldNumByName(FieldName);
+    return getFVsht(index);
+}
+
+float table::getFVflt(const _TCHAR* FieldName)
+{
+    short index = fieldNumByName(FieldName);
+    return getFVflt(index);
+}
+
+void table::setFV(const _TCHAR* FieldName, int data)
+{
+    short index = fieldNumByName(FieldName);
+    setFV(index, data);
+}
+
+void table::setFVA(const _TCHAR* FieldName, const char* data)
+{
+    short index = fieldNumByName(FieldName);
+    setFVA(index, data);
+}
+
+void table::setFV(const _TCHAR* FieldName, double data)
+{
+    short index = fieldNumByName(FieldName);
+    setFV(index, data);
+}
+
+void table::setFV(const _TCHAR* FieldName, float data)
+{
+    short index = fieldNumByName(FieldName);
+    setFV(index, data);
+}
+
+void table::setFV(const _TCHAR* FieldName, unsigned char data)
+{
+    short index = fieldNumByName(FieldName);
+    setFV(index, data);
+}
+
+void table::setFV(const _TCHAR* FieldName, short data)
+{
+    short index = fieldNumByName(FieldName);
+    setFV(index, data);
+}
+
+__int64 table::getFV64(const _TCHAR* FieldName)
+{
+    short index = fieldNumByName(FieldName);
+    return getFV64(index);
+}
+
+void table::setFV(const _TCHAR* FieldName, __int64 data)
+{
+    short index = fieldNumByName(FieldName);
+    setFV(index, data);
+}
+
+__int64 table::getFV64(short index)
+{
+    if (checkIndex(index) == false)
+        return 0;
+    fielddef& fd = m_tableDef->fieldDefs[index];
+
+    switch (fd.len)
+    {
+    case 8:
+        switch (fd.type)
+        {
+        case ft_uinteger:
+        case ft_integer:
+        case ft_logical:
+        case ft_autoinc:
+        case ft_bit:
+        case ft_currency:
+        case ft_timestamp:
+        case ft_mydatetime:
+        case ft_mytimestamp: return (__int64) *((__int64*)((char*)m_pdata + fd.pos));
+        }
+        return 0;
+    case 7:
+    case 6:
+    case 5:
+        switch (fd.type)
+        {
+        case ft_mytime:
+        case ft_mydatetime:
+        case ft_mytimestamp:
+            {
+                __int64 v = 0;
+                memcpy(&v, (char*)m_pdata + fd.pos, fd.len);
+                return v;
+            }
+        }
+        return 0;
+    default:
+
+        return (__int64) getFVlng(index);
+    }
+
+}
+
+void table::setFV(short index, __int64 data)
+{
+    if (checkIndex(index) == false)
+        return;
+
+    fielddef& fd = m_tableDef->fieldDefs[index];
+    switch (fd.len)
+    {
+    case 8:
+        switch (fd.type)
+        {
+        case ft_uinteger:
+        case ft_integer:
+        case ft_logical:
+        case ft_autoinc:
+        case ft_bit:
+        case ft_currency:
+        case ft_mydatetime:
+        case ft_mytimestamp: *((__int64*)((char*)m_pdata + fd.pos)) = data;
+            break;
+        case ft_timestamp:
+            {
+                btrDate d;
+                d.i = getNowDate();
+                btrTime t;
+                t.i = getNowTime();
+                *((__int64*)((char*)m_pdata + fd.pos)) = btrTimeStamp(d, t).i64;
+                break;
+            }
+        case ft_float:
+            {
+                double d = (double)data;
+                setFV(index, d);
+                break;
+            }
+        }
+        break;
+    case 7:
+    case 6:
+    case 5:
+        switch (fd.type)
+        {
+        case ft_mytime:
+        case ft_mydatetime:
+        case ft_mytimestamp: memcpy((char*)m_pdata + fd.pos, &data, fd.len);
+            break;
+        default: break;
+        }
+        break;
+    default:
+        {
+            int value = (int)data;
+            setFV(index, value);
+            break;
+        }
+    }
+}
+
+void table::setFV(const _TCHAR* FieldName, const void* data, uint_td size)
+{
+    short index = fieldNumByName(FieldName);
+    setFV(index, data, size);
+}
+
+/* if blob and text ,set binary data that is only set pointer. it is not copied.
+ *  Caller must hold data until it sends to the server.
+ */
+void table::setFV(short index, const void* data, uint_td size)
+{
+    if (checkIndex(index) == false)
+        return;
+
+    fielddef& fd = m_tableDef->fieldDefs[index];
+
+    switch (fd.type)
+    {
+    case ft_myvarbinary:
+    case ft_myvarchar:
+    case ft_mywvarbinary:
+    case ft_mywvarchar:
+    case ft_lstring:
+        {
+            int sizeByte = fd.varLenBytes();
+            size = std::min<uint_td>((uint_td)(fd.len - sizeByte), size);
+            memset((char*)m_pdata + fd.pos, 0, fd.len);
+            memcpy((char*)m_pdata + fd.pos, &size, sizeByte);
+            memcpy((char*)m_pdata + fd.pos + sizeByte, data, size);
+            break;
+        }
+    case ft_myblob:
+    case ft_mytext:
+        {
+            int sizeByte = fd.len - 8;
+            memset((char*)m_pdata + fd.pos, 0, fd.len);
+            memcpy((char*)m_pdata + fd.pos, &size, sizeByte);
+            memcpy((char*)m_pdata + fd.pos + sizeByte, &data, sizeof(char*));
+            break;
+
+        }
+    default: m_stat = STATUS_FIELDTYPE_NOTSUPPORT; // this field type is not supported.
+    }
+}
+
+void* table::getFVbin(const _TCHAR* FieldName, uint_td& size)
+{
+    short index = fieldNumByName(FieldName);
+    return getFVbin(index, size);
+}
+
+/* offset is writen at data that is first address of data
+ *  text is not converted to unicode form stored charset.
+ */
+void* table::getFVbin(short index, uint_td& size)
+{
+    if (checkIndex(index) == false)
+        return NULL;
+
+    fielddef& fd = m_tableDef->fieldDefs[index];
+
+    switch (fd.type)
+    {
+    case ft_myvarbinary:
+    case ft_myvarchar:
+    case ft_mywvarbinary:
+    case ft_mywvarchar:
+    case ft_lstring:
+        {
+            int sizeByte = fd.varLenBytes();
+            size = 0;
+            memcpy(&size, (char*)m_pdata + fd.pos, sizeByte);
+            return (void*)((char*)m_pdata + fd.pos + sizeByte);
+        }
+    case ft_myblob:
+    case ft_mytext:
+        {
+            int sizeByte = fd.len - 8;
+            size = 0;
+            memcpy(&size, (char*)m_pdata + fd.pos, sizeByte);
+            char** ptr = (char**)((char*)m_pdata + fd.pos + sizeByte);
+            return (void*)*ptr;
+        }
+    }
+    return NULL;
+}
+
+bool table::checkIndex(short index)
+{
+    if ((index >= m_tableDef->fieldCount) || (index < 0))
+    {
+        m_stat = STATUS_INVARID_FIELD_IDX;
+        return false;
+    }
+    return true;
+}
+
+double table::getFVDecimal(short index)
+{
+    unsigned char buf[20] = {0x00};
+    char result[30] = {0x00};
+    char n[10];
+    int i;
+    char* t;
+    unsigned char sign;
+    int len = m_tableDef->fieldDefs[index].len;
+    result[0] = '+';
+    memcpy(buf, (void*)((char*)m_pdata + m_tableDef->fieldDefs[index].pos), len);
+    sign = (unsigned char)(buf[len - 1] & 0x0F);
+    buf[len - 1] = (unsigned char)(buf[len - 1] & 0xF0);
+    for (i = 0; i < len; i++)
+    {
+        sprintf_s(n, 50, "%02x", buf[i]);
+        strcat(result, n);
+    }
+    i = (int)strlen(result);
+
+    if (sign == 13)
+        result[0] = '-';
+    result[i - 1] = 0x00;
+
+
+    t = result + (m_tableDef->fieldDefs[index].len * 2) - m_tableDef->fieldDefs[index].decimals;
+    strcpy((char*)buf, t);
+    *t = '.';
+    strcpy(t + 1, (char*)buf);
+    return atof(result);
+}
+
+double table::getFVnumeric(short index)
+{
+    char* t;
+    char dp[] = "{ABCDEFGHI}JKLMNOPQR";
+    char dpsa[] = "PQRSTUVWXYpqrstuvwxy";
+    char* pdp = NULL;
+    char i;
+    char buf[20] = {0x00};
+    char dummy[20];
+
+    buf[0] = '+';
+    strncpy(buf + 1, (char*)((char*)m_pdata + m_tableDef->fieldDefs[index].pos),
+        m_tableDef->fieldDefs[index].len);
+
+    t = &(buf[m_tableDef->fieldDefs[index].len]);
+
+    switch (m_tableDef->fieldDefs[index].type)
+    {
+    case ft_numeric: pdp = dp;
+        break;
+    case ft_numericsa: pdp = dpsa;
+        break;
+    case ft_numericsts: buf[0] = *t;
+        *t = 0x00;
+        break;
+    }
+
+    if (pdp)
+    {
+        for (i = 0; i < 21; i++)
+        {
+            if (*t == pdp[i])
+            {
+                if (i > 10)
+                {
+                    buf[0] = '-';
+                    *t = (char)(i + 38);
+                }
+                else
+                    *t = (char)(i + 48);
+                break;
+            }
+        }
+    }
+
+    t = buf + strlen(buf) - m_tableDef->fieldDefs[index].decimals;
+    strcpy(dummy, t);
+    *t = '.';
+    strcpy(t + 1, dummy);
+    return atof(buf);
+}
+
+void table::setFVDecimal(short index, double data)
+{ // Double  -> Decimal
+    char buf[30] = "%+0";
+    char dummy[30];
+    int point;
+    bool sign = false;
+    unsigned char n;
+    int i, k;
+    int strl;
+    bool offset = false; ;
+    point = (m_tableDef->fieldDefs[index].len) * 2;
+    _ltoa_s(point, dummy, 30, 10);
+    strcat(buf, dummy);
+    strcat(buf, ".");
+    _ltoa_s(m_tableDef->fieldDefs[index].decimals, dummy, 30, 10);
+    strcat(buf, dummy);
+    strcat(buf, "lf");
+    sprintf(dummy, buf, data);
+    if (dummy[0] == '-')
+        sign = true;
+
+    strl = (int)strlen(dummy + 1) - 1;
+    if (strl % 2 == 1)
+        strl = strl / 2;
+    else
+    {
+        strl = strl / 2 + 1;
+        offset = true;
+    }
+    memset(buf, 0, 30);
+    k = 0;
+    n = 0;
+    point = (int)strlen(dummy + 1);
+    if (strl <= m_tableDef->fieldDefs[index].len)
+    {
+        for (i = 1; i <= point; i++)
+        {
+            if ((dummy[i] == '-') || (dummy[i] == '.'));
+            else
+            {
+                if (offset)
+                {
+                    n = (unsigned char)(n + dummy[i] - 48);
+                    buf[k] = n;
+                    offset = false;
+                    k++;
+                }
+                else
+                {
+                    n = (unsigned char)(dummy[i] - 48);
+                    n = (unsigned char)(n << 4);
+                    offset = true; ;
+                }
+            }
+        }
+        if (sign)
+            buf[k] += ((unsigned char)(n + 13));
+        else
+            buf[k] += ((unsigned char)(n + 12));
+    }
+    memcpy((void*)((char*)m_pdata + m_tableDef->fieldDefs[index].pos), buf,
+        m_tableDef->fieldDefs[index].len);
+
+}
+
+void table::setFVNumeric(short index, double data)
+{ // Double  -> Numeric
+    char buf[30] = "%+0";
+    char dummy[30];
+    int point;
+    int n;
+    char dp[] = "{ABCDEFGHI}JKLMNOPQR";
+    char dpsa[] = "PQRSTUVWXYpqrstuvwxy";
+    bool sign = false;
+    char* t;
+
+    point = m_tableDef->fieldDefs[index].len + 1;
+
+    _ltoa_s(point, dummy, 30, 10);
+    strcat(buf, dummy);
+    strcat(buf, ".");
+    _ltoa_s(m_tableDef->fieldDefs[index].decimals, dummy, 30, 10);
+    strcat(buf, dummy);
+    strcat(buf, "lf");
+    sprintf(dummy, buf, data);
+    if (dummy[0] == '-')
+        sign = true;
+
+
+    strcpy(buf, &dummy[point - m_tableDef->fieldDefs[index].decimals] + 1);
+    dummy[point - m_tableDef->fieldDefs[index].decimals] = 0x00;
+    strcat(dummy, buf);
+
+    n = atol(&dummy[m_tableDef->fieldDefs[index].len]);
+    if (sign)
+        n += 10;
+    t = dummy + 1;
+    switch (m_tableDef->fieldDefs[index].type)
+    {
+    case ft_numeric: dummy[m_tableDef->fieldDefs[index].len] = dp[n];
+        break;
+    case ft_numericsa: dummy[m_tableDef->fieldDefs[index].len] = dpsa[n];
+        break;
+    case ft_numericsts:
+        if (sign)
+            strcat(dummy, "-");
+        else
+            strcat(dummy, "+");
+        t += 1;
+        break;
+    }
+
+    memcpy((void*)((char*)m_pdata + m_tableDef->fieldDefs[index].pos), t,
+        m_tableDef->fieldDefs[index].len);
+}
+
+unsigned int table::getRecordHash()
+{
+    return hash((const char*)fieldPtr(0), datalen());
+}
+
+
+
+
+
+int table::bookMarksCount() const
+{
+    int ret;
+    ret = m_impl->maxBookMarkedCount;
+    return ret;
+}
+
+void table::moveBookmarksId(long id)
+{
+    long Point = (id - 1) * 6 + 2;
+
+    if ((id <= m_impl->maxBookMarkedCount) && (m_impl->bookMarks))
+        seekByBookmark(*((bookmark_td*)((char*)m_impl->bookMarks + Point)));
+    else
+        seekByBookmark(0);
+}
+
+short_td table::doBtrvErr(HWND hWnd, _TCHAR* retbuf)
+{
+    return nstable::tdapErr(hWnd, m_stat, m_tableDef->tableName(), retbuf);
+}
+
+
+
+}// namespace client
+}// namespace tdap
+}// namespace protocol
+}// namespace db
+}// namespace bzs