MyField.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <errno.h>      // errno
#include <float.h>      // FLT_MAX
#include <math.h>       // modf, HUGE_VAL
#include <stdlib.h>     // strtoll, strtoull
#include <string.h>     // memcpy
 
#include <mysql.h>
 
#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
 
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/sql/MyField.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#define __SET_ERROR(_error) \
    connection()->setErrorStatus(_error, __THIS_FILE__, __LINE__)
#define __SET_ERROR_HANDLE(_error) \
    conn()->setErrorHandle(_error, __THIS_FILE__, __LINE__)
#define __SET_ERROR_MSG(_msg) \
    conn()->setErrorMessage(_msg, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(MyField, SQL::Field)
 
MyField::MyField()
    : Field(NULL)
{
    __index = 0;
    __field = NULL;
    __bind = NULL;
    __maxsize = 0;
}
 
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_TRACE3_N(L"length[%10u] decimals[%2u] [%ls]\n", 
        _field->length, _field->decimals, __name.data());
 
    switch(_field->type) {
        case MYSQL_TYPE_TINY: {
            if (_field->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 (_field->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 (_field->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 (_field->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::__dataType = SQL::typeFloat;
            __maxsize = sizeof(float);
            break;
        }
        case MYSQL_TYPE_DOUBLE: {
            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::__scale = _field->decimals;
            Field::__dataType = SQL::typeTimeStamp;
            __maxsize = sizeof(SQL::TimeStamp);
            break;
        }
        case MYSQL_TYPE_DATE:
        case MYSQL_TYPE_NEWDATE : {
            Field::__precision = _field->length;
            Field::__scale = _field->decimals;
            Field::__dataType = SQL::typeDate;
            __maxsize = sizeof(SQL::Date);
            break;
        }
        case MYSQL_TYPE_TIME:
        case MYSQL_TYPE_TIME2: {
            Field::__precision = _field->length;
            Field::__scale = _field->decimals;
            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::__scale = _field->decimals;
            Field::__dataType = SQL::typeNumeric;
            __maxsize = _field->length;
            break;
        }
        case MYSQL_TYPE_BIT: {
            Field::__scale = _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 = _field->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 (_field->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::__getDataSize(size_t* _size, bool _maxsize) 
{
    if (_maxsize) {
        *_size = __maxsize;
        return true;
    }
 
    if (__bind->is_null_value) {
        *_size = (size_t)-1;
    }
    else {
        switch (Field::__dataType) {
            case SQL::typeInteger:
            case SQL::typeUInteger:
            case SQL::typeFloat:
            case SQL::typeDate:
            case SQL::typeTime:
            case SQL::typeTimeTz:
            case SQL::typeTimeStamp:
            case SQL::typeTimeStampTz:
            case SQL::typeInterval:
            case SQL::typeIntervalYm:
            case SQL::typeIntervalDs:
                *_size = __maxsize;
                break;
            default:
                *_size = __bind->length_value;
        }
    }
 
    return true;
}
 
#define __TYPE_IS(_type)    (__field->type == _type)
 
bool MyField::__getData(
    void*           _buf,
    size_t*         _size,
    SQL::DataType  _bufType
)
{
#if 0
    if (!query()->inState(SQL::Query::stFetched)) {
        __SET_ERROR(SQL::eNotFetched);
        return false;
    }
#endif
    switch(_bufType) {
        case SQL::typeInteger :
            return  getInteger(_buf, _size);
        case SQL::typeUInteger :
            return getUInteger(_buf, _size);
        case SQL::typeFloat :
            return getFloat(_buf, _size);
        case SQL::typeDate :
            return getDate((SQL::Date*)_buf, _size);
        case SQL::typeTimeStamp :
            return getTimeStamp((SQL::TimeStamp*)_buf, _size);
        case SQL::typeTime:
            return getTime((SQL::Time*)_buf, _size);
        case SQL::typeInterval:
            return getInterval((SQL::Interval*)_buf, _size);
        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 (*_size < __bind->length_value) {
                __SET_ERROR(SQL::eInvalidBufferSize);
                return false;
            }
            if (__bind->buffer_length) {
                // 버퍼가 할당되어 있으면, 이것을 복사한다.
                memcpy(_buf, __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 = _buf;
                bind.buffer_length = *_size;
                if (mysql_stmt_fetch_column(query()->stmtHandle(), &bind, __index, 0)) {
                    __SET_ERROR_MSG(ByteString::format("(%u) %hs",
                        mysql_stmt_errno(query()->stmtHandle()),
                        mysql_stmt_error(query()->stmtHandle()))
                    );
                    return false;
                }
            }
            if (*_size > __bind->length_value)
                *((char*)_buf + __bind->length_value) = '\0';
            *_size = __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 < *_size) {
                *_size = __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 < *_size) {
                    bind.buffer_length = __MIN(sizeof(buf), *_size - total);
                    if (mysql_stmt_fetch_column(query()->stmtHandle(),
                        &bind, __index, total
                    )) {
                        __SET_ERROR_MSG(ByteString::format("(%u) %hs",
                            mysql_stmt_errno(query()->stmtHandle()),
                            mysql_stmt_error(query()->stmtHandle()))
                        );
                        return false;
                    }
                    ((OutputStream*)_buf)->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* _buf, size_t* _size)
{
    __DCL_ASSERT(!(__field->flags & UNSIGNED_FLAG));
 
    switch (__field->type) {
        case MYSQL_TYPE_TINY: {
            switch (*_size) {
                case sizeof(int8_t) : {
                    *(int8_t*)_buf = *(int8_t*)__bind->buffer;
                    break;
                }
                case sizeof(int16_t) : {
                    *(int16_t*)_buf = *(int8_t*)__bind->buffer;
                    break;
                }
                case sizeof(int32_t) : {
                    *(int32_t*)_buf = *(int8_t*)__bind->buffer;
                    break;
                }
                case sizeof(int64_t) : {
                    *(int64_t*)_buf = *(int8_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_size = sizeof(int8_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_YEAR : 
        case MYSQL_TYPE_SHORT : {
            switch (*_size) {
                case sizeof(int16_t) : {
                    *(int16_t*)_buf = *(int16_t*)__bind->buffer;
                    break;
                }
                case sizeof(int32_t) : {
                    *(int32_t*)_buf = *(int16_t*)__bind->buffer;
                    break;
                }
                case sizeof(int64_t) : {
                    *(int64_t*)_buf = *(int16_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_size = sizeof(int16_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_INT24 :
        case MYSQL_TYPE_LONG : {
            switch (*_size) {
                case sizeof(int32_t) : {
                    *(int32_t*)_buf = *(int32_t*)__bind->buffer;
                    break;
                }
                case sizeof(int64_t) : {
                    *(int64_t*)_buf = *(int32_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_size = sizeof(int32_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_LONGLONG : {
            switch (*_size) {
                case sizeof(int64_t) : {
                    *(int64_t*)_buf = *(int64_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_size = sizeof(int64_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_DECIMAL:
        case MYSQL_TYPE_NEWDECIMAL: {
            errno = 0;
            char* endptr = NULL;
            long long n;
            if ((Field::__precision - Field::__scale) < 20) {
                n = strtoll((char*)__bind->buffer, &endptr, 10);
                if (errno == ERANGE) {
                    __DCL_ASSERT(
                        n == LLONG_MAX || n == LLONG_MIN    // overflow
                    );
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eOutOfRange);
                    return false;
                }
    #define __UNNEED__ 0
    #if __UNNEED__
                else if (errno == EINVAL) {
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eInvalidData);
                    return false;
                }
    #endif
            }
            else {
                double d = strtod((char*)__bind->buffer, &endptr);
                if (errno == ERANGE) {
                    __DCL_ASSERT(
                        +HUGE_VAL == d || -HUGE_VAL == d    // overflow
                        || !(DBL_MIN < d)                   // underflow
                    );
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eOutOfRange);
                    return false;
                }
    #if __UNNEED__
                else if (errno == EINVAL) {
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eInvalidData);
                    return false;
                }
    #endif
                double i;
                (void)modf(d, &i);  // 정수부분만, 반환값(소수)는 버림
                if (i < (double)LLONG_MIN || (double)LLONG_MAX < i) {
                    __SET_ERROR(SQL::eOutOfRange);
                    return false;
                }
                n = (long long)i;
            }
 
            switch (*_size) {
                case sizeof(int8_t) : {
                    if (n < INT8_MIN || INT8_MAX < n) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(int8_t*)_buf = (int8_t)n;
                    break;
                }
                case sizeof(int16_t) : {
                    if (n < INT16_MIN || INT16_MAX < n) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(int16_t*)_buf = (int16_t)n;
                    break;
                }
                case sizeof(int32_t) : {
                    if (n < INT32_MIN || INT32_MAX < n) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(int32_t*)_buf = (int32_t)n;
                    break;
                }
                case sizeof(int64_t) : {
                    *(int64_t*)_buf = (int64_t)n;
                    break;
                }
                default: {
                    *_size = sizeof(int64_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        default: {
            __DCL_ASSERT(false);    // MyField::init bug      
        }
    }
 
    return true;
}
 
bool MyField::getUInteger(void* _buf, size_t* _size)
{
    __DCL_ASSERT(__field->flags & UNSIGNED_FLAG);
 
    switch (__field->type) {
        case MYSQL_TYPE_TINY : {
            switch (*_size) {
                case sizeof(uint8_t) : {
                    *(uint8_t*)_buf = *(uint8_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint16_t) : {
                    *(uint16_t*)_buf = *(uint8_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint32_t) : {
                    *(uint32_t*)_buf = *(uint8_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint64_t) : {
                    *(uint64_t*)_buf = *(uint8_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_size = sizeof(uint8_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_YEAR :
        case MYSQL_TYPE_SHORT: {
            switch (*_size) {
                case sizeof(uint16_t) : {
                    *(uint16_t*)_buf = *(uint16_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint32_t) : {
                    *(uint32_t*)_buf = *(uint16_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint64_t) : {
                    *(uint64_t*)_buf = *(uint16_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_size = sizeof(uint16_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_INT24:
        case MYSQL_TYPE_LONG: {
            switch (*_size) {
                case sizeof(uint32_t) : {
                    *(uint32_t*)_buf = *(uint32_t*)__bind->buffer;
                    break;
                }
                case sizeof(uint64_t) : {
                    *(uint64_t*)_buf = *(uint32_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_size = sizeof(uint32_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_LONGLONG: {
            switch (*_size) {
                case sizeof(uint64_t) : {
                    *(uint64_t*)_buf = *(uint64_t*)__bind->buffer;
                    break;
                }
                default: {
                    *_size = sizeof(uint32_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_DECIMAL :
        case MYSQL_TYPE_NEWDECIMAL : {
            errno = 0;
            char* endptr = NULL;
            unsigned long long u;
            if ((Field::__precision - Field::__scale) <= 20) {
                u = strtoull((char*)__bind->buffer, &endptr, 10);
                if (errno == ERANGE) {
                    __DCL_ASSERT(
                        u == ULONG_MAX      // overflow
                    );
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eOutOfRange);
                    return false;
                }
    #if __UNNEED__
                else if (errno == EINVAL) {
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eInvalidData);
                    return false;
                }
    #endif
            }
            else {
                double d = strtod((char*)__bind->buffer, &endptr);
                if (errno == ERANGE) {
                    __DCL_ASSERT(
                        +HUGE_VAL == d || -HUGE_VAL == d    // overflow
                        || !(DBL_MIN < d)                   // underflow
                    );
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eOutOfRange);
                    return false;
                }
    #if __UNNEED__
                else if (errno == EINVAL) {
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eInvalidData);
                    return false;
                }
    #endif
                double i;
                (void)modf(d, &i);  // 정수부분만, 반환값(소수)는 버림
                if (i < 0 || (double)ULONG_MAX < i) {
                    __SET_ERROR(SQL::eOutOfRange);
                    return false;
                }
                u = (unsigned long long)i;
            }
 
            switch (*_size) {
                case sizeof(uint8_t): {
                    if (UINT8_MAX < u) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(uint8_t*)_buf = (uint8_t)u;
                    break;
                }
                case sizeof(uint16_t): {
                    if (UINT16_MAX < u) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(uint16_t*)_buf = (uint16_t)u;
                    break;
                }
                case sizeof(uint32_t): {
                    if (UINT32_MAX < u) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(uint32_t*)_buf = (uint32_t)u;
                    break;
                }
                case sizeof(uint64_t): {
                    *(uint64_t*)_buf = (uint64_t)u;
                    break;
                }
                default: {
                    *_size = sizeof(uint64_t);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        default: {
            __DCL_ASSERT(false);    // MyField::init bug      
        }
    }
 
    return true;
}
 
bool MyField::getFloat(void* _buf, size_t* _size)
{
    switch (__field->type) {
        case MYSQL_TYPE_FLOAT: {
            switch (*_size) {
                case sizeof(float): {
                    *(float*)_buf = *(float*)__bind->buffer;
                    break;
                }
                case sizeof(double): {
                    *(double*)_buf = *(float*)__bind->buffer;
                    break;
                }
                default: {
                    *_size = sizeof(float);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_DOUBLE: {
            switch (*_size) {
                case sizeof(double) : {
                    *(double*)_buf = *(double*)__bind->buffer;
                    break;
                }
                default: {
                    *_size = sizeof(double);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        case MYSQL_TYPE_DECIMAL:
        case MYSQL_TYPE_NEWDECIMAL: {
            errno = 0;
            char* endptr = NULL;
            double d = strtod((char*)__bind->buffer, &endptr);
            if (errno == ERANGE) {
                __DCL_ASSERT(
                    +HUGE_VAL == d || -HUGE_VAL == d    // overflow
                    || !(DBL_MIN < d)                   // underflow
                );
                // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
    #if __UNNEED__
            else if (errno == EINVAL) {
                // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                __SET_ERROR(SQL::eInvalidData);
                return false;
            }
    #endif
            switch (*_size) {
                case sizeof(float): {
                    if (d < -FLT_MAX || FLT_MAX < d) {
                        __SET_ERROR(SQL::eOutOfRange);
                        return false;
                    }
                    *(float*)_buf = (float)d;
                    break;
                }
                case sizeof(double): {
                    *(double*)_buf = (double)d;
                    break;
                }
                default : {
                    *_size = sizeof(double);
                    __SET_ERROR(SQL::eInvalidBufferSize);
                    return false;
                }
            }
            break;
        }
        default : {
            __DCL_ASSERT(false);    // MyField::init bug
        }
    }
 
    return true;
}
 
bool MyField::getDate(SQL::Date* _buf, size_t* _size)
{
    __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_DATE));
 
    if (*_size != sizeof(SQL::Date)) {
        *_size = sizeof(SQL::Date);
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    MYSQL_TIME* s = (MYSQL_TIME*)__bind->buffer;
    _buf->year = s->year * (s->neg ? -1 : 1);
    _buf->month = s->month;
    _buf->day = s->day;
 
    return true;
}
 
bool MyField::getTimeStamp(SQL::TimeStamp* _buf, size_t* _size)
{
    __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_DATETIME)
            || __TYPE_IS(MYSQL_TYPE_TIMESTAMP));
 
    if (*_size != sizeof(SQL::TimeStamp)) {
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    MYSQL_TIME* s = (MYSQL_TIME*)__bind->buffer;
    _buf->year = s->year * (s->neg ? -1 : 1);
    _buf->month = s->month;
    _buf->day = s->day;
    _buf->hour = s->hour;
    _buf->min = s->minute;
    _buf->sec = s->second;
    _buf->frac = s->second_part * 1000;
    _buf->tzoff = INT16_MIN;
 
    return true;
}
 
bool MyField::getTime(SQL::Time* _buf, size_t* _size)
{
    __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_TIME));
 
    if (*_size != sizeof(SQL::Time)) {
        *_size = sizeof(SQL::Time);
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    MYSQL_TIME* s = (MYSQL_TIME*)__bind->buffer;
    _buf->hour = s->hour;
    _buf->min = s->minute;
    _buf->sec = s->second;
    _buf->frac = s->second_part * 1000;
    _buf->tzoff = INT16_MIN;
 
    return true;
}
 
bool MyField::getInterval(SQL::Interval* _buf, size_t* _size)
{
    __DCL_ASSERT(__TYPE_IS(MYSQL_TYPE_TIME));
 
    if (*_size != sizeof(SQL::Interval)) {
        *_size = sizeof(SQL::Interval);
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    MYSQL_TIME* s = (MYSQL_TIME*)__bind->buffer;
    int8_t sign = s->neg ? -1 : 1;
    _buf->years = 0;
    _buf->months = 0;
    _buf->days = s->hour / 24 * sign;
    _buf->hours = s->hour % 24 * sign;
    _buf->mins = s->minute * sign;
    _buf->secs = s->second * sign;
    _buf->fracs = s->second_part * 1000 * sign;
 
    return true;
}
 
__DCL_END_NAMESPACE