PqParam.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __APPLE__
#include <libkern/OSByteOrder.h>
#endif
#include <stdlib.h>     // PqTypes.h _byteswap_
 
#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/DateTime.h>
#include <dcl/InputStream.h>
#include <dcl/Files.h>
#include <dcl/SQLCore.h>
 
#include "PqConnection.h"
#include "PqQuery.h"
#include "PqParam.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
#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/PqParam.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(PqParam, SQL::Param)
 
PqParam::PqParam() : Param(NULL)
{
    __index = -1;
    __type = -1;
}
 
PqParam::~PqParam()
{
}
 
bool PqParam::init(SQL::Query* _queryHandle, int _index, const PGresult* _res)
{
    __DCL_ASSERT(Param::__queryHandle == NULL);
    __DCL_ASSERT(_queryHandle != NULL && _res != NULL);
 
    Param::__queryHandle = _queryHandle;
 
    __index = _index;
    __type = PQparamtype(_res, _index);
 
    return true;
}
 
bool PqParam::onAfterExecute()
{
    Param::__dataType = SQL::typeUnknown;
    __bytes.clear();
 
    return true;
}
 
const wchar_t* PqParam::serverDataTypeName() const
{
    return __dataTypeName(__type);
}
 
void PqParam::setNull()
{
    Param::__dataType = SQL::typeUnknown;
}
 
static inline int __ABS(int _n)
{
    return _n < 0 ? -_n : _n;
}
 
bool PqParam::__setData(
    _CONST void*  _val,
    size_t          _size,
    SQL::DataType  _valType,
    SQL::DataType  _sqlType
)
{
    bool r = false;
    switch(_valType) {
        case SQL::typeInteger:
            r = setInteger(_val, _size);
            break;
        case SQL::typeUInteger:
            r = setUInteger(_val, _size);
            break;
        case SQL::typeFloat:
            r = setFloat(_val, _size);
            break;
        case SQL::typeDate: 
            r = setDate((const SQL::Date*)_val, _size);
            break;
        case SQL::typeTime:
            r = setTime((const SQL::Time*)_val, _size);
            break;
        case SQL::typeTimeStamp:
            r = setTimeStamp((const SQL::TimeStamp*)_val, _size);
            break;
        case SQL::typeInterval:
            r = setInterval((const SQL::Interval*)_val, _size);
            break;
        case SQL::typeText:
        case SQL::typeBinary:
        case SQL::typeInputStream:
            r = setBytes(_val, _size, _valType, _sqlType);
            break;
        default: {
            __SET_ERROR(SQL::eNotSupportDataType);
            return false;
        }
    }
 
    if (r) {
        Param::__dataType = _sqlType;
    }
    return r;
}
 
bool PqParam::setInteger(const void* _val, size_t _size)
{
    int64_t n;
    switch (_size) {
        case sizeof(int8_t) : {
            n = *(int8_t*)_val;
            break;
        }
        case sizeof(int16_t) : {
            n = *(int16_t*)_val;
            break;
        }
        case sizeof(int32_t) : {
            n = *(int32_t*)_val;
            break;
        }
        case sizeof(int64_t) : {
            n = *(int64_t*)_val;
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
 
    switch (__type) {
        case BOOLOID: {
            __data.u8 = n ? 1 : 0;
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u8), __FORMAT_BINARY);
            break;
        }
        case INT2OID: {
            if (n < INT16_MIN || INT16_MAX < n) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            __data.u16 = __htons((uint16_t)(int16_t)n);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u16), __FORMAT_BINARY);
            break;
        }
        case INT4OID: {
            if (n < INT32_MIN || INT32_MAX < n) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            __data.u32 = __htonl((uint32_t)(int32_t)n);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u32), __FORMAT_BINARY);
            break;
        }
        case INT8OID: {
            __data.u64 = __htonll((uint64_t)(int64_t)n);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u64), __FORMAT_BINARY);
            break;
        }
        case FLOAT4OID: {
            __data.u32 = __htonf((float)n);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u32), __FORMAT_BINARY);
            break;
        }
        case FLOAT8OID: {
            __data.u64 = __htond((double)n);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u64), __FORMAT_BINARY);
            break;
        }
        case MONEYOID:
        case NUMERICOID:
        case CHAROID:
        case BPCHAROID:
        case VARCHAROID:
        case TEXTOID: {
            __bytes = ByteString::valueOf(n);
            query()->setValue(__index, __type,
                __bytes.data(), (unsigned)__bytes.length(), __FORMAT_TEXT
            );
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    return true;
}
 
