SQLParam.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
#if __DCL_WINDOWS
#include <windows.h>
#endif
// 2005.01.26
 
#include <dcl/Object.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/Charset.h>
#include <dcl/SQL.h>
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/SQLParam.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE

IMPLEMENT_CLASSINFO(SQLParam, SQLField)
 
/*
SQLParam::SQLParam(SQL::Param* hParam)
{
    __handle = hParam;
}
*/
SQLParam::SQLParam()
{
}
 
SQLParam::~SQLParam()
{
 
}
 
void SQLParam::setNull()
{
    __DCL_ASSERT(this != NULL);
    __DCL_ASSERT(__handle != NULL);
#ifdef __DCL_NO_RTTI
    __DCL_ASSERT(__handle->isKindOf(CLASSINFO(SQL::Param)));
#else
    __DCL_ASSERT(dynamic_cast<SQL::Param*>(__handle) != NULL);
#endif
 
    ((SQL::Param*)__handle)->setNull();
}
 
void SQLParam::setData(
        _CONST void*  _pv,    // data, IN
        size_t          _n,         // sizeof *_pv
        SQL::DataType  _dataType,  // typeof *_pv
        SQL::DataType  _assignType // assign to server type
        ) __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(this != NULL);
    __DCL_ASSERT(__handle != NULL);
#ifdef __DCL_NO_RTTI
    __DCL_ASSERT(__handle->isKindOf(CLASSINFO(SQL::Param)));
#else
    __DCL_ASSERT(dynamic_cast<SQL::Param*>(__handle) != NULL);
#endif
 
    __DCL_ASSERT(_pv != NULL);
//  __DCL_ASSERT(_n > 0); 문자열일 경우 _n는 0일 수 있다.
 
    if (!((SQL::Param*)__handle)->setData(_pv, _n, _dataType, _assignType)) {
        throw new SQLException(this);
    }
}

 
void SQLParam::setValue(int32_t _value) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*)&_value,
        sizeof(int32_t),
        SQL::typeInteger,
        SQL::typeInteger
        );
}
 
void SQLParam::setValue(uint32_t _value) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*)&_value,
        sizeof(uint32_t),
        SQL::typeUInteger,
        SQL::typeUInteger
        );
}
 
void SQLParam::setValue(int64_t _value) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*)&_value,
        sizeof(int64_t),
        SQL::typeInteger,
        SQL::typeInteger
        );
}
 
void SQLParam::setValue(uint64_t _value) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*)&_value,
        sizeof(uint64_t),
        SQL::typeUInteger,
        SQL::typeUInteger
        );
}
 
void SQLParam::setValue(float _value) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*)&_value,
        sizeof(float),
        SQL::typeFloat,
        SQL::typeFloat
        );
}
 
void SQLParam::setValue(double _value) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*)&_value,
        sizeof(double),
        SQL::typeFloat,
        SQL::typeFloat
        );
}
 
void SQLParam::setValue(
        const Decimal& _value
        ) __DCL_THROWS2(SQLException*, CharsetConvertException*)
{
    setValue(_value.toString(), SQL::typeNumeric);;
}
 
void SQLParam::setValue(Date _value) __DCL_THROWS1(SQLException*)
{
    SQL::Date d;
    int nYear, nMonth, nDay;
 
    _value.decode(nYear, nMonth, nDay);
 
    d.nYear = nYear;
    d.nMonth = nMonth;
    d.nDay = nDay;
 
    setData(
        (_CONST void*)&d,
        sizeof(SQL::Date),
        SQL::typeDate,
        SQL::typeDate
        );
}
 
void SQLParam::setValue(Time _value) __DCL_THROWS1(SQLException*)
{
    SQL::Time t;
    int nHour, nMin, nSec, nMSec;
 
    _value.decode(nHour, nMin, nSec, nMSec);
 
    t.nHour = nHour;
    t.nMin = nMin;
    t.nSec = nSec;
    t.nFrac = nMSec * 1000000;
 
    setData(
        (_CONST void*)&t,
        sizeof(SQL::Time),
        SQL::typeTime,
        SQL::typeTime
        );
}
 
void SQLParam::setValue(DateTime _value) __DCL_THROWS1(SQLException*)
{
    SQL::TimeStamp ts;
    int nYear, nMonth, nDay, nHour, nMin, nSec, nMSec;
    _value.date().decode(nYear, nMonth, nDay);
    _value.time().decode(nHour, nMin, nSec, nMSec);
 
    ts.nYear = nYear;
    ts.nMonth = nMonth;
    ts.nDay = nDay;
    ts.nHour = nHour;
    ts.nMin = nMin;
    ts.nSec = nSec;
    ts.nFrac = nMSec * 1000000;
    ts.nTzMin = 0;
 
    setData(
        (_CONST void*)&ts,
        sizeof(SQL::TimeStamp),
        SQL::typeTimeStamp,
        SQL::typeTimeStamp
        );
}
 
