MyField.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <float.h>  // FLT_MIN, FLT_MAX
#include <math.h>   // modf
#include <string.h> // memcpy
 
#include <dcl/Object.h>
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/size_t.h>
#include <dcl/SQLCore.h>
#include <dcl/OutputStream.h>
#include <dcl/Charset.h>
 
#include "MyConnection.h"
#include "MyQuery.h"
#include "MyField.h"
 
#define __TRACE_THIS    0
#if __TRACE_THIS
#define __DCL_TRACE0_N  __DCL_TRACE0
#define __DCL_TRACE1_N  __DCL_TRACE1
#define __DCL_TRACE2_N  __DCL_TRACE2
#define __DCL_TRACE3_N  __DCL_TRACE3
#define __DCL_TRACE4_N  __DCL_TRACE4
#else
#define __DCL_TRACE0_N(fmt)
#define __DCL_TRACE1_N(fmt, arg)
#define __DCL_TRACE2_N(fmt, arg1, arg2)
#define __DCL_TRACE3_N(fmt, arg1, arg2, arg3)
#define __DCL_TRACE4_N(fmt, arg1, arg2, arg3, arg4)
#endif
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const wchar_t __THIS_FILE__[] = __T("dcl/sql/MyField.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(MyField, SQL::Field)
 
MyField::MyField()
    : Field(NULL)
{
    __index = 0;
    __field = NULL;
    __bind = NULL;
}
 
MyField::~MyField()
{
    __DCL_TRACE1_N(L"~MyField [%ls]\n", Field::__name.data());
}
 
bool MyField::init(SQL::Query* _queryHandle,
    unsigned int _index, MYSQL_FIELD* _field, MYSQL_BIND* _bind)
{
    __DCL_ASSERT((_queryHandle != NULL) && (_field != NULL));
 
    Field::__queryHandle = _queryHandle;
    __index = _index;
    __field = _field;
    __bind = _bind;
 
    try {
        Field::__name = UTF8Decoder::decode(_field->name).toUpperCase();
    }
    catch (CharsetConvertException* _e) {
        __SET_ERROR_MSG(UTF8Encoder::encode(_e->toStringAll()));
        _e->destroy();
        return false;
    }
 
    __DCL_TRACE2_N(L"[%ls] decimals[%u]\n", __name.data(), _field->decimals);
    Field::__scale = _field->decimals;
 
    enum enum_field_types _type = __field->type;
    unsigned int _flags = __field->flags;
 
    switch(_type) {
        case MYSQL_TYPE_TINY: {
            if (_flags & UNSIGNED_FLAG) {
                Field::__precision = _field->length;
                Field::__dataType = SQL::typeUInteger;
            }
            else {
                Field::__precision = _field->length - 1;
                Field::__dataType = SQL::typeInteger;
            }
            __maxsize = sizeof(int8_t);
            break;
        }
        case MYSQL_TYPE_YEAR:
        case MYSQL_TYPE_SHORT: {
            if (_flags & UNSIGNED_FLAG) {
                Field::__precision = _field->length;
                Field::__dataType = SQL::typeUInteger;
            }
            else {
                Field::__precision = _field->length - 1;
                Field::__dataType = SQL::typeInteger;
            }
            __maxsize = sizeof(int16_t);
            break;
        }
        case MYSQL_TYPE_INT24:
        case MYSQL_TYPE_LONG: {
            if (_flags & UNSIGNED_FLAG) {
                Field::__precision = _field->length;
                Field::__dataType = SQL::typeUInteger;
            }
            else {
                Field::__precision = _field->length - 1;
                Field::__dataType = SQL::typeInteger;
            }
            __maxsize = sizeof(int32_t);
            break;
        }
        case MYSQL_TYPE_LONGLONG: {
            if (_flags & UNSIGNED_FLAG) {
                Field::__precision = _field->length;
                Field::__dataType = SQL::typeUInteger;
            }
            else {
                Field::__precision = _field->length - 1;
                Field::__dataType = SQL::typeInteger;
            }
            __maxsize = sizeof(int64_t);
            break;
        }
        case MYSQL_TYPE_FLOAT: {
            Field::__precision = _field->length - 1;
            Field::__dataType = SQL::typeFloat;
            __maxsize = sizeof(float);
            break;
        }
        case MYSQL_TYPE_DOUBLE: {
            Field::__precision = _field->length - 1;
            Field::__dataType = SQL::typeFloat;
            __maxsize = sizeof(double);
            break;
        }
        case MYSQL_TYPE_NULL: {
            Field::__dataType = SQL::typeUnknown;
            __maxsize = 0;
            break;
        }
        case MYSQL_TYPE_TIMESTAMP:
        case MYSQL_TYPE_DATETIME:
        case MYSQL_TYPE_TIMESTAMP2:
        case MYSQL_TYPE_DATETIME2: {
            Field::__precision = _field->length;
            Field::__dataType = SQL::typeTimeStamp;
            __maxsize = sizeof(SQL::TimeStamp);
            break;
        }
        case MYSQL_TYPE_DATE:
        case MYSQL_TYPE_NEWDATE : {
            Field::__precision = _field->length;
            Field::__dataType = SQL::typeDate;
            __maxsize = sizeof(SQL::Date);
            break;
        }
        case MYSQL_TYPE_TIME:
        case MYSQL_TYPE_TIME2: {
            Field::__precision = _field->length - 2;
            Field::__dataType = SQL::typeIntervalDs;
            __maxsize = sizeof(SQL::Interval);
            break;
        }
        case MYSQL_TYPE_DECIMAL:
        case MYSQL_TYPE_NEWDECIMAL: {
            Field::__precision = _field->length - (_field->decimals == 0 ? 1 : 2);
            Field::__dataType = SQL::typeNumeric;
            __maxsize = _field->length;
            break;
        }
        case MYSQL_TYPE_BIT: {
            Field::__precision = _field->length;
            Field::__dataType = SQL::typeBinary;
            __maxsize = sizeof(int64_t);
            break;
        }
        case MYSQL_TYPE_JSON:
        case MYSQL_TYPE_ENUM:
        case MYSQL_TYPE_SET:
        case MYSQL_TYPE_VAR_STRING:
        case MYSQL_TYPE_STRING:
        case MYSQL_TYPE_GEOMETRY: {
            Field::__dataType = _flags & BINARY_FLAG ?
                SQL::typeBinary : SQL::typeText;
            __maxsize = _field->length;
            break;
        }
        case MYSQL_TYPE_TINY_BLOB :
        case MYSQL_TYPE_BLOB :
        case MYSQL_TYPE_MEDIUM_BLOB :
        case MYSQL_TYPE_LONG_BLOB: {
            if (_flags & BINARY_FLAG) {
                Field::__dataType = _field->length <= ((uint16_t)-1 * 3) ?
                    SQL::typeBinary : SQL::typeLongBinary;
            }
            else {
                Field::__dataType = _field->length <= ((uint16_t)-1 * 3) ?
                    SQL::typeText : SQL::typeLongText;
            }
            __maxsize = _field->length;
            break;
        }
        default: {
            __DCL_ASSERT(false);
        }
    }
 
    return true;
}
 
#define SQLTYPE_NAME(type, name) case type : return name
 
const wchar_t* __dataTypeName(enum_field_types _type, unsigned int _flags)
{
    switch(_type) {
        SQLTYPE_NAME(MYSQL_TYPE_DECIMAL,    L"DECIMAL");
        case MYSQL_TYPE_TINY :
            if (_flags & UNSIGNED_FLAG)
                return                      L"TINYINT UNSIGNED";
            return                          L"TINYINT";
        case MYSQL_TYPE_SHORT :
            if (_flags & UNSIGNED_FLAG)
                return                      L"SMALLINT UNSIGNED";
            return                          L"SMALLINT";
        case MYSQL_TYPE_LONG:
            if (_flags & UNSIGNED_FLAG)
                return                      L"INTEGER UNSIGNED";
            return                          L"INTEGER";
        SQLTYPE_NAME(MYSQL_TYPE_FLOAT,      L"FLOAT");
        SQLTYPE_NAME(MYSQL_TYPE_DOUBLE,     L"DOUBLE");
        SQLTYPE_NAME(MYSQL_TYPE_NULL,       L"NULL-TYPE");
        SQLTYPE_NAME(MYSQL_TYPE_TIMESTAMP,  L"TIMESTAMP");
        case MYSQL_TYPE_LONGLONG:
            if (_flags & UNSIGNED_FLAG)
                return                      L"BIGINT UNSIGNED";
            return                          L"BIGINT";
        case MYSQL_TYPE_INT24 :
            if (_flags & UNSIGNED_FLAG)
                return                      L"MEDIUMINT UNSIGNED";
            return                          L"MEDIUMINT";
        SQLTYPE_NAME(MYSQL_TYPE_DATE,       L"DATE");
        SQLTYPE_NAME(MYSQL_TYPE_TIME,       L"TIME");
        SQLTYPE_NAME(MYSQL_TYPE_DATETIME,   L"DATETIME");
        SQLTYPE_NAME(MYSQL_TYPE_YEAR,       L"YEAR");
        SQLTYPE_NAME(MYSQL_TYPE_NEWDATE,    L"NEWDATE");
        SQLTYPE_NAME(MYSQL_TYPE_VARCHAR,    L"VARCHAR");
        SQLTYPE_NAME(MYSQL_TYPE_BIT,        L"BIT");
        SQLTYPE_NAME(MYSQL_TYPE_TIMESTAMP2, L"TIMESTAMP2");
        SQLTYPE_NAME(MYSQL_TYPE_DATETIME2,  L"DATETIME");
        SQLTYPE_NAME(MYSQL_TYPE_TIME2,      L"TIME2");
        SQLTYPE_NAME(MYSQL_TYPE_JSON,       L"JSON");
        SQLTYPE_NAME(MYSQL_TYPE_NEWDECIMAL, L"NEWDECIMAL");
        SQLTYPE_NAME(MYSQL_TYPE_ENUM,       L"ENUM");
        SQLTYPE_NAME(MYSQL_TYPE_SET,        L"SET");
        case MYSQL_TYPE_TINY_BLOB :                 // 2^8
            if (_flags & BINARY_FLAG)
                return L"TINYBLOB";
            return L"TINYTEXT";
        case MYSQL_TYPE_MEDIUM_BLOB:                // 2^24
            if (_flags & BINARY_FLAG)
                return L"MEDIUMBLOB";
            return L"MEDIUMTEXT";
        case MYSQL_TYPE_LONG_BLOB:                  // 2^32
            if (_flags & BINARY_FLAG)
                return L"LONGBLOB";
            return L"LONGTEXT";
        case MYSQL_TYPE_BLOB :                      // 2^16
            if (_flags & BINARY_FLAG)
                return L"BLOB";
            return L"TEXT";
        SQLTYPE_NAME(MYSQL_TYPE_VAR_STRING, L"VAR STRING");
        SQLTYPE_NAME(MYSQL_TYPE_STRING,     L"STRING");
        SQLTYPE_NAME(MYSQL_TYPE_GEOMETRY,   L"GEOMETRY");
        SQLTYPE_NAME(MAX_NO_FIELD_TYPES,    L"MAX_NO_FIELD_TYPES");
        default: 
            ;
    }
    return L"Unknown Type: Driver Not Support";
}
 
const wchar_t* MyField::serverDataTypeName() const
{
    return __dataTypeName(__field->type, __field->flags);
}
 
bool MyField::isNull() const
{  
    if (!query()->inState(SQL::Query::stFetched)) {
        return true;
    }
    return __bind->is_null_value;
}
 
bool MyField::__getDataSize(size_t* _psize, bool _maxsize) 
{
    if (_maxsize) {
        *_psize = __maxsize;
        return true;
    }
 
    if (!query()->inState(SQL::Query::stFetched)) {
        __SET_ERROR(SQL::eNotFetched);
        return false;
    }
 
    switch (Field::__dataType) {
    case SQL::typeInteger:
    case SQL::typeUInteger:
    case SQL::typeFloat:
    case SQL::typeDate:
    case SQL::typeTime:
    case SQL::typeTimeStamp:
    case SQL::typeTimeStampTz:
    case SQL::typeInterval:
    case SQL::typeIntervalYm:
    case SQL::typeIntervalDs:
        *_psize = __maxsize;
        break;
    default:
        *_psize = __bind->length_value;
    }
 
    return true;
}
 
#define __TYPE_IS(_type)    (__field->type == _type)
 
bool MyField::__getData(void* _pv, size_t* _psize, SQL::DataType _dataType)
{
    if (!query()->inState(SQL::Query::stFetched)) {
        __SET_ERROR(SQL::eNotFetched);
        return false;
    }
 
    switch(_dataType) {
        case SQL::typeInteger :
            return  getInteger(_pv, _psize);
        case SQL::typeUInteger :
            return getUInteger(_pv, _psize);
        case SQL::typeFloat :
            return getFloat(_pv, _psize);
        case SQL::typeDate :
            return getDate((SQL::Date*)_pv, _psize);
        case SQL::typeTimeStamp :
            return getTimeStamp((SQL::TimeStamp*)_pv, _psize);
        case SQL::typeTime:
            return getTime((SQL::Time*)_pv, _psize);
        case SQL::typeInterval:
            return getInterval((SQL::Interval*)_pv, _psize);
        case SQL::typeText:
        case SQL::typeBinary: {
            __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_DECIMAL)
                || __TYPE_IS(MYSQL_TYPE_NEWDECIMAL)
                || __TYPE_IS(MYSQL_TYPE_BIT)
                || __TYPE_IS(MYSQL_TYPE_JSON)
                || __TYPE_IS(MYSQL_TYPE_ENUM)
                || __TYPE_IS(MYSQL_TYPE_SET)
                || __TYPE_IS(MYSQL_TYPE_VAR_STRING)
                || __TYPE_IS(MYSQL_TYPE_STRING)
                || __TYPE_IS(MYSQL_TYPE_GEOMETRY)
                || __TYPE_IS(MYSQL_TYPE_TINY_BLOB)
                || __TYPE_IS(MYSQL_TYPE_BLOB)
                || __TYPE_IS(MYSQL_TYPE_MEDIUM_BLOB)
                || __TYPE_IS(MYSQL_TYPE_LONG_BLOB)
                );
            if (*_psize < __bind->length_value) {
                __SET_ERROR(SQL::eInvalidBufferSize);
                return false;
            }
            if (__bind->buffer_length) {
                // 버퍼가 할당되어 있으면, 이것을 복사한다.
                memcpy(_pv, __bind->buffer, __bind->length_value);
            }
            else {
                __DCL_TRACE2_N(L"b[%u][%u]\n",
                    __bind->buffer_length, __bind->length_value);
                MYSQL_BIND bind;
                memset(&bind, 0, sizeof(bind));
                bind.buffer = _pv;
                bind.buffer_length = *_psize;
                if (mysql_stmt_fetch_column(query()->stmt(), &bind, __index, 0)) {
                    __SET_ERROR_MSG(ByteString::format("(%u) %hs",
                        mysql_stmt_errno(query()->stmt()),
                        mysql_stmt_error(query()->stmt())));
                    return false;
                }
            }
            if (*_psize > __bind->length_value)
                *((char*)_pv + __bind->length_value) = '\0';
            *_psize = __bind->length_value;
            break;
        }
        case SQL::typeOutputStream: {
            __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_DECIMAL)
                || __TYPE_IS(MYSQL_TYPE_NEWDECIMAL)
                || __TYPE_IS(MYSQL_TYPE_BIT)
                || __TYPE_IS(MYSQL_TYPE_JSON)
                || __TYPE_IS(MYSQL_TYPE_ENUM)
                || __TYPE_IS(MYSQL_TYPE_SET)
                || __TYPE_IS(MYSQL_TYPE_VAR_STRING)
                || __TYPE_IS(MYSQL_TYPE_STRING)
                || __TYPE_IS(MYSQL_TYPE_GEOMETRY)
                || __TYPE_IS(MYSQL_TYPE_TINY_BLOB)
                || __TYPE_IS(MYSQL_TYPE_BLOB)
                || __TYPE_IS(MYSQL_TYPE_MEDIUM_BLOB)
                || __TYPE_IS(MYSQL_TYPE_LONG_BLOB)
            );
            if (__bind->length_value < *_psize) {
                *_psize = __bind->length_value;
            }
            try {
                char buf[4096];
                MYSQL_BIND bind;
                memset(&bind, 0, sizeof(bind));
                bind.buffer = buf;
                bind.length = &bind.length_value;
                unsigned long total = 0;
                while (total < *_psize) {
                    bind.buffer_length = __MIN(sizeof(buf), *_psize - total);
                    if (mysql_stmt_fetch_column(query()->stmt(),
                        &bind, __index, total)) {
                        __SET_ERROR_MSG(ByteString::format("(%u) %hs",
                            mysql_stmt_errno(query()->stmt()),
                            mysql_stmt_error(query()->stmt())));
                        return false;
                    }
                    ((OutputStream*)_pv)->write(bind.buffer, bind.buffer_length);
                    total += bind.buffer_length;
                    __DCL_TRACE2_N(L"mysql_stmt_fetch_column [%u][%u]\n",
                        bind.buffer_length, bind.length_value);
                }               
            }
            catch (IOException* e) {
                __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
                e->destroy();
                return false;
            }
            break;
        }
        default :
            __DCL_ASSERT(false);        // SQL::Field::getData bug
    }
 
    return true;
}
 
