PqField.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __APPLE__
#include <libkern/OSByteOrder.h>
#endif
 
#include <errno.h>      // errno
#include <float.h>      // FLT_MAX
#include <math.h>       // modf, HUGE_VAL
#include <stdlib.h>     // strtoll, strtoull, _byteswap_
#include <string.h>     // memset, memcpy
 
#include <libpq-fe.h>
#include <catalog/pg_type_d.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 "PqConnection.h"
#include "PqQuery.h"
#include "PqField.h"
#include "PqTypes.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
#define __DCL_TRACE5_N  __DCL_TRACE5
#define __DCL_TRACE6_N  __DCL_TRACE6
#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)
#define __DCL_TRACE5_N(fmt, arg1, arg2, arg3, arg4, arg5)
#define __DCL_TRACE6_N(fmt, arg1, arg2, arg3, arg4, arg5, arg6)
#endif
 
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/sql/PqField.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#define __SET_ERROR(_error) \
    connection()->setErrorStatus(_error, __THIS_FILE__, __LINE__)
#define __SET_ERROR_MSG(_message) \
    conn()->setErrorMessage(_message, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(PqField, SQL::Field)
 
PqField::PqField() 
    : Field(NULL)
{
    __index = -1;
    __type = -1;
    __size = 0;
    __format = 0;
    __maxDataSize = 0;
}
 
PqField::~PqField()
{
//  __DCL_TRACE1("~PqField: %ls", Field::__name.data());
}
 
bool PqField::init(SQL::Query* _queryHandle, int _index, const PGresult* _res)
{
    __DCL_ASSERT(Field::__queryHandle == NULL);
    __DCL_ASSERT(_queryHandle != NULL && _res != NULL);
 
    Field::__queryHandle = _queryHandle;
 
    try {
        Field::__name = UTF8Decoder::decode(PQfname(_res, _index)).toUpperCase();
    }
    catch (CharsetConvertException* _e) {
        __SET_ERROR_MSG(UTF8Encoder::encode(_e->toStringAll()));
        _e->destroy();
        return false;
    }
 
    __index = _index;
    __type = PQftype(_res, _index);
    __size = PQfsize(_res, _index);
    __format = PQfformat(_res, _index);
    int mod = PQfmod(_res, _index);
 
    switch (__type) {
        case BOOLOID: {
            Field::__dataType = SQL::typeInteger;
            Field::__precision = 1;
            break;
        }
        case INT2OID: {
            Field::__dataType = SQL::typeInteger;
            Field::__precision = 5;
            break;
        }
        case INT4OID: {
            Field::__dataType = SQL::typeInteger;
            Field::__precision = 10;
            break;
        }
        case INT8OID: {
            Field::__dataType = SQL::typeInteger;
            Field::__precision = 19;
            break;
        }
        case FLOAT4OID: {
            Field::__dataType = SQL::typeFloat;
            break;
        }
        case FLOAT8OID: {
            Field::__dataType = SQL::typeFloat;
            break;
        }
        case MONEYOID: {
            Field::__dataType = SQL::typeNumeric;
            Field::__precision = 19;
            Field::__scale = 2;
            break;
        }
        case NUMERICOID: {
            Field::__dataType = SQL::typeNumeric;
            Field::__precision = mod >> 16;
            Field::__scale = (mod - 4) & 0xffff;
            break;
        }
        case DATEOID: {
            Field::__dataType = SQL::typeDate;
            __maxDataSize = sizeof(SQL::Date);
            break;
        }
        case TIMEOID: {
            Field::__dataType = SQL::typeTime;
            Field::__scale = 6;
            __maxDataSize = sizeof(SQL::Time);
            break;
        }
        case TIMETZOID: {
            Field::__dataType =  SQL::typeTimeTz;
            Field::__scale = 6;
            __maxDataSize = sizeof(SQL::Time);
            break;
        }
        case TIMESTAMPOID: {
            Field::__dataType = SQL::typeTimeStamp;
            Field::__scale = 6;
            __maxDataSize = sizeof(SQL::TimeStamp);
            break;
        }
        case TIMESTAMPTZOID: {
            Field::__dataType = SQL::typeTimeStampTz;
            Field::__scale = 6;
            __maxDataSize = sizeof(SQL::TimeStamp);
            break;
        }
        case INTERVALOID: {
            Field::__dataType = SQL::typeInterval;
            Field::__precision = mod >> 16;
            Field::__scale = (mod - 4) & 0xffff;
            __maxDataSize = sizeof(SQL::Interval);
            break;
        }
        case BITOID:
        case VARBITOID: {
            Field::__dataType = SQL::typeText;
            __maxDataSize = mod;
            break;
        }
        case CHAROID:
        case BPCHAROID:
        case VARCHAROID: {
            Field::__dataType = SQL::typeText;
            if (mod != -1) {
                __maxDataSize = mod - 4;
            }
            break;
        }
        case TEXTOID:
        case JSONOID:
        case XMLOID:
 
        case MACADDROID:
        case INETOID:
        case CIDROID:
        case MACADDR8OID:
 
        case UUIDOID:
 
        case TSVECTOROID:
        case TSQUERYOID:
        case JSONBOID:
        case JSONPATHOID:
        default: {
            Field::__dataType = SQL::typeText;
            break;
        }
 
        case BYTEAOID: {
            Field::__dataType = SQL::typeBinary;
            break;
        }
    }
 
    if (__maxDataSize == 0) {
        __maxDataSize = __size >= 0 ?
            __size : 10 * 1024 * 1024;  // cannot exceed 1 GB;
    }
 
    __DCL_TRACE6_N(L"Field [%2d] size [%6d %7d %3d,%3d] [%ls]\n",
        __index, __size, mod, __precision, __scale, __name.data());
 
    return true;
}
 
const wchar_t* PqField::serverDataTypeName() const
{
    return __dataTypeName(__type);
}
 
bool PqField::__getDataSize(size_t* _size, bool _maxsize)
{
    if (_maxsize) {
        *_size = __maxDataSize;
        return true;
    }
 
    const char* value;
    int length;
    if (query()->getValue(__index, value, length)) {
        *_size = length;
    }
    else {
        *_size = (size_t)-1;
    }
 
    return true;
}
 
bool PqField::__getData(
    void*           _buf,
    size_t*         _size,
    SQL::DataType  _bufType
)
{
    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::typeTime:
            return getTime((SQL::Time*)_buf, _size);
        case SQL::typeTimeStamp:
            return getTimeStamp((SQL::TimeStamp*)_buf, _size);
        case SQL::typeInterval:
            return getInterval((SQL::Interval*)_buf, _size);
        case SQL::typeText:
            if (Field::__dataType == SQL::typeNumeric) {
                return getNumeric((char*)_buf, _size);
            }
        case SQL::typeBinary:
            return getBytes((char*)_buf, _size);
        case SQL::typeOutputStream:
            return writeTo((OutputStream*)_buf, _size);
        default:
            __DCL_ASSERT(false);        // SQL::Field::getData bug
    }
    return true;
}
 