bool PqParam::setUInteger(const void* _val, size_t _size)
{
    uint64_t u;
    switch (_size) {
        case sizeof(uint8_t) : {
            u = *(uint8_t*)_val;
            break;
        }
        case sizeof(uint16_t) : {
            u = *(uint16_t*)_val;
            break;
        }
        case sizeof(uint32_t) : {
            u = *(uint32_t*)_val;
            break;
        }
        case sizeof(uint64_t) : {
            u = *(uint64_t*)_val;
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
 
    switch (__type) {
        case BOOLOID: {
            __data.u8 = u ? 1 : 0;
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u8), __FORMAT_BINARY);
            break;
        }
        case INT2OID: {
            if (UINT16_MAX < u) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            __data.u16 = __htons((uint16_t)u);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u16), __FORMAT_BINARY);
            break;
        }
        case INT4OID: {
            if (UINT32_MAX < u) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            __data.u32 = __htonl((uint32_t)u);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u32), __FORMAT_BINARY);
            break;
        }
        case INT8OID: {
            __data.u64 = __htonll((uint64_t)u);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u64), __FORMAT_BINARY);
            break;
        }
        case FLOAT4OID: {
            __data.u32 = __htonf((float)u);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u32), __FORMAT_BINARY);
            break;
        }
        case FLOAT8OID: {
            __data.u64 = __htond((double)u);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u64), __FORMAT_BINARY);
            break;
        }
        case MONEYOID:
        case NUMERICOID:
        case CHAROID:
        case BPCHAROID:
        case VARCHAROID:
        case TEXTOID: {
            __bytes = ByteString::valueOf(u);
            query()->setValue(__index, __type,
                __bytes.data(), (unsigned)__bytes.length(), __FORMAT_TEXT
            );
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    return true;
}
 
bool PqParam::setFloat(const void* _val, size_t _size)
{
    double d;
    switch (_size) {
        case sizeof(float) : {
            d = *(float*)_val;
            break;
        }
        case sizeof(double) : {
            d = *(double*)_val;
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
 
    switch (__type) {
        case BOOLOID: {
            __data.u8 = d != 0 ? 1 : 0;
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u8), __FORMAT_BINARY);
            break;
        }
        case INT2OID: {
            if (d < INT16_MIN || INT16_MAX < d) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            __data.u16 = __htons((uint16_t)(int16_t)d);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u16), __FORMAT_BINARY);
            break;
        }
        case INT4OID: {
            if (d < INT32_MIN || INT32_MAX < d) {
                __SET_ERROR(SQL::eOutOfRange);
                return false;
            }
            __data.u32 = __htonl((uint32_t)(int32_t)d);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u32), __FORMAT_BINARY);
            break;
        }
        case INT8OID: {
            __data.u64 = __htonll((uint64_t)(int64_t)d);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u64), __FORMAT_BINARY);
            break;
        }
        case FLOAT4OID: {
            __data.u32 = __htonf((float)d);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u32), __FORMAT_BINARY);
            break;
        }
        case FLOAT8OID: {
            __data.u64 = __htond((double)d);
            query()->setValue(__index, __type,
                &__data, sizeof(__data.u64), __FORMAT_BINARY);
            break;
        }
        case MONEYOID:
        case NUMERICOID:
        case CHAROID:
        case BPCHAROID:
        case VARCHAROID:
        case TEXTOID: {
            __bytes = ByteString::format((_size == 4 ? "%.8g" : "%.16g"), d);
            query()->setValue(__index, __type,
                __bytes.data(), (unsigned)__bytes.length(), __FORMAT_TEXT
            );
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    return true;
}
 