bool MyField::getInteger(void* _pv, size_t* _psize)
{
    __DCL_ASSERT(!(__field->flags & UNSIGNED_FLAG));
 
    switch (__field->type) {
        case MYSQL_TYPE_TINY: {
            switch (*_psize) {
                case sizeof(int8_t) : {
                    *(int8_t*)_pv = *(int8_t*)__bind->buffer;
                    break;
                }
                case sizeof(int16_t) : {
                    *(int16_t*)_pv = *(int8_t*)__bind->buffer;
                    break;
                }
                case sizeof(int32_t) : {
                    *(int32_t*)_pv = *(int8_t*)__bind->buffer;
                    break;
                }
                case sizeof(int64_t) : {
                    *(int64_t*)_pv = *(int8_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(int8_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_YEAR : 
        case MYSQL_TYPE_SHORT : {
            switch (*_psize) {
                case sizeof(int16_t) : {
                    *(int16_t*)_pv = *(int16_t*)__bind->buffer;
                    break;
                }
                case sizeof(int32_t) : {
                    *(int32_t*)_pv = *(int16_t*)__bind->buffer;
                    break;
                }
                case sizeof(int64_t) : {
                    *(int64_t*)_pv = *(int16_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(int16_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_INT24 :
        case MYSQL_TYPE_LONG : {
            switch (*_psize) {
                case sizeof(int32_t) : {
                    *(int32_t*)_pv = *(int32_t*)__bind->buffer;
                    break;
                }
                case sizeof(int64_t) : {
                    *(int64_t*)_pv = *(int32_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(int32_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_LONGLONG : {
            switch (*_psize) {
                case sizeof(int64_t) : {
                    *(int64_t*)_pv = *(int64_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(int64_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_DECIMAL:
        case MYSQL_TYPE_NEWDECIMAL: {
            char* endptr;
            long long n;
            if ((Field::__precision - Field::__scale) < 20) {
                n = strtoll((char*)__bind->buffer, &endptr, 10);
                if (n == LLONG_MAX || n == LLONG_MIN) {
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eServerError);
                    return false;
                }
            }
            else {
                double d = strtod((char*)__bind->buffer, &endptr);
                if (+HUGE_VAL == d || -HUGE_VAL == d || !(DBL_MIN < d)) {
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eServerError);
                    return false;
                }
 
                double i;
                (void)modf(d, &i);  // 정수부분만, 반환값(소수)는 버림
                if (i < LLONG_MIN || LLONG_MAX < i) {
                    __SET_ERROR(SQL::eOutOfRange);
                    return false;
                }
                n = (long long)i;
            }
 
            switch (*_psize) {
                case sizeof(int8_t) : {
                    if (n < INT8_MIN || INT8_MAX < n) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(int8_t*)_pv = (int8_t)n;
                    break;
                }
                case sizeof(int16_t) : {
                    if (n < INT16_MIN || INT16_MAX < n) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(int16_t*)_pv = (int16_t)n;
                    break;
                }
                case sizeof(int32_t) : {
                    if (n < INT32_MIN || INT32_MAX < n) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(int32_t*)_pv = (int32_t)n;
                    break;
                }
                case sizeof(int64_t) : {
                    *(int64_t*)_pv = (int64_t)n;
                    break;
                }
                default: {
                    *_psize = sizeof(int64_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        default: {
            __DCL_ASSERT(false);    // MyField::init bug      
        }
    }
 
    return true;
}
 
bool MyField::getUInteger(void* _pv, size_t* _psize)
{
    __DCL_ASSERT(__field->flags & UNSIGNED_FLAG);
 
    switch (__field->type) {
        case MYSQL_TYPE_TINY : {
            switch (*_psize) {
                case sizeof(uint8_t) : {
                    *(uint8_t*)_pv = *(uint8_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint16_t) : {
                    *(uint16_t*)_pv = *(uint8_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint32_t) : {
                    *(uint32_t*)_pv = *(uint8_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint64_t) : {
                    *(uint64_t*)_pv = *(uint8_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(uint8_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_YEAR :
        case MYSQL_TYPE_SHORT: {
            switch (*_psize) {
                case sizeof(uint16_t) : {
                    *(uint16_t*)_pv = *(uint16_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint32_t) : {
                    *(uint32_t*)_pv = *(uint16_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint64_t) : {
                    *(uint64_t*)_pv = *(uint16_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(uint16_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_INT24:
        case MYSQL_TYPE_LONG: {
            switch (*_psize) {
                case sizeof(uint32_t) : {
                    *(uint32_t*)_pv = *(uint32_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint64_t) : {
                    *(uint64_t*)_pv = *(uint32_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(uint32_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_LONGLONG: {
            switch (*_psize) {
                case sizeof(uint64_t) : {
                    *(uint64_t*)_pv = *(uint64_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(uint32_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_DECIMAL :
        case MYSQL_TYPE_NEWDECIMAL : {
            char* endptr;
            unsigned long long u;
            if ((Field::__precision - Field::__scale) < 20) {
                u = strtoull((char*)__bind->buffer, &endptr, 10);
                if (u == ULONG_MAX) {
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eServerError);
                    return false;
                }
            }
            else {
                double d = strtod((char*)__bind->buffer, &endptr);
                if (+HUGE_VAL == d || -HUGE_VAL == d || !(DBL_MIN < d)) {
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eServerError);
                    return false;
                }
 
                double i;
                modf(d, &i);    // 정수부분만, 반환값(소수)는 버림
                if (i < 0 || ULONG_MAX < i) {
                    __SET_ERROR(SQL::eOutOfRange);
                    return false;
                }
                u = (unsigned long long)i;
            }
 
            switch (*_psize) {
                case sizeof(uint8_t): {
                    if (UINT8_MAX < u) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(uint8_t*)_pv = (uint8_t)u;
                    break;
                }
                case sizeof(uint16_t): {
                    if (UINT16_MAX < u) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(uint16_t*)_pv = (uint16_t)u;
                    break;
                }
                case sizeof(uint32_t): {
                    if (UINT32_MAX < u) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(uint32_t*)_pv = (uint32_t)u;
                    break;
                }
                case sizeof(uint64_t): {
                    *(uint64_t*)_pv = (uint64_t)u;
                    break;
                }
                default: {
                    *_psize = sizeof(uint64_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        default: {
            __DCL_ASSERT(false);    // MyField::init bug      
        }
    }
 
    return true;
}
 
bool MyField::getFloat(void* _pv, size_t* _psize)
{
    switch (__field->type) {
        case MYSQL_TYPE_FLOAT: {
            switch (*_psize) {
                case sizeof(float): {
                    *(float*)_pv = *(float*)__bind->buffer;
                    break;
                }
                case sizeof(double): {
                    *(double*)_pv = *(float*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(float);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_DOUBLE: {
            switch (*_psize) {
                case sizeof(double) : {
                    *(double*)_pv = *(double*)__bind->buffer;
                    break;
                }
                default: {
                    *_psize = sizeof(double);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_DECIMAL:
        case MYSQL_TYPE_NEWDECIMAL: {
            char* endptr;
            double d = strtod((char*)__bind->buffer, &endptr);
            if (+HUGE_VAL == d || -HUGE_VAL == d || !(DBL_MIN < d)) {
                // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                __SET_ERROR(SQL::eServerError);
                return false;
            }
 
            switch (*_psize) {
                case sizeof(float): {
                    if (d < FLT_MIN || FLT_MAX < d) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(float*)_pv = (float) d;
                    break;
                }
                case sizeof(double): {
                    if (d < DBL_MIN || DBL_MAX < d) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(double*)_pv = (double)d;
                    break;
                }
                default : {
                    *_psize = sizeof(double);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        default : {
            __DCL_ASSERT(false);    // MyField::init bug
        }
    }
 
    return true;
}
 
bool MyField::getDate(SQL::Date* _pv, size_t* _psize)
{
    __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_DATE));
 
    if (*_psize != sizeof(SQL::Date)) {
        *_psize = sizeof(SQL::Date);
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
    
    MYSQL_TIME* s = (MYSQL_TIME*)__bind->buffer;
    _pv->year = s->year * (s->neg ? -1 : 1);
    _pv->month = s->month;
    _pv->day = s->day;
 
    return true;
}
 
bool MyField::getTimeStamp(SQL::TimeStamp* _pv, size_t* _psize)
{
    __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_DATETIME)
            || __TYPE_IS(MYSQL_TYPE_TIMESTAMP));
 
    if (*_psize != sizeof(SQL::TimeStamp)) {
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    MYSQL_TIME* s = (MYSQL_TIME*)__bind->buffer;
    _pv->year = s->year * (s->neg ? -1 : 1);
    _pv->month = s->month;
    _pv->day = s->day;
    _pv->hour = s->hour;
    _pv->min = s->minute;
    _pv->sec = s->second;
    _pv->frac = s->second_part * 1000;
    _pv->tzoff = INT16_MIN;
 
    return true;
}
 
bool MyField::getTime(SQL::Time* _pv, size_t* _psize)
{
    __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_TIME));
 
    if (*_psize != sizeof(SQL::Time)) {
        *_psize = sizeof(SQL::Time);
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    MYSQL_TIME* s = (MYSQL_TIME*)__bind->buffer;
    _pv->hour = s->hour;
    _pv->min = s->minute;
    _pv->sec = s->second;
    _pv->frac = s->second_part * 1000;
    _pv->tzoff = INT16_MIN;
 
    return true;
}
 
bool MyField::getInterval(SQL::Interval* _pv, size_t* _psize)
{
    __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_TIME));
 
    if (*_psize != sizeof(SQL::Interval)) {
        *_psize = sizeof(SQL::Interval);
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    MYSQL_TIME* s = (MYSQL_TIME*)__bind->buffer;
    int8_t sign = s->neg ? -1 : 1;
    _pv->years = 0;
    _pv->months = 0;
    _pv->days = s->hour / 24 * sign;
    _pv->hours = s->hour % 24 * sign;
    _pv->mins = s->minute * sign;
    _pv->secs = s->second * sign;
    _pv->fracs = s->second_part * 1000 * sign;
 
    return true;
}
 
__DCL_END_NAMESPACE