SQLParam.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
#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_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/SQLParam.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE

IMPLEMENT_CLASSINFO(SQLParam, SQLField)
 
SQLParam::SQLParam()
{
}
 
SQLParam::~SQLParam()
{
}
 
void SQLParam::setNull()
{
    __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*  _val,       // data, IN
    size_t          _size,      // sizeof *_val
    SQL::DataType  _valType,   // typeof *_val
    SQL::DataType  _sqlType    // assign to server type
) __DCL_THROWS1(SQLException*)
{
    __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(_val != NULL);
//  __DCL_ASSERT(_size > 0); 문자열일 경우 _size는 0일 수 있다.
 
    if (!((SQL::Param*)__handle)->setData(_val, _size, _valType, _sqlType)) {
        throw new SQLException(this, NULL);
    }
}
 
void SQLParam::setOutputType(
    SQL::DataType  _sqlType
) __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(__handle != NULL);
    if (!((SQL::Param*)__handle)->setOutputType(_sqlType)) {
        throw new SQLException(this, NULL);
    }
}

void SQLParam::setValue(int8_t _val) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*) & _val,
        sizeof(int8_t),
        SQL::typeInteger,
        SQL::typeInteger
    );
}
 
void SQLParam::setValue(uint8_t _val) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*) & _val,
        sizeof(uint8_t),
        SQL::typeUInteger,
        SQL::typeUInteger
    );
}
 
void SQLParam::setValue(int16_t _val) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*) & _val,
        sizeof(int16_t),
        SQL::typeInteger,
        SQL::typeInteger
    );
}
 
void SQLParam::setValue(uint16_t _val) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*) & _val,
        sizeof(uint16_t),
        SQL::typeUInteger,
        SQL::typeUInteger
    );
}
 
void SQLParam::setValue(int32_t _val) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*)&_val,
        sizeof(int32_t),
        SQL::typeInteger,
        SQL::typeInteger
    );
}
 
void SQLParam::setValue(uint32_t _val) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*)&_val,
        sizeof(uint32_t),
        SQL::typeUInteger,
        SQL::typeUInteger
    );
}
 
void SQLParam::setValue(int64_t _val) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*)&_val,
        sizeof(int64_t),
        SQL::typeInteger,
        SQL::typeInteger
    );
}
 
void SQLParam::setValue(uint64_t _val) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*)&_val,
        sizeof(uint64_t),
        SQL::typeUInteger,
        SQL::typeUInteger
    );
}
 
void SQLParam::setValue(float _val) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*)&_val,
        sizeof(float),
        SQL::typeFloat,
        SQL::typeFloat
    );
}
 
void SQLParam::setValue(double _val) __DCL_THROWS1(SQLException*)
{
    setData(
        (_CONST void*)&_val,
        sizeof(double),
        SQL::typeFloat,
        SQL::typeFloat
    );
}
 
void SQLParam::setValue(const Decimal& _val) __DCL_THROWS1(SQLException*)
{
    setValue(
        _val.toString(),
        SQL::typeNumeric
    );
}
 
void SQLParam::setValue(Date _val) __DCL_THROWS1(SQLException*)
{
    SQL::Date d;
    int nYear, nMonth, nDay;
 
    _val.decode(nYear, nMonth, nDay);
 
    d.year = nYear;
    d.month = nMonth;
    d.day = nDay;
 
    setData(
        (_CONST void*)&d,
        sizeof(SQL::Date),
        SQL::typeDate,
        SQL::typeDate
    );
}
 
void SQLParam::setValue(
    Time _val,
    int16_t _tzMinute // = INT16_MIN
) __DCL_THROWS1(SQLException*)
{
    SQL::Time t;
    int nHour, nMin, nSec, nMSec;
 
    _val.decode(nHour, nMin, nSec, nMSec);
 
    t.hour = nHour;
    t.min = nMin;
    t.sec = nSec;
    t.frac = nMSec * 1000000;
    t.tzoff = _tzMinute;
 
    setData(
        (_CONST void*) & t,
        sizeof(SQL::Time),
        SQL::typeTime,
        t.tzoff == INT16_MIN ? SQL::typeTime : SQL::typeTimeTz
    );
}
 
void SQLParam::setValue(
    DateTime _val,
    int16_t _tzMinute // = INT16_MIN
) __DCL_THROWS1(SQLException*)
{
    SQL::TimeStamp ts;
    int nYear, nMonth, nDay, nHour, nMin, nSec, nMSec;
    _val.date().decode(nYear, nMonth, nDay);
    _val.time().decode(nHour, nMin, nSec, nMSec);
 
    ts.year = nYear;
    ts.month = nMonth;
    ts.day = nDay;
    ts.hour = nHour;
    ts.min = nMin;
    ts.sec = nSec;
    ts.frac = nMSec * 1000000;
    ts.tzoff = _tzMinute;
 
    setData(
        (_CONST void*)&ts,
        sizeof(SQL::TimeStamp),
        SQL::typeTimeStamp,
        ts.tzoff == INT16_MIN ? SQL::typeTimeStamp : SQL::typeTimeStampTz
    );
}
 