bool PqParam::setDate(const SQL::Date* _val, size_t _size)
{
    if (_size != sizeof(SQL::Date)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    const SQL::Date* val = (const SQL::Date*)_val;
    ByteStringBuilder sb;
    sb.format(
        "%04d-%02d-%02d",
        __ABS(val->year),
        val->month,
        val->day
    );
    if (val->year < 0) {
        sb += " BC";
    }
    __bytes = sb.toByteString();
 
    switch (__type) {
        case DATEOID:
        case TIMESTAMPOID:
        case TIMESTAMPTZOID:
        case CHAROID:
        case BPCHAROID:
        case VARCHAROID:
        case TEXTOID: {
            query()->setValue(__index, __type,
                __bytes.data(), (int)__bytes.length(), __FORMAT_TEXT
            );
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    return true;
}
 
bool PqParam::setTime(const SQL::Time* _val, size_t _size)
{
    if (_size != sizeof(SQL::Time)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    const SQL::Time* val = (const SQL::Time*)_val;
    if (val->tzoff == INT16_MIN) {
        __bytes = ByteString::format(
            "%02d:%02d:%02d.%06d",
            val->hour,
            val->min,
            val->sec,
            val->frac / 1000
        );
    }
    else {
        __bytes = ByteString::format(
            "%02d:%02d:%02d.%06d %+03d:%02d",
            val->hour,
            val->min,
            val->sec,
            val->frac / 1000,
            val->tzoff / 60,
            __ABS(val->tzoff % 60)
        );
    }
 
    switch (__type) {
        case TIMEOID:
        case CHAROID:
        case BPCHAROID:
        case VARCHAROID:
        case TEXTOID: {
            query()->setValue(__index, __type,
                __bytes.data(), (int)__bytes.length(), __FORMAT_TEXT
            );
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    return true;
}
 
bool PqParam::setTimeStamp(const SQL::TimeStamp* _val, size_t _size)
{
    if (_size != sizeof(SQL::TimeStamp)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    const SQL::TimeStamp* val = (const SQL::TimeStamp*)_val;
    ByteStringBuilder sb;
    if (val->tzoff == INT16_MIN) {
        sb.format(
            "%04d-%02d-%02d %02d:%02d:%02d.%06d",
            __ABS(val->year),
            val->month,
            val->day,
            val->hour,
            val->min,
            val->sec,
            val->frac / 1000
        );
    }
    else {
        sb.format(
            "%04d-%02d-%02d %02d:%02d:%02d.%06d %+03d:%02d",
            __ABS(val->year),
            val->month,
            val->day,
            val->hour,
            val->min,
            val->sec,
            val->frac / 1000,
            val->tzoff / 60,
            __ABS(val->tzoff % 60)
        );
    }
    if (val->year < 0) {
        sb += " BC";
    }
    __bytes = sb.toByteString();
 
    switch (__type) {
        case DATEOID:
        case TIMESTAMPOID:
        case TIMESTAMPTZOID:
        case CHAROID:
        case BPCHAROID:
        case VARCHAROID:
        case TEXTOID: {
            query()->setValue(__index, __type,
                __bytes.data(), (int)__bytes.length(), __FORMAT_TEXT
            );
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    return true;
}
 
bool PqParam::setInterval(const SQL::Interval* _val, size_t _size)
{
    if (_size != sizeof(SQL::Interval)) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    const SQL::Interval* val = (const SQL::Interval*)_val;
    if (val->secs || val->fracs >= 0) {
        __bytes = ByteString::format(
            "P%dY%dM%dDT%dH%dM%d.%dS",
            val->years,
            val->months,
            val->days,
            val->hours,
            val->mins,
            val->secs,
            __ABS(val->fracs)
        );
    }
    else {
        __bytes = ByteString::format(
            "P%dY%dM%dDT%dH%dM%-0.%dS",
            val->years,
            val->months,
            val->days,
            val->hours,
            val->mins,
            __ABS(val->fracs)
        );
    }
 
    switch (__type) {
        case INTERVALOID:
        case CHAROID:
        case BPCHAROID:
        case VARCHAROID:
        case TEXTOID: {
            query()->setValue(__index, __type,
                __bytes.data(), (int)__bytes.length(), __FORMAT_TEXT
            );
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    return true;
}
 
bool PqParam::setBytes(
    _CONST void*  _val,
    size_t          _size,
    SQL::DataType  _valType,
    SQL::DataType  _sqlType
)
{
    const char* val = (const char*)_val;
    size_t size = _size;
    SQL::DataType valType = _valType;
    if (_valType == SQL::typeInputStream) {
        try {
            __bytes = Files::readBytes(*(InputStream*)_val, _size);
            val = __bytes;
            size = __bytes.length();
        }
        catch (IOException* _e) {
            __SET_ERROR_MSG(UTF8Encoder::encode(_e->toStringAll()));
            _e->destroy();
            return false;
        }
        if (_sqlType == SQL::typeBinary
            || _sqlType == SQL::typeLongBinary
            || _sqlType == SQL::typeBlob) {
            valType = SQL::typeBinary;
        }
    }
 
    if (10 * 1024 * 1024 < size) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    if (valType == SQL::typeText) {
        switch (__type) {
            case BYTEAOID:
            case CHAROID:           
            case BPCHAROID:
            case VARCHAROID:
 
            case TEXTOID:
            case JSONOID:
            case XMLOID:
 
            case TSVECTOROID:
            case TSQUERYOID:
            case JSONBOID:
            case JSONPATHOID: {
                // 여기서 FORMAT_BINARY는 
                // 서버에서 변환하지 마라! 의미
                query()->setValue(__index, __type,
                    val, (unsigned)size, __FORMAT_BINARY
                );
                break;
            }
            case BOOLOID:
            case INT2OID:
            case INT4OID:
            case INT8OID:
            case FLOAT4OID:
            case FLOAT8OID:
            case MONEYOID:
            case NUMERICOID:
            case DATEOID:
            case TIMEOID:
            case TIMETZOID:
            case TIMESTAMPOID:
            case TIMESTAMPTZOID:
            case INTERVALOID:
            case BITOID:
            case VARBITOID:
 
            case MACADDROID:
            case INETOID:
            case CIDROID:
            case MACADDR8OID:
 
            case UUIDOID:
            default: {
                // 텍스트를 서버에서 적절히 변환해서 사용하라!
                query()->setValue(__index, __type,
                    val, (unsigned)size, __FORMAT_TEXT
                );
            }
#if 0
            default: {
                __SET_ERROR(SQL::eNotSupportDataType);
                return false;
            }
#endif
        }
    }
    else {
        // SQL::typeBinary는
        // 서버에서 변환하지 마라!
        query()->setValue(__index, __type,
            val, (unsigned)size, __FORMAT_BINARY
        );
    }
 
    return true;
}
 
__DCL_END_NAMESPACE