transactd 1.2.0 → 2.0.0

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

@@ -0,0 +1,1985 @@
+/* =================================================================
+ 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 "field.h"
+#include "fields.h"
+#include "nsDatabase.h"
+#include <bzs/db/protocol/tdap/myDateTime.cpp>
+#include <bzs/db/protocol/tdap/fieldComp.h>
+#include "stringConverter.h"
+#include <bzs/rtl/stringBuffers.h>
+#include <boost/shared_array.hpp>
+
+#ifdef BCB_32
+#pragma option push
+#pragma option -O1
+#include <boost/unordered_map.hpp>
+#pragma option pop
+#else
+#include <boost/unordered_map.hpp>
+#endif
+
+#pragma package(smart_init)
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+namespace client
+{
+
+//------------------------------------------------------------------------------
+//       class fieldShare
+//------------------------------------------------------------------------------
+struct Imple
+{
+    stringConverter* cv;
+    bzs::rtl::stringBuffer strBufs;
+    std::vector<boost::shared_array<char> > blobs;
+
+    Imple() : strBufs(4096)
+    {
+        cv = new stringConverter(nsdatabase::execCodePage(),
+                                 nsdatabase::execCodePage());
+    }
+
+    ~Imple() { delete cv; }
+};
+
+fieldShare::fieldShare()
+    : m_imple(new Imple()), myDateTimeValueByBtrv(true), trimPadChar(true),
+      usePadChar(true), logicalToString(false)
+{
+}
+
+fieldShare::~fieldShare()
+{
+    delete m_imple;
+}
+
+stringConverter* fieldShare::cv()
+{
+    return m_imple->cv;
+}
+
+bzs::rtl::stringBuffer* fieldShare::strBufs()
+{
+    return &m_imple->strBufs;
+}
+
+void fieldShare::blobPushBack(char* p)
+{
+    m_imple->blobs.push_back(boost::shared_array<char>(p));
+}
+
+void fieldShare::blobClear()
+{
+    m_imple->blobs.clear();
+}
+
+//------------------------------------------------------------------------------
+//       class fielddefs
+//------------------------------------------------------------------------------
+
+struct infoImple
+{
+    std::vector<fielddef> fields;
+    boost::unordered_map<std::_tstring, int> map;
+    const aliasMap_type* aliasMap;
+
+    infoImple() : aliasMap(NULL) {}
+    infoImple(const infoImple& r)
+        : fields(r.fields), map(r.map), aliasMap(r.aliasMap){};
+};
+
+fielddefs::fielddefs() : fieldShare(), m_imple(new infoImple)
+{
+}
+
+// A fieldShare is need no copy member(s)
+fielddefs::fielddefs(const fielddefs& r)
+    : fieldShare(), m_imple(new infoImple(*r.m_imple))
+{
+}
+
+// A fieldShare is no copy member(s)
+fielddefs& fielddefs::operator=(const fielddefs& r)
+{
+    if (this != &r)
+    {
+        *m_imple = *r.m_imple;
+    }
+    return *this;
+}
+
+void fielddefs::aliasing(fielddef* p) const
+{
+    if (m_imple->aliasMap)
+    {
+        const _TCHAR* ret = m_imple->aliasMap->get(p->name());
+        if (ret[0])
+            p->setName(ret);
+    }
+}
+
+fielddefs::~fielddefs()
+{
+    delete m_imple;
+}
+
+fielddefs* fielddefs::clone() const
+{
+    fielddefs* p = new fielddefs(*this);
+    return p;
+}
+
+void fielddefs::setAliases(const aliasMap_type* p)
+{
+    m_imple->aliasMap = p;
+}
+
+void fielddefs::addAllFileds(tabledef* def)
+{
+    m_imple->fields.clear();
+    for (int i = 0; i < def->fieldCount; ++i)
+        push_back(&def->fieldDefs[i]);
+}
+
+void fielddefs::push_back(const fielddef* p, bool rePosition)
+{
+    m_imple->fields.push_back(*p);
+    int index = (int)m_imple->fields.size() - 1;
+    fielddef* pp = &m_imple->fields[index];
+
+    // convert field name of table charset to recordset schema charset.
+    _TCHAR tmp[FIELD_NAME_SIZE * 3];
+    pp->setName(p->name(tmp));
+
+    if (rePosition)
+    {
+        if (index == 0)
+            pp->pos = 0;
+        else
+        {
+            fielddef* bf = &m_imple->fields[index - 1];
+            pp->pos = bf->pos + bf->len;
+        }
+    }
+    // reset update indicator
+    pp->enableFlags.bitE = false;
+    aliasing(pp);
+    m_imple->map[pp->name()] = index;
+}
+
+void fielddefs::remove(int index)
+{
+    m_imple->map.erase(m_imple->fields[index].name());
+    m_imple->fields.erase(m_imple->fields.begin() + index);
+    boost::unordered_map<std::_tstring, int>::iterator it =
+        m_imple->map.begin();
+    while (it != m_imple->map.end())
+    {
+        if ((*it).second > index)
+            (*it).second--;
+        ++it;
+    }
+}
+
+void fielddefs::reserve(size_t size)
+{
+    m_imple->fields.reserve(size);
+}
+
+void fielddefs::clear()
+{
+    m_imple->fields.clear();
+    m_imple->map.clear();
+}
+
+void fielddefs::resetUpdateIndicator()
+{
+    std::vector<fielddef>::iterator it = m_imple->fields.begin();
+    while (it != m_imple->fields.end())
+    {
+        (*it).enableFlags.bitE = false;
+        ++it;
+    }
+}
+
+bool fielddefs::checkIndex(int index) const
+{
+    return (index >= 0 && index < (int)m_imple->fields.size());
+}
+
+int fielddefs::indexByName(const std::_tstring& name) const
+{
+    if (m_imple->map.count(name) == 0)
+        return -1;
+
+    return m_imple->map.at(name);
+}
+
+const fielddef& fielddefs::operator[](int index) const
+{
+    assert(checkIndex(index));
+
+    return m_imple->fields[index];
+}
+
+const fielddef& fielddefs::operator[](const _TCHAR* name) const
+{
+    return m_imple->fields[indexByName(std::_tstring(name))];
+}
+
+const fielddef& fielddefs::operator[](const std::_tstring& name) const
+{
+    return m_imple->fields[indexByName(name)];
+}
+
+size_t fielddefs::size() const
+{
+    return m_imple->fields.size();
+}
+
+size_t fielddefs::totalFieldLen() const
+{
+    const fielddef& fd = m_imple->fields[m_imple->fields.size() - 1];
+    return fd.pos + fd.len;
+}
+
+void fielddefs::copyFrom(const table* tb)
+{
+    int n = tb->getCurProcFieldCount();
+    m_imple->fields.reserve(n + size());
+    const tabledef* def = tb->tableDef();
+    int pos = 0;
+    for (int i = 0; i < n; ++i)
+    {
+        fielddef fd = def->fieldDefs[tb->getCurProcFieldIndex(i)];
+        fd.pos = pos;
+        push_back(&fd);
+        pos += fd.len;
+    }
+
+    // Defalut field charset
+    cv()->setCodePage(mysql::codePage(def->charsetIndex));
+}
+
+bool fielddefs::canUnion(const fielddefs& src) const
+{
+    if (size() != src.size())
+        return false;
+    for (int i = 0; i < (int)m_imple->fields.size(); ++i)
+    {
+        const fielddef& l = m_imple->fields[i];
+        const fielddef& r = src.m_imple->fields[i];
+        if (l.pos != r.pos)
+            return false;
+        if (l.len != r.len)
+            return false;
+        if (l.type != r.type)
+            return false;
+        if (l.charsetIndex() != r.charsetIndex())
+            return false;
+    }
+    return true;
+}
+
+fielddefs* fielddefs::create()
+{
+    return new fielddefs();
+}
+
+void fielddefs::release()
+{
+    delete this;
+}
+
+//------------------------------------------------------------------------------
+//       class field
+//------------------------------------------------------------------------------
+static fielddef fdDummy;
+
+DLLLIB const fielddef& dummyFd()
+{
+    fdDummy.type = ft_integer;
+    fdDummy.pos = 0;
+    fdDummy.len = 2;
+    fdDummy.setName(_T("Invalid filed"));
+    return fdDummy;
+}
+
+// const field fieldDummy(NULL, initDummy(), NULL);
+
+inline __int64 getValue64(const fielddef& fd, const uchar_td* ptr)
+{
+    __int64 ret = 0;
+    if (ptr)
+    {
+        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_autoIncUnsigned:
+        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)
+{
+    if (!ptr)
+        return;
+    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)) = value;
+            break;
+        }
+    }
+    case ft_autoIncUnsigned:
+    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;
+    }
+}
+
+void* field::ptr() const
+{
+    return m_ptr + m_fd->pos;
+    ;
+}
+
+void field::setFVA(const char* data)
+{
+    if (!m_ptr)
+        return;
+    __int64 value;
+    double fltValue;
+
+    char* p = (char*)m_ptr + m_fd->pos;
+    if (data == NULL)
+    {
+        memset(p, 0, m_fd->len);
+        return;
+    }
+
+    switch (m_fd->type)
+    {
+    case ft_string:
+        return store<stringStore, char, char>(p, data, *m_fd, m_fds->cv(),
+                                              m_fds->usePadChar);
+    case ft_note:
+    case ft_zstring:
+        return store<zstringStore, char, char>(p, data, *m_fd, m_fds->cv());
+    case ft_wzstring:
+        return store<wzstringStore, WCHAR, char>(p, data, *m_fd, m_fds->cv());
+    case ft_wstring:
+        return store<wstringStore, WCHAR, char>(p, data, *m_fd, m_fds->cv(),
+                                                m_fds->usePadChar);
+    case ft_mychar:
+        return store<myCharStore, char, char>(p, data, *m_fd, m_fds->cv());
+    case ft_myvarchar:
+        return store<myVarCharStore, char, char>(p, data, *m_fd, m_fds->cv());
+    case ft_lstring:
+    case ft_myvarbinary:
+        return store<myVarBinaryStore, char, char>(p, data, *m_fd, m_fds->cv());
+    case ft_mywchar:
+        return store<myWcharStore, WCHAR, char>(p, data, *m_fd, m_fds->cv());
+    case ft_mywvarchar:
+        return store<myWvarCharStore, WCHAR, char>(p, data, *m_fd, m_fds->cv());
+    case ft_mywvarbinary:
+        return store<myWvarBinaryStore, WCHAR, char>(p, data, *m_fd,
+                                                     m_fds->cv());
+    case ft_myblob:
+    case ft_mytext:
+    {
+        char* tmp = blobStore<char>(p, data, *m_fd, m_fds->cv());
+        m_fds->blobPushBack(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(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_autoIncUnsigned:
+    case ft_uinteger:
+    case ft_integer:
+    case ft_autoinc:
+    case ft_bit:
+        value = _atoi64(data);
+        break;
+    case ft_logical:
+        if (m_fds->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(m_fd->len);
+        t = data;
+        value = t.getValue();
+        break;
+    }
+
+    case ft_mydatetime:
+    {
+        myDateTime t(m_fd->len);
+        t = data;
+        value = t.getValue();
+        break;
+    }
+    default:
+        return;
+    }
+    setValue(*m_fd, (uchar_td*)m_ptr, value);
+}
+
+#ifdef _WIN32
+
+void field::setFVW(const wchar_t* data)
+{
+    if (!m_ptr)
+        return;
+    int value;
+    double fltValue;
+
+    char* p = (char*)m_ptr + m_fd->pos;
+    if (data == NULL)
+    {
+        memset(p, 0, m_fd->len);
+        return;
+    }
+
+    switch (m_fd->type)
+    {
+    case ft_string:
+        return store<stringStore, char, WCHAR>(p, data, *m_fd, m_fds->cv(),
+                                               m_fds->usePadChar);
+    case ft_note:
+    case ft_zstring:
+        return store<zstringStore, char, WCHAR>(p, data, *m_fd, m_fds->cv());
+    case ft_wzstring:
+        return store<wzstringStore, WCHAR, WCHAR>(p, data, *m_fd, m_fds->cv());
+    case ft_wstring:
+        return store<wstringStore, WCHAR, WCHAR>(p, data, *m_fd, m_fds->cv(),
+                                                 m_fds->usePadChar);
+    case ft_mychar:
+        return store<myCharStore, char, WCHAR>(p, data, *m_fd, m_fds->cv());
+    case ft_myvarchar:
+        return store<myVarCharStore, char, WCHAR>(p, data, *m_fd, m_fds->cv());
+    case ft_lstring:
+    case ft_myvarbinary:
+        return store<myVarBinaryStore, char, WCHAR>(p, data, *m_fd,
+                                                    m_fds->cv());
+    case ft_mywchar:
+        return store<myWcharStore, WCHAR, WCHAR>(p, data, *m_fd, m_fds->cv());
+    case ft_mywvarchar:
+        return store<myWvarCharStore, WCHAR, WCHAR>(p, data, *m_fd,
+                                                    m_fds->cv());
+    case ft_mywvarbinary:
+        return store<myWvarBinaryStore, WCHAR, WCHAR>(p, data, *m_fd,
+                                                      m_fds->cv());
+    case ft_myblob:
+    case ft_mytext:
+    {
+        char* tmp = blobStore<WCHAR>(p, data, *m_fd, m_fds->cv());
+        m_fds->blobPushBack(tmp);
+        return;
+    }
+
+    case ft_date: // date mm/dd/yy
+        value = /*StrToBtrDate*/ atobtrd(data).i;
+        setFV(value);
+        break;
+    case ft_time: // time hh:nn:ss
+        value = /*StrToBtrTime*/ atobtrt(data).i;
+        setFV(value);
+        return;
+
+    case ft_autoIncUnsigned:
+    case ft_uinteger:
+    case ft_integer:
+    case ft_autoinc:
+    case ft_bit:
+    {
+        __int64 v = _wtoi64(data);
+        setFV(v);
+        break;
+    }
+    case ft_logical:
+        if (m_fds->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(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(fltValue);
+        break;
+    case ft_timestamp:
+    {
+        __int64 v = 0;
+        setFV(v);
+        return;
+    }
+    case ft_mydate:
+    {
+        myDate d;
+        d = data;
+        setValue(*m_fd, (uchar_td*)m_ptr, d.getValue());
+        return;
+    }
+    case ft_mytime:
+    {
+        myTime t(m_fd->len);
+        t = data;
+        setValue(*m_fd, (uchar_td*)m_ptr, t.getValue());
+        return;
+    }
+    case ft_mydatetime:
+    {
+        myDateTime t(m_fd->len);
+        t = data;
+        setFV(t.getValue());
+        return;
+    }
+    case ft_mytimestamp:
+    case ft_lvar:
+        break;
+    }
+}
+
+#endif //_WIN32
+
+void field::setFV(unsigned char data)
+{
+
+    int value = (int)data;
+    setFV(value);
+}
+
+void field::setFV(int data)
+{
+    if (!m_ptr)
+        return;
+    char buf[20];
+    double d;
+    int v = data;
+    switch (m_fd->type)
+    {
+    case ft_mydate:
+    {
+        myDate myd;
+        myd.setValue(data, m_fds->myDateTimeValueByBtrv);
+        setValue(*m_fd, (uchar_td*)m_ptr, myd.getValue());
+        break;
+    }
+    case ft_mytime:
+    {
+        myTime myt(m_fd->len);
+        myt.setValue(data, m_fds->myDateTimeValueByBtrv);
+        setValue(*m_fd, (uchar_td*)m_ptr, myt.getValue());
+        break;
+    }
+    case ft_integer:
+    case ft_date:
+    case ft_time:
+    case ft_autoIncUnsigned:
+    case ft_uinteger:
+    case ft_logical:
+    case ft_autoinc:
+    case ft_bit:
+    case ft_mydatetime:
+        switch (m_fd->len)
+        {
+        case 1:
+            *((char*)((char*)m_ptr + m_fd->pos)) = (char)v;
+            break;
+        case 2:
+            *((short*)((char*)m_ptr + m_fd->pos)) = (short)v;
+            break;
+        case 3:
+            memcpy((char*)m_ptr + m_fd->pos, &v, 3);
+            break;
+        case 4:
+            *((int*)((char*)m_ptr + m_fd->pos)) = v;
+            break;
+        case 8:
+            *((__int64*)((char*)m_ptr + m_fd->pos)) = v;
+            break;
+        }
+        break;
+
+    case ft_timestamp:
+    {
+        __int64 v = 0;
+        setFV(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(d);
+        break;
+    case ft_string:
+    case ft_zstring:
+    case ft_note:
+    case ft_myvarbinary:
+    case ft_myvarchar:
+    case ft_mychar:
+        if (data == 0)
+            setFVA("");
+        else
+        {
+            _ltoa_s(data, buf, 20, 10);
+            setFVA(buf);
+        }
+        break;
+    case ft_mywvarbinary:
+    case ft_mywvarchar:
+    case ft_mywchar:
+    case ft_wstring:
+    case ft_wzstring:
+    {
+        if (data == 0)
+            setFV(_T(""));
+        else
+        {
+            _TCHAR buf[30];
+            _ltot_s(data, buf, 30, 10);
+            setFV(buf);
+        }
+        break;
+    }
+    case ft_lvar:
+        break;
+    }
+}
+
+void field::setFV(double data)
+{
+    if (!m_ptr)
+        return;
+    char buf[20];
+    __int64 i64;
+    switch (m_fd->type)
+    {
+    case ft_currency: // currency
+        i64 = (__int64)(data * 10000 + 0.5);
+        setFV(i64);
+        break;
+    case ft_bfloat: // bfloat
+    case ft_float:
+        switch (m_fd->len)
+        {
+        case 4:
+            *((float*)((char*)m_ptr + m_fd->pos)) = (float)data;
+            break;
+        case 8:
+            *((double*)((char*)m_ptr + m_fd->pos)) = data;
+            break;
+        default:
+            break;
+        }
+        break;
+    case ft_decimal:
+    case ft_money:
+        setFVDecimal(data);
+        break;
+    case ft_numeric:
+    case ft_numericsts:
+    case ft_numericsa:
+        setFVNumeric(data);
+        break;
+
+    case ft_integer:
+    case ft_date:
+    case ft_time:
+    case ft_autoIncUnsigned:
+    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(i64);
+        break;
+    case ft_string:
+    case ft_zstring:
+    case ft_note:
+    case ft_myvarbinary:
+    case ft_myvarchar:
+    case ft_mychar:
+        if (data == 0)
+            setFVA("");
+        else
+        {
+            sprintf(buf, "%f", data);
+            setFVA(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(_T(""));
+        else
+        {
+            _TCHAR buf[40];
+            _stprintf_s(buf, 40, _T("%f"), data);
+            setFV(buf);
+        }
+        break;
+    }
+    }
+}
+
+void field::setFV(short data)
+{
+    int value = (int)data;
+    setFV(value);
+}
+
+void field::setFV(float data)
+{
+    double value = (double)data;
+    setFV(value);
+}
+
+short field::getFVsht() const
+{
+    return (short)getFVlng();
+}
+
+int field::getFVlng() const
+{
+    if (!m_ptr)
+        return 0;
+    int ret = 0;
+    switch (m_fd->type)
+    {
+    case ft_integer:
+    case ft_autoinc:
+        switch (m_fd->len)
+        {
+        case 1:
+            ret = *(((char*)m_ptr + m_fd->pos));
+            break;
+        case 2:
+            ret = *((short*)((char*)m_ptr + m_fd->pos));
+            break;
+        case 3:
+            memcpy(&ret, (char*)m_ptr + m_fd->pos, 3);
+            ret = ((ret & 0xFFFFFF) << 8) / 0x100;
+            break;
+        case 8:
+        case 4:
+            ret = *((int*)((char*)m_ptr + m_fd->pos));
+            break;
+        }
+        break;
+    case ft_autoIncUnsigned:
+    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 (m_fd->len)
+        {
+        case 1:
+            ret = *((unsigned char*)((char*)m_ptr + m_fd->pos));
+            break;
+        case 2:
+            ret = *((unsigned short*)((char*)m_ptr + m_fd->pos));
+            break;
+        case 3:
+            memcpy(&ret, (char*)m_ptr + m_fd->pos, 3);
+            break;
+        case 8:
+        case 4:
+            ret = *((unsigned int*)((char*)m_ptr + m_fd->pos));
+            break;
+        }
+        break;
+    case ft_mydate:
+    {
+        myDate myd;
+        myd.setValue((int)getValue64(*m_fd, (const uchar_td*)m_ptr));
+        ret = myd.getValue(m_fds->myDateTimeValueByBtrv);
+        break;
+    }
+    case ft_mytime:
+    {
+        myTime myt(m_fd->len);
+        myt.setValue((int)getValue64(*m_fd, (const uchar_td*)m_ptr));
+        ret = (int)myt.getValue(m_fds->myDateTimeValueByBtrv);
+        break;
+        ;
+    }
+    case ft_string:
+    case ft_zstring:
+    case ft_note:
+    case ft_myvarbinary:
+    case ft_myvarchar:
+    case ft_mychar:
+        ret = atol(getFVAstr());
+        break;
+    case ft_wstring:
+    case ft_wzstring:
+    case ft_mywvarbinary:
+    case ft_mywvarchar:
+    case ft_mywchar:
+        ret = _ttol(getFVstr());
+        break;
+    case ft_currency:
+        ret = (long)(*((__int64*)((char*)m_ptr + m_fd->pos)) / 10000);
+        break;
+    case ft_bfloat:
+    case ft_float:
+        ret = (long)getFVdbl();
+        break;
+    case ft_decimal:
+    case ft_money:
+        ret = (long)getFVDecimal();
+        break;
+    case ft_numeric:
+    case ft_numericsts:
+    case ft_numericsa:
+        ret = (long)getFVnumeric();
+        break;
+
+    case ft_lvar:
+        break;
+    default:
+        return 0;
+    }
+    return ret;
+}
+
+float field::getFVflt() const
+{
+    return (float)getFVdbl();
+}
+
+double field::getFVdbl() const
+{
+    if (!m_ptr)
+        return 0;
+    double ret = 0;
+    switch (m_fd->type)
+    {
+    case ft_currency:
+        ret = (double)*((__int64*)((char*)m_ptr + m_fd->pos));
+        ret = ret / 10000;
+        break;
+
+    case ft_bfloat:
+    case ft_timestamp:
+    case ft_float:
+        switch (m_fd->len)
+        {
+        case 4:
+            ret = (double)*((float*)((char*)m_ptr + m_fd->pos));
+            break;
+        case 10: // long double
+        case 8:
+            ret = (double)*((double*)((char*)m_ptr + m_fd->pos));
+            break;
+        }
+        break;
+    case ft_string:
+    case ft_zstring:
+    case ft_note:
+    case ft_myvarbinary:
+    case ft_myvarchar:
+    case ft_mychar:
+        ret = atof(getFVAstr());
+        break;
+    case ft_wstring:
+    case ft_wzstring:
+    case ft_mywvarbinary:
+    case ft_mywvarchar:
+    case ft_mywchar:
+        ret = _ttof(getFVstr());
+        break;
+    case ft_integer:
+    case ft_date:
+    case ft_time:
+    case ft_autoIncUnsigned:
+    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();
+        break;
+
+    case ft_decimal:
+    case ft_money:
+        ret = getFVDecimal();
+        break;
+    case ft_numeric:
+    case ft_numericsts:
+    case ft_numericsa:
+        ret = getFVnumeric();
+        break;
+    case ft_lvar:
+        break;
+    default:
+        return 0;
+    }
+    return ret;
+}
+
+unsigned char field::getFVbyt() const
+{
+    return (unsigned char)getFVlng();
+}
+
+#ifdef _WIN32
+
+const wchar_t* field::getFVWstr() const
+{
+    if (!m_ptr)
+        return L"";
+    char* data = (char*)m_ptr + m_fd->pos;
+    switch (m_fd->type)
+    {
+    case ft_string:
+        return read<stringStore, char, WCHAR>(data, m_fds->strBufs(), *m_fd,
+                                              m_fds->cv(), m_fds->trimPadChar);
+    case ft_note:
+    case ft_zstring:
+        return read<zstringStore, char, WCHAR>(data, m_fds->strBufs(), *m_fd,
+                                               m_fds->cv());
+    case ft_wzstring:
+        return read<wzstringStore, WCHAR, WCHAR>(data, m_fds->strBufs(), *m_fd,
+                                                 m_fds->cv());
+    case ft_wstring:
+        return read<wstringStore, WCHAR, WCHAR>(
+            data, m_fds->strBufs(), *m_fd, m_fds->cv(), m_fds->trimPadChar);
+    case ft_mychar:
+        return read<myCharStore, char, WCHAR>(data, m_fds->strBufs(), *m_fd,
+                                              m_fds->cv(), m_fds->trimPadChar);
+    case ft_myvarchar:
+        return read<myVarCharStore, char, WCHAR>(data, m_fds->strBufs(), *m_fd,
+                                                 m_fds->cv());
+    case ft_lstring:
+    case ft_myvarbinary:
+        return read<myVarBinaryStore, char, WCHAR>(data, m_fds->strBufs(),
+                                                   *m_fd, m_fds->cv());
+    case ft_mywchar:
+        return read<myWcharStore, WCHAR, WCHAR>(
+            data, m_fds->strBufs(), *m_fd, m_fds->cv(), m_fds->trimPadChar);
+    case ft_mywvarchar:
+        return read<myWvarCharStore, WCHAR, WCHAR>(data, m_fds->strBufs(),
+                                                   *m_fd, m_fds->cv());
+    case ft_mywvarbinary:
+        return read<myWvarBinaryStore, WCHAR, WCHAR>(data, m_fds->strBufs(),
+                                                     *m_fd, m_fds->cv());
+    case ft_myblob:
+    case ft_mytext:
+        return readBlob<WCHAR>(data, m_fds->strBufs(), *m_fd, m_fds->cv());
+    }
+    wchar_t* p = (wchar_t*)m_fds->strBufs()->getPtrW(max(m_fd->len * 2, 50));
+
+    wchar_t buf[10] = L"%0.";
+
+    switch (m_fd->type)
+    {
+
+    case ft_integer:
+    case ft_bit:
+    case ft_autoinc:
+        _i64tow_s(getFV64(), p, 50, 10);
+        return p;
+    case ft_logical:
+        if (m_fds->logicalToString)
+        {
+            if (getFVlng())
+                return L"Yes";
+            else
+                return L"No";
+        }
+        else
+            _i64tow_s(getFV64(), p, 50, 10);
+
+    case ft_bfloat:
+    case ft_float:
+    case ft_currency:
+    {
+
+        swprintf_s(p, 50, L"%lf", getFVdbl());
+        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_autoIncUnsigned:
+    case ft_uinteger:
+        swprintf_s(p, 50, L"%lu", getFV64());
+        break;
+    case ft_date:
+        return btrdtoa(getFVlng(), p);
+    case ft_time:
+        return btrttoa(getFVlng(), p);
+    case ft_mydate:
+    {
+        myDate d;
+        d.setValue((int)getValue64(*m_fd, (const uchar_td*)m_ptr));
+        return d.toStr(p, m_fds->myDateTimeValueByBtrv);
+    }
+    case ft_mytime:
+    {
+
+        myTime t(m_fd->len);
+        t.setValue(getValue64(*m_fd, (const uchar_td*)m_ptr));
+        return t.toStr(p);
+    }
+    case ft_mydatetime:
+    {
+        myDateTime t(m_fd->len);
+        t.setValue(getFV64());
+        return t.toStr(p);
+    }
+    case ft_mytimestamp:
+    {
+        myTimeStamp ts(m_fd->len);
+        ts.setValue(getFV64());
+        return ts.toStr(p);
+    }
+    case ft_decimal:
+    case ft_money:
+    case ft_numeric:
+    case ft_numericsts:
+    case ft_numericsa:
+        _ltow_s(m_fd->decimals, p, 50, 10);
+        wcscat(buf, p);
+        wcscat(buf, L"lf");
+        swprintf(p, 50, buf, getFVdbl());
+        break;
+    case ft_lvar:
+        return NULL;
+    case ft_timestamp:
+        return btrTimeStamp(getFV64()).toString(p);
+    default:
+        p[0] = 0x00;
+    }
+    return p;
+}
+
+#endif //_WIN32
+
+const char* field::getFVAstr() const
+{
+    if (!m_ptr)
+        return "";
+
+    char buf[10] = "%0.";
+
+    char* data = (char*)m_ptr + m_fd->pos;
+    switch (m_fd->type)
+    {
+
+    case ft_string:
+        return read<stringStore, char, char>(data, m_fds->strBufs(), *m_fd,
+                                             m_fds->cv(), m_fds->trimPadChar);
+    case ft_note:
+    case ft_zstring:
+        return read<zstringStore, char, char>(data, m_fds->strBufs(), *m_fd,
+                                              m_fds->cv());
+    case ft_wzstring:
+        return read<wzstringStore, WCHAR, char>(data, m_fds->strBufs(), *m_fd,
+                                                m_fds->cv());
+    case ft_wstring:
+        return read<wstringStore, WCHAR, char>(data, m_fds->strBufs(), *m_fd,
+                                               m_fds->cv(), m_fds->trimPadChar);
+    case ft_mychar:
+        return read<myCharStore, char, char>(data, m_fds->strBufs(), *m_fd,
+                                             m_fds->cv(), m_fds->trimPadChar);
+    case ft_myvarchar:
+        return read<myVarCharStore, char, char>(data, m_fds->strBufs(), *m_fd,
+                                                m_fds->cv());
+    case ft_lstring:
+    case ft_myvarbinary:
+        return read<myVarBinaryStore, char, char>(data, m_fds->strBufs(), *m_fd,
+                                                  m_fds->cv());
+    case ft_mywchar:
+        return read<myWcharStore, WCHAR, char>(data, m_fds->strBufs(), *m_fd,
+                                               m_fds->cv(), m_fds->trimPadChar);
+    case ft_mywvarchar:
+        return read<myWvarCharStore, WCHAR, char>(data, m_fds->strBufs(), *m_fd,
+                                                  m_fds->cv());
+    case ft_mywvarbinary:
+        return read<myWvarBinaryStore, WCHAR, char>(data, m_fds->strBufs(),
+                                                    *m_fd, m_fds->cv());
+    case ft_myblob:
+    case ft_mytext:
+        return readBlob<char>(data, m_fds->strBufs(), *m_fd, m_fds->cv());
+    }
+    char* p = m_fds->strBufs()->getPtrA(max(m_fd->len * 2, 50));
+    switch (m_fd->type)
+    {
+    case ft_integer:
+    case ft_bit:
+    case ft_autoinc:
+        _i64toa_s(getFV64(), p, 50, 10);
+        return p;
+    case ft_logical:
+        if (m_fds->logicalToString)
+        {
+            if (getFVlng())
+                return "Yes";
+            else
+                return "No";
+        }
+        else
+            _i64toa_s(getFV64(), p, 50, 10);
+        break;
+    case ft_bfloat:
+    case ft_float:
+    case ft_currency:
+    {
+        sprintf(p, "%lf", getFVdbl());
+        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(), p);
+    case ft_time:
+        return btrttoa(getFVlng(), p);
+    case ft_autoIncUnsigned:
+    case ft_uinteger:
+        sprintf_s(p, 50, "%llu", (unsigned __int64)getFV64());
+        break;
+
+    case ft_mydate:
+    {
+        myDate d;
+        d.setValue((int)getValue64(*m_fd, (const uchar_td*)m_ptr));
+        return d.toStr(p, m_fds->myDateTimeValueByBtrv);
+    }
+    case ft_mytime:
+    {
+        myTime t(m_fd->len);
+        t.setValue(getValue64(*m_fd, (const uchar_td*)m_ptr));
+        return t.toStr(p);
+    }
+    case ft_mytimestamp:
+    {
+        myTimeStamp ts(m_fd->len);
+        ts.setValue(getFV64());
+        return ts.toStr(p);
+    }
+    case ft_mydatetime:
+    {
+        myDateTime t(m_fd->len);
+        t.setValue(getFV64());
+        return t.toStr(p);
+    }
+    case ft_decimal:
+    case ft_money:
+    case ft_numeric:
+    case ft_numericsts:
+    case ft_numericsa:
+        _ltoa_s(m_fd->decimals, p, 50, 10);
+        strcat(buf, p);
+        strcat(buf, "lf");
+        sprintf_s(p, 50, buf, getFVdbl());
+        break;
+    case ft_lvar:
+        return NULL;
+    case ft_timestamp:
+        return btrTimeStamp(getFV64()).toString(p);
+    default:
+        p[0] = 0x00;
+    }
+    return p;
+}
+
+int field::getFVint() const
+{
+    return (int)getFVlng();
+}
+
+__int64 field::getFV64() const
+{
+    if (!m_ptr)
+        return 0;
+
+    switch (m_fd->len)
+    {
+    case 8:
+        switch (m_fd->type)
+        {
+        case ft_autoIncUnsigned:
+        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_ptr + m_fd->pos));
+        }
+        return 0;
+    case 7:
+    case 6:
+    case 5:
+        switch (m_fd->type)
+        {
+        case ft_mytime:
+        case ft_mydatetime:
+        case ft_mytimestamp:
+        {
+            __int64 v = 0;
+            memcpy(&v, (char*)m_ptr + m_fd->pos, m_fd->len);
+            return v;
+        }
+        }
+        return 0;
+    default:
+
+        return (__int64)getFVlng();
+    }
+}
+
+void field::setFV(__int64 data)
+{
+    if (!m_ptr)
+        return;
+
+    switch (m_fd->len)
+    {
+    case 8:
+        switch (m_fd->type)
+        {
+        case ft_autoIncUnsigned:
+        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_ptr + m_fd->pos)) = data;
+            break;
+        case ft_timestamp:
+        {
+            btrDate d;
+            d.i = getNowDate();
+            btrTime t;
+            t.i = getNowTime();
+            *((__int64*)((char*)m_ptr + m_fd->pos)) = btrTimeStamp(d, t).i64;
+            break;
+        }
+        case ft_float:
+        {
+            double d = (double)data;
+            setFV(d);
+            break;
+        }
+        }
+        break;
+    case 7:
+    case 6:
+    case 5:
+        switch (m_fd->type)
+        {
+        case ft_mytime:
+        case ft_mydatetime:
+        case ft_mytimestamp:
+            memcpy((char*)m_ptr + m_fd->pos, &data, m_fd->len);
+            break;
+        default:
+            break;
+        }
+        break;
+    default:
+    {
+        int value = (int)data;
+        setFV(value);
+        break;
+    }
+    }
+}
+
+/* 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 field::setFV(const void* data, uint_td size)
+{
+    if (!m_ptr)
+        return;
+    switch (m_fd->type)
+    {
+    case ft_myvarbinary:
+    case ft_myvarchar:
+    case ft_mywvarbinary:
+    case ft_mywvarchar:
+    case ft_lstring:
+    {
+        int sizeByte = m_fd->varLenBytes();
+        size = std::min<uint_td>((uint_td)(m_fd->len - sizeByte), size);
+        memset((char*)m_ptr + m_fd->pos, 0, m_fd->len);
+        memcpy((char*)m_ptr + m_fd->pos, &size, sizeByte);
+        memcpy((char*)m_ptr + m_fd->pos + sizeByte, data, size);
+        break;
+    }
+    case ft_myblob:
+    case ft_mytext:
+    {
+        int sizeByte = m_fd->len - 8;
+        memset((char*)m_ptr + m_fd->pos, 0, m_fd->len);
+        memcpy((char*)m_ptr + m_fd->pos, &size, sizeByte);
+        memcpy((char*)m_ptr + m_fd->pos + sizeByte, &data, sizeof(char*));
+        break;
+    }
+    case ft_lvar:
+    {
+        int sizeByte = 2;
+        size = std::min<uint_td>((uint_td)(m_fd->len - sizeByte), size);
+        memset((char*)m_ptr + m_fd->pos, 0, m_fd->len);
+        memcpy((char*)m_ptr + m_fd->pos, &size, sizeByte);
+        memcpy((char*)m_ptr + m_fd->pos + sizeByte, data, size);
+        break;
+    }
+    default:
+        size = std::min<uint_td>((uint_td)m_fd->len, size);
+        memset((char*)m_ptr + m_fd->pos, 0, m_fd->len);
+        memcpy((char*)m_ptr + m_fd->pos, data, size);
+    }
+}
+
+/* offset is writen at data that is first address of data
+ *  text is not converted to unicode form stored charset.
+ */
+void* field::getFVbin(uint_td& size) const
+{
+    if (!m_ptr)
+        return 0;
+
+    switch (m_fd->type)
+    {
+    case ft_myvarbinary:
+    case ft_myvarchar:
+    case ft_mywvarbinary:
+    case ft_mywvarchar:
+    case ft_lstring:
+    {
+        int sizeByte = m_fd->varLenBytes();
+        size = 0;
+        memcpy(&size, (char*)m_ptr + m_fd->pos, sizeByte);
+        return (void*)((char*)m_ptr + m_fd->pos + sizeByte);
+    }
+    case ft_myblob:
+    case ft_mytext:
+    {
+        int sizeByte = m_fd->len - 8;
+        size = 0;
+        memcpy(&size, (char*)m_ptr + m_fd->pos, sizeByte);
+        char** ptr = (char**)((char*)m_ptr + m_fd->pos + sizeByte);
+        return (void*)*ptr;
+    }
+    case ft_lvar:
+    {
+        int sizeByte = 2;
+        size = 0;
+        memcpy(&size, (char*)m_ptr + m_fd->pos, sizeByte);
+        return (void*)((char*)m_ptr + m_fd->pos + sizeByte);
+    }
+    }
+    return NULL;
+}
+
+double field::getFVDecimal() const
+{
+    if (!m_ptr)
+        return 0;
+
+    unsigned char buf[20] = { 0x00 };
+    char result[30] = { 0x00 };
+    char n[10];
+    int i;
+    char* t;
+    unsigned char sign;
+    int len = m_fd->len;
+    result[0] = '+';
+    memcpy(buf, (void*)((char*)m_ptr + m_fd->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_fd->len * 2) - m_fd->decimals;
+    strcpy((char*)buf, t);
+    *t = '.';
+    strcpy(t + 1, (char*)buf);
+    return atof(result);
+}
+
+double field::getFVnumeric() const
+{
+    if (!m_ptr)
+        return 0;
+
+    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_ptr + m_fd->pos), m_fd->len);
+
+    t = &(buf[m_fd->len]);
+
+    switch (m_fd->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_fd->decimals;
+    strcpy(dummy, t);
+    *t = '.';
+    strcpy(t + 1, dummy);
+    return atof(buf);
+}
+
+void field::setFVDecimal(double data)
+{ // Double  -> Decimal
+    if (!m_ptr)
+        return;
+
+    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_fd->len) * 2;
+    _ltoa_s(point, dummy, 30, 10);
+    strcat(buf, dummy);
+    strcat(buf, ".");
+    _ltoa_s(m_fd->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_fd->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_ptr + m_fd->pos), buf, m_fd->len);
+}
+
+void field::setFVNumeric(double data)
+{ // Double  -> Numeric
+    if (!m_ptr)
+        return;
+
+    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_fd->len + 1;
+
+    _ltoa_s(point, dummy, 30, 10);
+    strcat(buf, dummy);
+    strcat(buf, ".");
+    _ltoa_s(m_fd->decimals, dummy, 30, 10);
+    strcat(buf, dummy);
+    strcat(buf, "lf");
+    sprintf(dummy, buf, data);
+    if (dummy[0] == '-')
+        sign = true;
+
+    strcpy(buf, &dummy[point - m_fd->decimals] + 1);
+    dummy[point - m_fd->decimals] = 0x00;
+    strcat(dummy, buf);
+
+    n = atol(&dummy[m_fd->len]);
+    if (sign)
+        n += 10;
+    t = dummy + 1;
+    switch (m_fd->type)
+    {
+    case ft_numeric:
+        dummy[m_fd->len] = dp[n];
+        break;
+    case ft_numericsa:
+        dummy[m_fd->len] = dpsa[n];
+        break;
+    case ft_numericsts:
+        if (sign)
+            strcat(dummy, "-");
+        else
+            strcat(dummy, "+");
+        t += 1;
+        break;
+    }
+
+    memcpy((void*)((char*)m_ptr + m_fd->pos), t, m_fd->len);
+}
+
+template <class T>
+inline int compNumber(const field& l, const field& r, char logType)
+{
+    return compare<T>((const char*)l.ptr(), (const char*)r.ptr());
+}
+
+inline int compNumber24(const field& l, const field& r, char logType)
+{
+    return compareInt24((const char*)l.ptr(), (const char*)r.ptr());
+}
+
+inline int compNumberU24(const field& l, const field& r, char logType)
+{
+    return compareUint24((const char*)l.ptr(), (const char*)r.ptr());
+}
+
+inline int compMem(const field& l, const field& r, char logType)
+{
+    return memcmp((const char*)l.ptr(), (const char*)r.ptr(), l.len());
+}
+
+inline int compString(const field& l, const field& r, char logType)
+{
+    return strncmp((const char*)l.ptr(), (const char*)r.ptr(), l.len());
+}
+
+inline int compiString(const field& l, const field& r, char logType)
+{
+    return _strnicmp((const char*)l.ptr(), (const char*)r.ptr(), l.len());
+}
+
+inline int compWString(const field& l, const field& r, char logType)
+{
+    return wcsncmp16((char16_t*)l.ptr(), (char16_t*)r.ptr(), l.len());
+}
+
+inline int compiWString(const field& l, const field& r, char logType)
+{
+    return wcsnicmp16((char16_t*)l.ptr(), (char16_t*)r.ptr(), l.len());
+}
+
+template <class T>
+inline int compVarString(const field& l, const field& r, char logType)
+{
+    return compareVartype<T>((const char*)l.ptr(), (const char*)r.ptr(),
+                             l.type() == ft_myvarbinary, logType);
+}
+
+template <class T>
+inline int compWVarString(const field& l, const field& r, char logType)
+{
+    return compareWvartype<T>((const char*)l.ptr(), (const char*)r.ptr(),
+                              l.type() == ft_mywvarbinary, logType);
+}
+
+inline int compBlob(const field& l, const field& r, char logType)
+{
+    return compareBlobType((const char*)l.ptr(), (const char*)r.ptr(),
+                           l.type() == ft_myblob, logType, l.blobLenBytes());
+}
+
+compFieldFunc field::getCompFunc(char logType) const
+{
+    switch (m_fd->type)
+    {
+    case ft_integer:
+    case ft_autoinc:
+    case ft_currency:
+    {
+        switch (m_fd->len)
+        {
+        case 1:
+            return &compNumber<char>;
+        case 2:
+            return &compNumber<short>;
+        case 3:
+            return &compNumber24;
+        case 4:
+            return &compNumber<int>;
+        case 8:
+            return &compNumber<__int64>;
+        }
+    }
+    case ft_mychar:
+    case ft_string:
+        if (logType & CMPLOGICAL_CASEINSENSITIVE)
+            return &compiString;
+        return &compMem;
+    case ft_zstring:
+    case ft_note:
+        if (logType & CMPLOGICAL_CASEINSENSITIVE)
+            return &compiString;
+        return &compString;
+    case ft_logical:
+    case ft_uinteger:
+    case ft_autoIncUnsigned:
+    case ft_date:
+    case ft_time:
+    case ft_timestamp:
+    case ft_mydate:
+    {
+        switch (m_fd->len)
+        {
+        case 1:
+            return &compNumber<unsigned char>;
+        case 2:
+            return &compNumber<unsigned short>;
+        case 3:
+            return &compNumberU24;
+        case 4:
+            return &compNumber<unsigned int>;
+        case 8:
+            return &compNumber<unsigned __int64>;
+        }
+    }
+    case ft_mytime:
+    case ft_mydatetime:
+    case ft_mytimestamp:
+        return &compMem;
+    case ft_float:
+        switch (m_fd->len)
+        {
+        case 4:
+            return &compNumber<float>;
+        case 8:
+            return &compNumber<double>;
+        }
+    case ft_mywchar:
+    case ft_wstring:
+    case ft_wzstring:
+        if (logType & CMPLOGICAL_CASEINSENSITIVE)
+            return &compiWString;
+        if ((m_fd->type == ft_wstring) || (m_fd->type == ft_mywchar))
+            return &compMem;
+        return &compWString;
+    case ft_lstring:
+    case ft_myvarchar:
+    case ft_myvarbinary:
+        if (m_fd->varLenBytes() == 1)
+            return &compVarString<unsigned char>;
+        return &compVarString<unsigned short>;
+    case ft_mywvarchar:
+    case ft_mywvarbinary:
+        if (m_fd->varLenBytes() == 1)
+            return &compWVarString<unsigned char>;
+        return &compWVarString<unsigned short>;
+    case ft_mytext:
+    case ft_myblob:
+        return &compBlob;
+    }
+    return NULL;
+}
+
+int field::comp(const field& r, char logType) const
+{
+    compFieldFunc f = getCompFunc(logType);
+    return f(*this, r, logType);
+}
+
+bool field::isCompPartAndMakeValue()
+{
+    bool ret = false;
+    if (m_fd->isStringType())
+    {
+        _TCHAR* p = (_TCHAR*)getFVstr();
+        if (p)
+        {
+            size_t n = _tcslen(p);
+            if (n && ((ret = (p[n - 1] == _T('*'))) != 0))
+            {
+                p[n - 1] = 0x00;
+                setFV(p);
+            }
+        }
+        else
+            setFV(_T(""));
+    }
+    return ret;
+}
+
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs