IFXParam.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <sqlhdr.h>
#include <sqltypes.h>
#include <locator.h>
#include <sqlda.h>
 
#ifndef _IFXTYPES_H_
// locator.h에서 ifxtypes.h가 인크루드 되어 있으면 이 문장이 필요 없다.
// Informix Client-SDK 버전에 따라 다르다.
typedef int mint;
#endif
 
#include <dcl/Object.h>
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/InputStream.h>
#include <dcl/SQLCore.h>
 
#include "IFXConnection.h"
#include "IFXQuery.h"
#include "IFXParam.h"
#include "IFXTypes_.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/IFXParam.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#define __SET_ERROR(_error) \
    conn()->setErrorHandle(_error, 0L, __THIS_FILE__, __LINE__)
#define __SET_ERROR_HANDLE(_SQLCODE) \
    conn()->setErrorHandle(SQL::eServerError, _SQLCODE, __THIS_FILE__, __LINE__)
#define __SET_ERROR_MSG(_message) \
    conn()->setErrorMessage(_message, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(IFXParam, SQL::Param)
 
IFXParam::IFXParam() : Param(NULL)
{
    __sqlvar = NULL;
}
 
IFXParam::~IFXParam()
{
}
 
bool IFXParam::init(SQL::Query* _queryHandle, ifx_sqlvar_t* _sqlvar)
{
    __DCL_ASSERT((Param::__queryHandle == NULL) && (__sqlvar == NULL));
 
    Param::__queryHandle = _queryHandle;
 
    __sqltype = _sqlvar->sqltype;
    __sqllen = _sqlvar->sqllen;
    __indicator = -1;   // set null 
    __sqlvar = _sqlvar;
    __sqlvar->sqldata = NULL;
    __sqlvar->sqlind = &__indicator;
 
    return true;
}
 
bool IFXParam::onAfterExecute()
{
    bool r = true;
    if (__sqlvar->sqltype == CLOCATORTYPE && __sqlvar->sqldata) {
        loc_t* loc = (loc_t*)(__sqlvar->sqldata);
        if (loc->loc_status != 0) {
            __SET_ERROR_HANDLE(loc->loc_status);
            r = false;;
        }
    }
 
    Param::__dataType = SQL::typeUnknown;
    __indicator = -1;   // set null 
    __sqlvar->sqldata = NULL;
 
    return r;
}
 
// in IFXField.cpp
const wchar_t* __dataTypeName(const ifx_sqlvar_t* _sqlvar);
 
const wchar_t* IFXParam::serverDataTypeName() const
{
    return __dataTypeName(__sqlvar);
}
 
void IFXParam::setNull()
{
    Param::__dataType = SQL::typeUnknown;
    __indicator = -1;   // set null 
    __sqlvar->sqldata = NULL;
}
 
bool IFXParam::__setData(
    _CONST void*  _val,
    size_t          _size,
    SQL::DataType  _valType,
    SQL::DataType  _sqlType
)
{
    bool r = true;
    switch(_valType) {
        case SQL::typeInteger : {
            r = setInteger(_val, _size);
            break;
        }
        case SQL::typeUInteger: {
            r = setUInteger(_val, _size);
            break;
        }
        case SQL::typeFloat: {
            if (_size == sizeof(float)) {
                __data.f32 = *(float*)_val;
                __sqlvar->sqldata = (char*)&__data;
                __sqlvar->sqltype = CFLOATTYPE;
                __sqlvar->sqllen = sizeof(float);
            }
            else if (_size == sizeof(double)) {
                __data.f64 = *(double*)_val;
                __sqlvar->sqldata = (char*)&__data;
                __sqlvar->sqltype = CDOUBLETYPE;
                __sqlvar->sqllen = sizeof(double);
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            break;
        }
        case SQL::typeDate: {
            if (_size == sizeof(SQL::Date)) {
                const SQL::Date* p = (const SQL::Date*)_val;
                short mdy[3];
                mdy[0] = p->month;
                mdy[1] = p->day;
                mdy[2] = p->year;
 
                int r = rmdyjul(mdy, &__data.date);
                if (r) {
                    __SET_ERROR_HANDLE(r);
                    return false;
                }
                __sqlvar->sqldata = (char*)&__data;
                __sqlvar->sqltype = CDATETYPE;
                __sqlvar->sqllen = sizeof(long);
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            break;
        }
        case SQL::typeTime: {
            if (_size == sizeof(SQL::Time)) {
                const SQL::Time* p = (const SQL::Time*)_val;
                int r = __encode_dtime(p, &__data.dtime);
                if (r) {
                    __SET_ERROR_HANDLE(r);
                    return false;
                }
 
                __sqlvar->sqldata = (char*)&__data;
                __sqlvar->sqltype = CDTIMETYPE;
                __sqlvar->sqllen = sizeof(dtime_t);
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            break;
        }
        case SQL::typeTimeStamp: {
            if (_size == sizeof(SQL::TimeStamp)) {
                const SQL::TimeStamp* p = (const SQL::TimeStamp*)_val;
                int r = __encode_dtime(p, &__data.dtime);
                if (r) {
                    __SET_ERROR_HANDLE(r);
                    return false;
                }
 
                __sqlvar->sqldata = (char*)&__data;
                __sqlvar->sqltype = CDTIMETYPE;
                __sqlvar->sqllen = sizeof(dtime_t);
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            break;
        }
        case SQL::typeInterval: {
            if (_size == sizeof(SQL::Interval)) {
                int r = __encode_intrvl(
                    (const SQL::Interval*)_val,
                    _sqlType,
                    &__data.ival
                    );
                if (r) {
                    __SET_ERROR_HANDLE(r);
                    return false;
                }
 
                __sqlvar->sqldata = (char*)&__data;
                __sqlvar->sqltype = CINVTYPE;
                __sqlvar->sqllen = sizeof(intrvl_t);
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            break;
        }
        case SQL::typeText : {
            if (_sqlType == SQL::typeNumeric) {
                if (_size > 0) {
                    int r = deccvasc((char*)_val, _size, &__data.dec);
                    if (r) {
                        __SET_ERROR_HANDLE(r);
                        return false;
                    }
                    __sqlvar->sqldata = (char*)&__data;
                    __sqlvar->sqltype = CDECIMALTYPE;
                    __sqlvar->sqllen = sizeof(dec_t);
                }
                else {
                    __SET_ERROR(SQL::eInvalidDataSize);
                    return false;
                }
                break;
            }
        }
        case SQL::typeBinary: {
            r = setBytes(_val, _size, _sqlType);
            break;
        }
        case SQL::typeInputStream: {
            r = setInputStream(_val, _size, _sqlType);
            break;
        }
        default: {
            __SET_ERROR(SQL::eNotSupportDataType);
            return false;
        }
    }
 
    if (r) {
        __indicator = 0;
        Param::__dataType = _sqlType;
    }
 
    return true;
}
 
bool IFXParam::setInteger(const void* _val, size_t _size)
{
    switch (_size) {
        case sizeof(int8_t) : {
            __data.i32 = (int32_t) * (int8_t*)_val;
            __sqlvar->sqltype = CLONGTYPE;
            __sqlvar->sqllen = sizeof(int32_t);
            break;
        }
        case sizeof(int16_t) : {
            __data.i32 = (int32_t) * (int16_t*)_val;
            __sqlvar->sqltype = CLONGTYPE;
            __sqlvar->sqllen = sizeof(int32_t);
            break;
        }
        case sizeof(int32_t) : {
            __data.i32 = *(int32_t*)_val;
            __sqlvar->sqltype = CLONGTYPE;
            __sqlvar->sqllen = sizeof(int32_t);
            break;
        }
        case sizeof(int64_t) : {
            __data.i64 = *(int64_t*)_val;
            __sqlvar->sqltype = CBIGINTTYPE;
            __sqlvar->sqllen = sizeof(bigint);
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataSize);
            return false;
        }
    }
    __sqlvar->sqldata = (char*)&__data;
    return true;
}
 
bool IFXParam::setUInteger(const void* _val, size_t _size)
{
    switch (__sqltype & SQLTYPE) {
        case SQLSMINT:
        case SQLINT:
        case SQLSERIAL: {
            switch (_size) {
                case sizeof(uint8_t) : {
                    __data.i32 = (int32_t) * (uint8_t*)_val;
                    __sqlvar->sqltype = CLONGTYPE;
                    __sqlvar->sqllen = sizeof(int32_t);
                    break;
                }
                case sizeof(uint16_t) : {
                    __data.i32 = (int32_t) * (uint16_t*)_val;
                    __sqlvar->sqltype = CLONGTYPE;
                    __sqlvar->sqllen = sizeof(int32_t);
                    break;
                }
                case sizeof(uint32_t) : {
                    __data.i32 = (int32_t) * (uint32_t*)_val;
                    __sqlvar->sqltype = CLONGTYPE;
                    __sqlvar->sqllen = sizeof(int32_t);
                    break;
                }
                case sizeof(uint64_t) : {
                    __data.i64 = (int64_t) * (uint32_t*)_val;
                    __sqlvar->sqltype = CBIGINTTYPE;
                    __sqlvar->sqllen = sizeof(bigint);
                    break;
                }
                default: {
                    __SET_ERROR(SQL::eInvalidDataSize);
                    return false;
                }
            }
            break;
        }
        case SQLINT8:
        case SQLSERIAL8:
        case SQLINFXBIGINT:
        case SQLBIGSERIAL: {
            switch (_size) {
                case sizeof(uint8_t) : {
                    __data.i64 = (int64_t) * (uint8_t*)_val;
                    __sqlvar->sqltype = CBIGINTTYPE;
                    __sqlvar->sqllen = sizeof(int32_t);
                    break;
                }
                case sizeof(uint16_t) : {
                    __data.i64 = (int64_t) * (uint16_t*)_val;
                    __sqlvar->sqltype = CBIGINTTYPE;
                    __sqlvar->sqllen = sizeof(int32_t);
                    break;
                }
                case sizeof(uint32_t) : {
                    __data.i64 = (int64_t) * (uint32_t*)_val;
                    __sqlvar->sqltype = CBIGINTTYPE;
                    __sqlvar->sqllen = sizeof(int32_t);
                    break;
                }
                case sizeof(uint64_t) : {
                    __data.i64 = (int64_t) * (uint32_t*)_val;
                    __sqlvar->sqltype = CBIGINTTYPE;
                    __sqlvar->sqllen = sizeof(bigint);
                    break;
                }
                default: {
                    __SET_ERROR(SQL::eInvalidDataSize);
                    return false;
                }
            }
            break;
        }
        default: {
            __SET_ERROR(SQL::eInvalidDataType);
            return false;
        }
    }
 
    __sqlvar->sqldata = (char*)&__data;
    return true;
}
 
bool IFXParam::setBytes(const void* _val, size_t _size,
        SQL::DataType _sqlType)
{
    switch (__sqltype & SQLTYPE) {
        case SQLTEXT:
        case SQLBYTES: {
            if (_size > INT32_MAX) {
                __SET_ERROR(SQL::eInvalidDataSize);
                return false;
            }
            switch (_sqlType) {
                case SQL::typeText:
                case SQL::typeLongText:
                case SQL::typeClob: {
                    __data.loc.loc_type = SQLTEXT;
                    break;
                }
                case SQL::typeBinary:
                case SQL::typeLongBinary:
                case SQL::typeBlob: {
                    __data.loc.loc_type = SQLBYTES;
                    break;
                }
                default: {
                    __SET_ERROR(SQL::eNotSupportDataType);
                    return false;
                }
            }
            __data.loc.loc_loctype = LOCMEMORY;
            __data.loc.loc_indicator = 0;
            // __data.loc.loc_type = SQLTEXT or SQLBYTES;
            __data.loc.loc_mflags = 0;
            __data.loc.loc_oflags = LOC_WONLY;
 
            __data.loc.loc_buffer = (char*)_val;
            __data.loc.loc_bufsize = _size;
            __data.loc.loc_size = _size;
 
            __sqlvar->sqltype = CLOCATORTYPE;
            __sqlvar->sqllen = sizeof(loc_t);
            __sqlvar->sqldata = (char*)&__data.loc;
            break;
        }
        default: {
            switch (_sqlType) {
                case SQL::typeText:
                case SQL::typeLongText:
                case SQL::typeClob: {
                    __sqlvar->sqltype = CFIXCHARTYPE;
                    break;
                }
                case SQL::typeBinary:
                case SQL::typeLongBinary:
                case SQL::typeBlob: {
                    __sqlvar->sqltype = CFIXBINTYPE;
                    break;
                }
                default: {
                    __SET_ERROR(SQL::eNotSupportDataType);
                    return false;
                }
            }
            __sqlvar->sqldata = (char*)_val;            
            __sqlvar->sqllen = _size;
        }
    }
    return true;
}
 
static mint on_loc_open(loc_t* _loc, mint _flag, mint _bsize);
static mint on_loc_read(loc_t* _loc, char* _val, mint _buflen);
static mint on_loc_close(loc_t* _loc);
 
bool IFXParam::setInputStream(const void* _val, size_t _size,
        SQL::DataType _sqlType)
{
    if (_size != (size_t)-1 && _size > INT32_MAX) {
        __SET_ERROR(SQL::eInvalidDataSize);
        return false;
    }
 
    switch (_sqlType) {
        case SQL::typeText:
        case SQL::typeLongText:
        case SQL::typeClob: {
            __data.loc.loc_type = SQLTEXT;
            break;
        }
        case SQL::typeBinary:
        case SQL::typeLongBinary:
        case SQL::typeBlob: {
            __data.loc.loc_type = SQLBYTES;
            break;
        }
        default: {
            __SET_ERROR(SQL::eNotSupportDataType);
            return false;
        }
    }
 
    __data.loc.loc_open = on_loc_open;
    __data.loc.loc_read = on_loc_read;
    __data.loc.loc_close = on_loc_close;
    __data.loc.loc_write = NULL;
 
    __data.loc.loc_loctype = LOCUSER;
    __data.loc.loc_indicator = 0;
    // __data.loc.loc_type = SQLTEXT or SQLBYTES;
    __data.loc.loc_mflags = 0;
    __data.loc.loc_oflags = LOC_WONLY;
 
    __data.loc.loc_user_env = (char*)_val;
    __data.loc.loc_size = _size;
 
    __sqlvar->sqldata = (char*)&__data;
    __sqlvar->sqltype = CLOCATORTYPE;
    __sqlvar->sqllen = sizeof(loc_t);
 
    return true;
}
 
// MSVCRTD.DLL을 사용하는 윈도우용 DEBUG 버전은 LOCFILE을 사용할 경우
// 실패한다. DEBUG 버전에서는 LOCUSER로 대체한다.
static mint on_loc_open(loc_t* _loc, mint _flag, mint _bsize)
{
    _loc->loc_status = 0;
    _loc->loc_xfercount = 0L;
 
    /*
        if error {
            _loc->loc_status = -452;
            return -1;
        }
    */
    return 0;
}
 
inline mint __MIN(mint _x, mint _y)
{
    return _x < _y ? _x : _y;
}
 
static mint on_loc_read(loc_t* _loc, char* _val, mint _buflen)
{
    mint nToRead = _buflen;
    if (_loc->loc_size != -1)
        nToRead = __MIN(_buflen, _loc->loc_size - _loc->loc_xfercount);
 
    InputStream* pInput = (InputStream*)(_loc->loc_user_env);
    size_t nRead = 0;
    try {
        nRead = pInput->read(_val, (size_t)nToRead);
    }
    catch (IOException* e) {
        e->destroy();
        _loc->loc_status = -454;
        return -1;
    }
    _loc->loc_xfercount += nRead;
    return nRead;
}
 
static mint on_loc_close(loc_t* _loc)
{
    _loc->loc_status = 0;
    return 0;
}
 
__DCL_END_NAMESPACE