PgParam.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <ecpgtype.h>
#include <sqlda.h>
#include <pgtypes_numeric.h>
#include <pgtypes_date.h>
#include <pgtypes_interval.h>
#include <pgtypes_timestamp.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 "PgConnection.h"
#include "PgQuery.h"
#include "PgParam.h"
#include "PgTypes_.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 wchar_t __THIS_FILE__[] = __T("dcl/sql/PgParam.cpp");
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(PgParam, SQL::Param)
 
PgParam::PgParam() : Param(NULL)
{
    __sqlvar = NULL;
}
 
PgParam::~PgParam()
{
}
 
bool PgParam::init(SQL::Query* _queryHandle, sqlvar_t* _sqlvar)
{
    __DCL_ASSERT((Param::__queryHandle == NULL) && (__sqlvar == NULL));
 
    Param::__queryHandle = _queryHandle;
 
    //__DCL_TRACE4_N(L"type[%d] len[%d] data[%p] ind[%p]\n",
    //  _sqlvar->sqltype, _sqlvar->sqllen,
    //  _sqlvar->sqldata, _sqlvar->sqlind);
 
    __sqlvar = _sqlvar;
    //__sqlvar->sqltype = 0;
    //__sqlvar->sqllen = 0;
    //__sqlvar->sqldata = NULL;
    __sqlvar->sqlind = &__indicator;
    __indicator = -1;   // set null 
 
    return true;
}
 
#if __DCL_DEBUG
void PgParam::onBeforeExecute()
{
#if __TRACE_THIS && 1
    if (__dataType == SQL::typeText) {
        __DCL_TRACE2_N(L"sqltype[%d] sqllen[%d]\n",
            __sqlvar->sqltype, __sqlvar->sqllen);
        __DCL_TRACE2_N(L"sqldata[%p] [%ls]\n", __sqlvar->sqldata,
            String::tryString((const char*)__sqlvar->sqldata, __sqlvar->sqllen).data());
    }
#endif
}
#endif
 
bool PgParam::onAfterExecute()
{
    Param::__dataType = SQL::typeUnknown;
    __sqlvar->sqltype = 0;
    __sqlvar->sqllen = 0;
    __sqlvar->sqldata = NULL;
    __indicator = -1;   // set null 
    __bytes.clear();
 
    return true;
}
 
// in PgField.cpp
const wchar_t* __dataTypeName(const sqlvar_t* _sqlvar);
 
const wchar_t* PgParam::serverDataTypeName() const
{
    return __dataTypeName(__sqlvar);
}
 
void PgParam::setNull()
{
    Param::__dataType = SQL::typeUnknown;
    __sqlvar->sqltype = 0;
    __sqlvar->sqllen = 0;
    __sqlvar->sqldata = NULL;
    __indicator = -1;   // set null 
}
 