bool PqField::getInteger(void* _buf, size_t* _size)
{
    const char* value;
    int length;
    long long n;
    __DCL_VERIFY(query()->getValue(__index, value, length));
    __DCL_TRACE2_N(L"[%d][%ls]\n", length, String::tryString(value, length).data());
 
    if (__format == __FORMAT_BINARY) {
        switch (__type) {
            case BOOLOID: {
                n = *(int8_t*)value;
                break;
            }
            case INT2OID: {
                n = (int16_t)__ntohs(*(uint16_t*)value);
                break;
            }
            case INT4OID: {
                n = (int32_t)__ntohl(*(uint32_t*)value);
                break;
            }
            case INT8OID: {
                n = (int64_t)__ntohll(*(uint64_t*)value);
                break;
            }
            case FLOAT4OID: {
                n = (int64_t)__ntohf(*(uint32_t*)value);
                break;
            }
            case FLOAT8OID: {
                n = (int64_t)__ntohd(*(uint64_t*)value);
                break;
            }
            case MONEYOID:
            case NUMERICOID: {
                n = 0;
            }
            default: {
                __SET_ERROR(SQL::eInvalidDataType);
                return false;
            }
        }
    }
    else {  // __FORMAT_TEXT
        ByteString s;   // for MONEYOID
        switch (__type) {
            case BOOLOID: {
                n = strchr("fF0", *value) ? 0 : 1;
                break;
            }
            case INT2OID:
            case INT4OID:
            case INT8OID: {
                errno = 0;
                char* endptr = NULL;
                n = strtoll(value, &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
                break;
            }
            case FLOAT4OID:
            case FLOAT8OID: {
                errno = 0;
                char* endptr = NULL;
                double d = strtod(value, &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;
                break;
            }
            case MONEYOID: {
                s.assign(value, length);
                s = s.replace_r("[^0-9\\.]", "", false);
                value = s.data();
            }
            case NUMERICOID: {
                errno = 0;
                char* endptr = NULL;
                if ((Field::__precision - Field::__scale) < 20) {
                    n = strtoll(value, &endptr, 10);
                    if (errno == ERANGE) {
                        __DCL_ASSERT(
                            n == LLONG_MAX || n == LLONG_MIN    // 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(value, &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;
                }
                break;
            }
            default: {
                __SET_ERROR(SQL::eInvalidDataType);
                return false;
            }
        }
    }
 
    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;
        }
    }
 
    return true;
}
 
bool PqField::getUInteger(void* _buf, size_t* _size)
{
    const char* value;
    int length;
    unsigned long long u;
    ByteString s;
    __DCL_VERIFY(query()->getValue(__index, value, length));
    __DCL_TRACE2_N(L"[%d][%ls]\n", length, String::tryString(value, length).data());
 
    if (__format == __FORMAT_BINARY) {
        switch (__type) {
            case BOOLOID: {
                u = *(uint8_t*)value;
                break;
            }
            case INT2OID: {
                u = (uint16_t)__ntohs(*(uint16_t*)value);
                break;
            }
            case INT4OID: {
                u = (uint32_t)__ntohl(*(uint32_t*)value);
                break;
            }
            case INT8OID: {
                u = (uint64_t)__ntohll(*(uint64_t*)value);
                break;
            }
            case FLOAT4OID: {
                u = (uint64_t)__ntohf(*(uint32_t*)value);
                break;
            }
            case FLOAT8OID: {
                u = (uint64_t)__ntohd(*(uint64_t*)value);
                break;
            }
            case MONEYOID:
            case NUMERICOID: {
                u = 0;
            }
            default: {
                __SET_ERROR(SQL::eInvalidDataType);
                return false;
            }
        }
    }
    else {  // __FORMAT_TEXT
        ByteString s;   // for MONEYOID
        switch (__type) {
            case BOOLOID: {
                u = strchr("fF0", *value) ? 0 : 1;
                break;
            }
            case INT2OID:
            case INT4OID:
            case INT8OID: {
                errno = 0;
                char* endptr = NULL;
                u = strtoull(value, &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
                break;
            }
            case FLOAT4OID:
            case FLOAT8OID: {
                errno = 0;
                char* endptr = NULL;
                double d = strtod(value, &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;
                }
                u = (unsigned long long)i;
                break;
            }
            case MONEYOID: {
                s.assign(value, length);
                s = s.replace_r("[^0-9\\.]", "", false);
                value = s.data();
            }
            case NUMERICOID: {
                errno = 0;
                char* endptr = NULL;
                if ((Field::__precision - Field::__scale) <= 20) {
                    u = strtoull(value, &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(value, &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;
                }
                break;
            }
            default: {
                __SET_ERROR(SQL::eInvalidDataType);
                return false;
            }
        }
    }
 
    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;
        }
    }
 
    return true;
}
 
bool PqField::getFloat(void* _buf, size_t* _size)
{
    const char* value;
    int length;
    double d;
    __DCL_VERIFY(query()->getValue(__index, value, length));
    __DCL_TRACE2_N(L"[%d][%ls]\n", length, String::tryString(value, length).data());
 
    if (__format == __FORMAT_BINARY) {
        switch (__type) {
            case BOOLOID: {
                d = (double)*(int8_t*)value;
                break;
            }
            case INT2OID: {
                d = (double)(int16_t)__ntohs(*(uint16_t*)value);
                break;
            }
            case INT4OID: {
                d = (double)(int32_t)__ntohl(*(uint32_t*)value);
                break;
            }
            case INT8OID: {
                d = (double)(int64_t)__ntohll(*(uint64_t*)value);
                break;
            }
            case FLOAT4OID: {
                d = (double)__ntohf(*(uint32_t*)value);
                break;
            }
            case FLOAT8OID: {
                d = (double)__ntohd(*(uint64_t*)value);
                break;
            }
            case MONEYOID:
            case NUMERICOID: {
                d = 0;
            }
            default: {
                __SET_ERROR(SQL::eInvalidDataType);
                return false;
            }
        }
    }
    else {  // __FORMAT_TEXT
        ByteString s;   // for MONEYOID
        switch (__type) {
            case BOOLOID: {
                d = strchr("fF0", *value) ? 0 : 1;
                break;
            }
            case INT2OID:
            case INT4OID:
            case INT8OID: {
                errno = 0;
                char* endptr = NULL;
                long long n = strtoll(value, &endptr, 10);
                if (errno == ERANGE) {
                    __DCL_ASSERT(
                        n == LLONG_MAX || n == LLONG_MIN    // overflow
                    );
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eOutOfRange);
                    return false;
                }
    #if __UNNEED__
                else if (errno == EINVAL) {
                    // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
                    __SET_ERROR(SQL::eInvalidData);
                    return false;
                }
    #endif
                d = (double)n;
                break;
            }
            case FLOAT4OID:
            case FLOAT8OID: {
                errno = 0;
                char* endptr = NULL;
                d = strtod(value, &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
                break;
            }
            case MONEYOID: {
                s.assign(value, length);
                s = s.replace_r("[^0-9\\.]", "", false);
                value = s.data();
            }
            case NUMERICOID: {
                errno = 0;
                char* endptr = NULL;
                d = strtod(value, &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
                break;
            }
            default: {
                __SET_ERROR(SQL::eInvalidDataType);
                return false;
            }
        }
    }
 
    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;
        }
    }
 
    return true;
}
 
bool PqField::getDate(SQL::Date* _buf, size_t* _size)
{
    if (*_size != sizeof(SQL::Date)) {
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    const char* value;
    int length;
    __DCL_VERIFY(query()->getValue(__index, value, length));
    __DCL_TRACE2_N(L"[%d][%ls]\n", length, String::tryString(value, length).data());
 
    if (__format == __FORMAT_BINARY) {
        memset(_buf, 0, sizeof(SQL::Date));
    }
    else {
        SQL::TimeStamp ts;
        if (!__decode_timestamp_iso(value, NULL, ts)) {
            // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
            __SET_ERROR(SQL::eInvalidData);
            return false;
        }
        _buf->year = ts.year;
        _buf->month = ts.month;
        _buf->day = ts.day;
    }
 
    return true;
}
 
bool PqField::getTime(SQL::Time* _buf, size_t* _size)
{
    if (*_size != sizeof(SQL::Time)) {
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    const char* value;
    int length;
    __DCL_VERIFY(query()->getValue(__index, value, length));
    __DCL_TRACE2_N(L"[%d][%ls]\n", length, String::tryString(value, length).data());
 
    if (__format == __FORMAT_BINARY) {
        memset(_buf, 0, sizeof(SQL::Time));
    }
    else {
        SQL::TimeStamp ts;
        if (!__decode_timestamp_iso(value, NULL, ts)) {
            // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
            __SET_ERROR(SQL::eInvalidData);
            return false;
        }
        _buf->hour = ts.hour;
        _buf->min = ts.min;
        _buf->sec = ts.sec;
        _buf->frac = ts.frac;
        _buf->tzoff = ts.tzoff;
    }
 
    return true;
}
 
bool PqField::getTimeStamp(SQL::TimeStamp* _buf, size_t* _size)
{
    if (*_size != sizeof(SQL::TimeStamp)) {
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    const char* value;
    int length;
    __DCL_VERIFY(query()->getValue(__index, value, length));
    __DCL_TRACE2_N(L"[%d][%ls]\n", length, String::tryString(value, length).data());
 
    if (__format == __FORMAT_BINARY) {
        memset(_buf, 0, sizeof(SQL::TimeStamp));
    }
    else {
        if (!__decode_timestamp_iso(value, NULL, *_buf)) {
            // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
            __SET_ERROR(SQL::eInvalidData);
            return false;
        }
    }
 
    return true;
}
 
bool PqField::getInterval(SQL::Interval* _buf, size_t* _size)
{
    if (*_size != sizeof(SQL::Interval)) {
        __SET_ERROR(SQL::eInvalidBufferSize);
        return false;
    }
 
    const char* value;
    int length;
    __DCL_VERIFY(query()->getValue(__index, value, length));
    __DCL_TRACE2_N(L"[%d][%ls]\n", length, String::tryString(value, length).data());
 
    if (__format == __FORMAT_BINARY) {
        memset(_buf, 0, sizeof(SQL::Interval));
    }
    else {
        if (!__decode_interval_iso(value, NULL, *_buf)) {
            // API 버그 또는 서버로부터 수신된 값에 오류가 있다.
            __SET_ERROR(SQL::eInvalidData);
            return false;
        }
 
    }
 
    return true;
}
 
bool PqField::getNumeric(char* _buf, size_t* _size)
{
    const char* value;
    int length;
    __DCL_VERIFY(query()->getValue(__index, value, length));
    __DCL_TRACE2_N(L"[%d][%ls]\n", length, String::tryString(value, length).data());
 
    if (__format == __FORMAT_BINARY) {
        *_size = 0;
    }
    else {  // __FORMAT_TEXT
        if ((size_t)length < *_size) {
            *(_buf + length) = '\0';
            *_size = length;
        }
        memcpy(_buf, value, *_size);
    }
 
    return true;
}
bool PqField::getBytes(char* _buf, size_t* _size)
{
    const char* value;
    int length;
    __DCL_VERIFY(query()->getValue(__index, value, length));
    __DCL_TRACE2_N(L"[%d][%ls]\n", length, String::tryString(value, length).data());
 
    if (__type == BYTEAOID && __format == __FORMAT_TEXT) {
        bool __UNUSED__ r = false;
        const char* srcend = value + length;
        char* dstend = _buf + *_size;
        if (__is_hex_escaped(value))
            r = __unescape_hex(value, srcend, _buf, dstend);
        else
            r = __unescape_oct(value, srcend, _buf, dstend);
 
        size_t dstlen = dstend - _buf;
        __DCL_TRACE2_N(L"unescaped [%zd][%ls]\n", dstlen, String::valueOf(r).data());
 
        if (dstlen < *_size) {
            *(_buf + dstlen) = '\0';
            *_size = dstlen;
        }
    }
    else {
        if ((size_t) length < *_size) {
            *(_buf + length) = '\0';
            *_size = length;
        }
        memcpy(_buf, value, *_size);
    }
    return true;
}
 
bool PqField::writeTo(OutputStream* _output, size_t* _size)
{
    const char* value;
    int length;
    __DCL_VERIFY(query()->getValue(__index, value, length));
 
    if (__type == BYTEAOID && __format == __FORMAT_TEXT) {
        try {
            size_t total = 0;
            bool __is_hex = __is_hex_escaped(value);
            char buf[4096];
            const char* src = value;
            const char* srcend = value + length;
            while (src < srcend && total < *_size) {
                char* dstend = buf + sizeof(buf);
                bool __UNUSED__ r = __is_hex ? __unescape_hex(src, srcend, buf, dstend)
                    : __unescape_oct(src, srcend, buf, dstend);
 
                size_t dstlen = dstend - buf;
                __DCL_TRACE2_N(L"unescaped [%zd][%ls]\n", dstlen, String::valueOf(r).data());
                if (dstlen) {
                    _output->write(buf, dstlen);
                    total += dstlen;
                }
                // value의 데이터에 오류가 있어서 dstlen이 0인 경우도 있을 수 있다.
                // srclen이 0dl 될때까지 반복한다.
                src = srcend;
                srcend = value + length;
            }
        }
        catch (IOException* e) {
            __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
            e->destroy();
            return false;
        }
    }
    else {
        if ((size_t)length < *_size) {
            *_size = length;
        }
        try {
            _output->write(value, *_size);
        }
        catch (IOException* e) {
            __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
            e->destroy();
            return false;
        }
    }
    return true;
}
 
__DCL_END_NAMESPACE