void SQLParam::setValue(
    Interval _val,
    SQL::DataType _sqlType //  = SQL::typeIntervalDs
) __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(_sqlType == SQL::typeIntervalYm
        || _sqlType == SQL::typeIntervalDs);
 
    SQL::Interval iv;
    long nDays, nMSecs;
    _val.decode(nDays, nMSecs);
 
    if (_sqlType == SQL::typeIntervalYm) {
        iv.years = nDays / 360;
        iv.months = (int8_t)((nDays % 360) / 30);
        iv.days = 0;
        iv.hours = 0;
        iv.mins = 0;
        iv.secs = 0;
        iv.fracs = 0;
    }
    else {
        iv.years = 0;
        iv.months = 0;
        iv.days = nDays;
        iv.hours = (int8_t)(nMSecs / 3600000);
        iv.mins = (int8_t)((nMSecs % 3600000) / 60000);
        iv.secs = (int8_t)((nMSecs % 60000) / 1000);
        iv.fracs = (nMSecs % 1000) * 1000000;
    }
 
    setData(
        (_CONST void*)&iv,
        sizeof(SQL::Interval),
        SQL::typeInterval,
        _sqlType
    );
}
 
void SQLParam::setValue(
    const String& _val,
    SQL::DataType _sqlType // = SQL::typeText
) __DCL_THROWS1(SQLException*)
{
    setValue(_val.data(), _val.length());
}
 
void SQLParam::setValue(
    const wchar_t*  _val,
    size_t          _size,
    SQL::DataType  _sqlType // = SQL::typeText
) __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(_sqlType == SQL::typeNumeric
        || _sqlType == SQL::typeText
        || _sqlType == SQL::typeLongText
        || _sqlType == SQL::typeClob
    );
 
    ByteString val;
    try {
        val = UTF8Encoder::encode(_val, _size);
    }
    catch (CharsetConvertException* _cause) {
        throw new SQLException(this, _cause);
    }
    setValue(val, _sqlType);
}
 
void SQLParam::setValue(
    const ByteString&   _val,
    SQL::DataType      _sqlType // = SQL::typeBinary
) __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(_sqlType == SQL::typeNumeric
        || _sqlType == SQL::typeText
        || _sqlType == SQL::typeLongText
        || _sqlType == SQL::typeClob
        || _sqlType == SQL::typeBinary
        || _sqlType == SQL::typeLongBinary
        || _sqlType == SQL::typeBlob
    );
 
    // SQL::Param은 문자열을 복사하지 않을 수 있다.
    // SQL::Param이 파괴될때까지 문자열의 참조를 보관하여 문자열이 
    // 파괴되지 않도록 한다.
    __bytesValue = _val;
 
    setData(
        (_CONST void*)__bytesValue.data(),
        __bytesValue.length(),
        (_sqlType == SQL::typeBinary
            || _sqlType == SQL::typeLongBinary
            || _sqlType == SQL::typeBlob
            ) ? SQL::typeBinary : SQL::typeText,
        _sqlType
    );
}
 
void SQLParam::setValue(
    const char*     _val,
    size_t          _size,
    SQL::DataType  _sqlType // = SQL::typeBinary
) __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(_sqlType == SQL::typeText
        || _sqlType == SQL::typeLongText
        || _sqlType == SQL::typeClob
        || _sqlType == SQL::typeBinary
        || _sqlType == SQL::typeLongBinary
        || _sqlType == SQL::typeBlob
    );
 
    setData(
        (_CONST void*)_val,
        _size,
        (_sqlType == SQL::typeBinary
            || _sqlType == SQL::typeLongBinary
            || _sqlType == SQL::typeBlob
            ) ? SQL::typeBinary : SQL::typeText,
        _sqlType
    );
}
 
void SQLParam::setValue(
    _CONST InputStream& _input,
    size_t              _size,   // = (size_t)-1,
    SQL::DataType      _sqlType // = SQL::typeLongBinary
) __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(_sqlType == SQL::typeText
        || _sqlType == SQL::typeLongText
        || _sqlType == SQL::typeClob 
        || _sqlType == SQL::typeBinary
        || _sqlType == SQL::typeLongBinary
        || _sqlType == SQL::typeBlob
    );
 
    setData(
        &_input,
        _size,
        SQL::typeInputStream,
        _sqlType
    );
}
 
__DCL_END_NAMESPACE