bool PgParam::__setData(
        _CONST void* _pv,
        size_t      _size,
        SQL::DataType  _dataType,
        SQL::DataType  _assignType
        )
{
    switch(_dataType) {
        case SQL::typeInteger: {
            switch (_size) {
                case sizeof(int8_t) : {
                    __data.i32 = (int32_t) * (int8_t*)_pv;
                    __sqlvar->sqltype = ECPGt_int;
                    __sqlvar->sqllen = sizeof(int32_t);
                    __sqlvar->sqldata = (char*)&__data;
                    break;
                }
                case sizeof(int16_t) : {
                    __data.i32 = (int32_t) * (int16_t*)_pv;
                    __sqlvar->sqltype = ECPGt_int;
                    __sqlvar->sqllen = sizeof(int32_t);
                    __sqlvar->sqldata = (char*)&__data;
                    break;
                }
                case sizeof(int32_t) : {
                    __data.i32 = *(int32_t*)_pv;
                    __sqlvar->sqltype = ECPGt_int;
                    __sqlvar->sqllen = sizeof(int32_t);
                    __sqlvar->sqldata = (char*)&__data;
                    break;
                }
                case sizeof(int64_t) : {
                    __data.i64 = *(int64_t*)_pv;
#if ALIGNOF_LONG == 8
                    __sqlvar->sqltype = ECPGt_long;
#else
                    __sqlvar->sqltype = ECPGt_long_long;
#endif
                    __sqlvar->sqllen = sizeof(int64_t);
                    __sqlvar->sqldata = (char*)&__data;
                    break;
                }
                default: {
                    __SET_ERROR(SQL::eInvalidDataSize);
                    return false;
                }
            }
            break;
        }
        case SQL::typeUInteger: {
            switch (_size) {
                case sizeof(uint8_t) : {
                    __data.i32 = (int32_t) * (uint8_t*)_pv;
                    __sqlvar->sqltype = ECPGt_int;
                    __sqlvar->sqllen = sizeof(uint32_t);
                    __sqlvar->sqldata = (char*)&__data;
                    break;
                }
                case sizeof(uint16_t) : {
                    __data.i32 = (int32_t) * (uint16_t*)_pv;
                    __sqlvar->sqltype = ECPGt_int;
                    __sqlvar->sqllen = sizeof(uint32_t);
                    __sqlvar->sqldata = (char*)&__data;
                    break;
                }
                case sizeof(uint32_t) : {
                    __data.i32 = (int32_t) * (uint32_t*)_pv;
                    __sqlvar->sqltype = ECPGt_int;
                    __sqlvar->sqllen = sizeof(uint32_t);
                    __sqlvar->sqldata = (char*)&__data;
                    break;
                }
                case sizeof(uint64_t) : {
                    __data.i64 = (int64_t) * (uint64_t*)_pv;
#if ALIGNOF_LONG == 8
                    __sqlvar->sqltype = ECPGt_long;
#else
                    __sqlvar->sqltype = ECPGt_long_long;
#endif
                    __sqlvar->sqllen = sizeof(int64_t);
                    __sqlvar->sqldata = (char*)&__data;
                    break;
                }
                default: {
                    __SET_ERROR(SQL::eInvalidDataSize);
                    return false;
                }
            }
            break;
        }
        case SQL::typeFloat: {
            switch (_size) {
                case sizeof(float) : {
                    __data.f32 = *(float*)_pv;
                    __sqlvar->sqltype = ECPGt_float;
                    __sqlvar->sqllen = sizeof(float);
                    __sqlvar->sqldata = (char*)&__data;
                    break;
                }
                case sizeof(double) : {
                    __data.f64 = *(double*)_pv;
                    __sqlvar->sqltype = ECPGt_double;
                    __sqlvar->sqllen = sizeof(double);
                    __sqlvar->sqldata = (char*)&__data;
                    break;
                }
                default: {
                    __SET_ERROR(SQL::eInvalidDataSize);
                    return false;
                }
            }
            break;
        }
        case SQL::typeDate: {
            if (_size == sizeof(SQL::Date)) {
                __encode((const SQL::Date*)_pv, &__data.dt);
                __sqlvar->sqltype = ECPGt_date;
                __sqlvar->sqllen = sizeof(date);
                __sqlvar->sqldata = (char*)&__data;
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            break;
        }
        case SQL::typeTime: {
            if (_size == sizeof(SQL::Time)) {
                __bytes = __encode((const SQL::Time*)_pv);
                __sqlvar->sqltype = ECPGt_char;
                __sqlvar->sqllen = (short)__bytes.length();
                __sqlvar->sqldata = (char*)__bytes.data();
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            break;
        }
        case SQL::typeTimeStamp: {
            if (_size == sizeof(SQL::TimeStamp)) {
                const SQL::TimeStamp* p = (const SQL::TimeStamp*)_pv;
#if 0
                if (p->tzoff != INT16_MIN) {
                    __SET_ERROR(SQL::eInvalidData);
                    return false;
                }
#endif
                __encode(p, &__data.ts);
                __sqlvar->sqltype = ECPGt_timestamp;
                __sqlvar->sqllen = sizeof(timestamp);
                __sqlvar->sqldata = (char*)&__data;
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            break;
        }
        case SQL::typeInterval: {
            if (_size == sizeof(SQL::Interval)) {
                __encode((const SQL::Interval*)_pv, &__data.ival);
                __sqlvar->sqltype = ECPGt_interval;
                __sqlvar->sqllen = sizeof(interval);
                __sqlvar->sqldata = (char*)&__data;
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            break;
        }
        case SQL::typeText: {
            if (_assignType == SQL::typeNumeric) {
                if (_size > 0) {
                    numeric* p = PGTYPESnumeric_from_asc((char*)_pv, NULL);
                    if (!p) {
                        __SET_ERROR(SQL::eInvalidData);
                        return false;
                    }
                    PGTYPESnumeric_copy(p, &__data.nu);
                    __sqlvar->sqltype = ECPGt_numeric;
                    __sqlvar->sqllen = sizeof(numeric);
                    __sqlvar->sqldata = (char*)&__data;
                }
                else {
                    __SET_ERROR(SQL::eInvalidDataSize);
                    return false;
                }
                break;
            }
#if __TRACE_THIS && 1
            __DCL_TRACE2_N(L"_dataType[%d] _size[%zd]\n",
                _dataType, _size);
            __DCL_TRACE2_N(L"_pv[%p] [%ls]\n", _pv,
                String::tryString((const char*)_pv, _size).data());
#endif
        }
        case SQL::typeBinary: {
            switch (_assignType) {
                case SQL::typeText:        // CHAR, VARCHAR
                case SQL::typeLongText: {
                    __sqlvar->sqltype = ECPGt_char;
                    __sqlvar->sqllen = (short) _size;
                    __sqlvar->sqldata = (char*) _pv;
                    break;
                }
                case SQL::typeBinary:    // ECPGt_bytea 동작하지 않는다!
                case SQL::typeLongBinary: {
                    __bytes = ByteString::toHexString(
                        (const char*)_pv, _size, (size_t)-1, true);
                    if (__bytes.length() > INT16_MAX) {
                        __SET_ERROR(SQL::eInvalidDataSize);
                        return false;
                    }
                    __sqlvar->sqltype = ECPGt_char;
                    __sqlvar->sqllen = (short)__bytes.length();
                    __sqlvar->sqldata = (char*)__bytes.data();
                    break;
                }
                default: {
                    __SET_ERROR(SQL::eNotSupportDataType);
                    return false;
                }
            }
            break;
        }
        case SQL::typeInputStream: {
            try {
                __bytes = Files::readBytes(*(InputStream*)_pv, _size);
            }
            catch (IOException* e) {
                __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
                e->destroy();
                return false;
            }
            if (__bytes.length() > INT16_MAX) {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            __bytes = ByteString::toHexString(__bytes, (size_t)-1, true);
            if (__bytes.length() > INT16_MAX) {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            __sqlvar->sqltype = ECPGt_char;
            __sqlvar->sqllen = (short) __bytes.length();
            __sqlvar->sqldata = (char*)__bytes.data();
            break;
        }
        default: {
            __SET_ERROR(SQL::eNotSupportDataType);
            return false;
        }
    }
 
    __indicator = 0;
    Param::__dataType = _assignType;
    return true;
}
 
__DCL_END_NAMESPACE