PqField Class Reference

#include <PqField.h>

Inheritance diagram for PqField:

Public Member Functions
	PqField ()
virtual	~PqField ()
bool	init (SQL::Query *_query, int _index, const PGresult *_res)
virtual const wchar_t *	serverDataTypeName () const
virtual bool	__getDataSize (size_t *_size, bool _maxsize)
virtual bool	__getData (void *_buf, size_t *_size, SQL::DataType _bufType)
Public Member Functions inherited from Object
virtual String	toString () const
virtual void	destroy ()
String	className () const
bool	isInstanceOf (const std::type_info &typeinfo) const
virtual const std::type_info &	typeInfo () const

Protected Member Functions
PqQuery *	query () const
PqConnection *	conn () const
bool	getInteger (void *_buf, size_t *_size)
bool	getUInteger (void *_buf, size_t *_size)
bool	getFloat (void *_buf, size_t *_size)
bool	getDate (SQL::Date *_buf, size_t *_size)
bool	getTime (SQL::Time *_buf, size_t *_size)
bool	getTimeStamp (SQL::TimeStamp *_buf, size_t *_size)
bool	getInterval (SQL::Interval *_buf, size_t *_size)
bool	getNumeric (char *_buf, size_t *_size)
bool	getBytes (char *_buf, size_t *_size)
bool	writeTo (OutputStream *_output, size_t *_size)
Protected Member Functions inherited from SQL::Field
	Field (Query *_queryHandle)
virtual	~Field ()
Protected Member Functions inherited from Object
virtual	~Object ()
	Object ()

Additional Inherited Members
Protected Attributes inherited from SQL::Field
Query *	__queryHandle
String	__name
DataType	__dataType
short	__precision
short	__scale

Detailed Description

Definition at line 8 of file PqField.h.

Constructor & Destructor Documentation

PqField()

PqField::PqField

(

)

~PqField()

PqField::~PqField ( )

virtual

Definition at line 73 of file PqField.cpp.

{
//  __DCL_TRACE1("~PqField: %ls", Field::__name.data());
}

Member Function Documentation

__getData()

bool PqField::__getData ( void * _buf, size_t * _size, SQL::DataType _bufType )

virtual

Implements SQL::Field.

Definition at line 253 of file PqField.cpp.

{
    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;
}

__getDataSize()

bool PqField::__getDataSize ( size_t * _size, bool _maxsize )

virtual

Implements SQL::Field.

Definition at line 234 of file PqField.cpp.

{
    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;
}

conn()

PqConnection * PqField::conn ( ) const

inlineprotected

Definition at line 57 of file PqField.h.

{
    return query()->conn();
}

getBytes()

bool PqField::getBytes ( char * _buf, size_t * _size )

protected

Definition at line 988 of file PqField.cpp.

{
    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;
}

getDate()

bool PqField::getDate ( SQL::Date * _buf, size_t * _size )

protected

Definition at line 853 of file PqField.cpp.

{
    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;
}

getFloat()

bool PqField::getFloat ( void * _buf, size_t * _size )

protected

Definition at line 698 of file PqField.cpp.

{
    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;
}

getInteger()

bool PqField::getInteger ( void * _buf, size_t * _size )

protected

Definition at line 288 of file PqField.cpp.

{
    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;
}

getInterval()

bool PqField::getInterval ( SQL::Interval * _buf, size_t * _size )

protected

Definition at line 941 of file PqField.cpp.

{
    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;
}

getNumeric()

bool PqField::getNumeric ( char * _buf, size_t * _size )

protected

Definition at line 968 of file PqField.cpp.

{
    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;
}

getTime()

bool PqField::getTime ( SQL::Time * _buf, size_t * _size )

protected

Definition at line 883 of file PqField.cpp.

{
    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;
}

getTimeStamp()

bool PqField::getTimeStamp ( SQL::TimeStamp * _buf, size_t * _size )

protected

Definition at line 915 of file PqField.cpp.

{
    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;
}

getUInteger()

bool PqField::getUInteger ( void * _buf, size_t * _size )

protected

Definition at line 493 of file PqField.cpp.

{
    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;
}

init()

bool PqField::init	(	SQL::Query *	_query,
		int	_index,
		const PGresult *	_res )

Definition at line 78 of file PqField.cpp.

{
    __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;
}

query()

PqQuery * PqField::query ( ) const

inlineprotected

Definition at line 52 of file PqField.h.

{ 
    return (PqQuery*)Field::__queryHandle; 
}

serverDataTypeName()

const wchar_t * PqField::serverDataTypeName ( ) const

virtual

Implements SQL::Field.

Definition at line 229 of file PqField.cpp.

{
    return __dataTypeName(__type);
}

writeTo()

bool PqField::writeTo ( OutputStream * _output, size_t * _size )

protected

Definition at line 1022 of file PqField.cpp.

{
    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;
}

---

The documentation for this class was generated from the following files:

• PqField.h
• PqField.cpp