void SQLParam::setValue(
        DateTime _value,
        int16_t _tzMinute
        ) __DCL_THROWS1(SQLException*)
{
    SQL::TimeStamp ts;
    int nYear, nMonth, nDay, nHour, nMin, nSec, nMSec;
    _value.date().decode(nYear, nMonth, nDay);
    _value.time().decode(nHour, nMin, nSec, nMSec);
 
    ts.nYear = nYear;
    ts.nMonth = nMonth;
    ts.nDay = nDay;
    ts.nHour = nHour;
    ts.nMin = nMin;
    ts.nSec = nSec;
    ts.nFrac = nMSec * 1000000;
    ts.nTzMin = _tzMinute;
 
    setData(
        (_CONST void*)&ts,
        sizeof(SQL::TimeStamp),
        SQL::typeTimeStampTz,
        SQL::typeTimeStampTz
        );
}
 
void SQLParam::setValue(
        Interval _value,
        SQL::DataType _assignType  //  = SQL::typeIntervalDs
        ) __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(_assignType == SQL::typeInterval
        || _assignType == SQL::typeIntervalYm
        || _assignType == SQL::typeIntervalDs);
 
    SQL::Interval iv;
    long nDays, nMSecs;
    _value.decode(nDays, nMSecs);
 
    if (_assignType == SQL::typeIntervalYm) {
        iv.nYears = nDays / 360;
        iv.nMonths = (int8_t)((nDays % 360) / 30);
        iv.nDays = 0;
        iv.nHours = 0;
        iv.nMins = 0;
        iv.nSecs = 0;
        iv.nFracs = 0;
    }
    else {
        iv.nYears = 0;
        iv.nMonths = 0;
        iv.nDays = nDays;
        iv.nHours = (int8_t)(nMSecs / 3600000);
        iv.nMins = (int8_t)((nMSecs % 3600000) / 60000);
        iv.nSecs = (int8_t)((nMSecs % 60000) / 1000);
        iv.nFracs = (nMSecs % 1000) * 1000000;
    }
 
    setData(
        (_CONST void*)&iv,
        sizeof(SQL::Interval),
        _assignType,
        _assignType
        );
}
 
void SQLParam::setValue(
        const String& _value,
        SQL::DataType _assignType // = SQL::typeText
        ) __DCL_THROWS2(SQLException*, CharsetConvertException*)
{
    __DCL_ASSERT(_assignType == SQL::typeNumeric
        || _assignType == SQL::typeText
        || _assignType == SQL::typeLongText
        || _assignType == SQL::typeClob);
 
    setValue(UTF8Encoder::encode(_value), _assignType);
}
 
void SQLParam::setValue(
        const wchar_t*  _p,
        size_t          _n,
        SQL::DataType  _assignType // = SQL::typeText
        ) __DCL_THROWS2(SQLException*, CharsetConvertException*)
{
    __DCL_ASSERT(_assignType == SQL::typeNumeric
        || _assignType == SQL::typeText
        || _assignType == SQL::typeLongText
        || _assignType == SQL::typeClob);
 
    setValue(UTF8Encoder::encode(_p, _n), _assignType);
}
 
void SQLParam::setValue(
        const ByteString& _value,
        SQL::DataType  _assignType // = SQL::typeBinary
        ) __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(_assignType == SQL::typeNumeric
        || _assignType == SQL::typeText
        || _assignType == SQL::typeLongText
        || _assignType == SQL::typeClob
        || _assignType == SQL::typeBinary
        || _assignType == SQL::typeLongBinary
        || _assignType == SQL::typeBlob);
 
    // SQL::Param은 문자열을 복사하지 않을 수 있다.
    // SQL::Param이 파괴될때까지 문자열의 참조를 보관하여 문자열이 
    // 파괴되지 않도록 한다.
    __bytesValue = _value;
    SQL::DataType dataType = SQL::typeText;
    if (_assignType == SQL::typeBinary || _assignType == SQL::typeLongBinary)
        dataType = SQL::typeBinary;
 
    setData(
        (_CONST void*)__bytesValue.data(),
        __bytesValue.length(),
        dataType,
        _assignType
        );
}
 
void SQLParam::setValue(
        const byte_t* _p,
        size_t _n,
        SQL::DataType _assignType // = SQL::typeBinary
        ) __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(_assignType == SQL::typeBinary
        || _assignType == SQL::typeLongBinary
        || _assignType == SQL::typeBlob);
 
    setData(
        (_CONST void*)_p,
        _n,
        SQL::typeBinary,
        _assignType
        );
}
 
void SQLParam::setValue(
        _CONST InputStream* _input,
        size_t _n,
        SQL::DataType _assignType
        ) __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(_assignType == SQL::typeText
        || _assignType == SQL::typeLongText
        || _assignType == SQL::typeClob 
        || _assignType == SQL::typeBinary
        || _assignType == SQL::typeLongBinary
        || _assignType == SQL::typeBlob);
 
    setData(
        _input,
        _n,
        SQL::typeInputStream,
        _assignType
        );
}
 
void SQLParam::setDataType(
        SQL::DataType  _dataType
        ) __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(this != NULL);
    __DCL_ASSERT(__handle != NULL);
    if (!((SQL::Param*)__handle)->setDataType(_dataType))
    {
        throw new SQLException(this);
    }
}
 
__DCL_END_NAMESPACE