OciParam.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <oci.h>
 
#include <stdlib.h>     // malloc, free
#include <string.h>     // memset
 
#include <dcl/Object.h>
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/size_t.h>
#include <dcl/Numeric.h>
#include <dcl/InputStream.h>
#include <dcl/OutputStream.h>
#include <dcl/BytesOutputStream.h>
#include <dcl/Charset.h>
#include <dcl/SQLCore.h>
 
#include "OciConnection.h"
#include "OciQuery.h"
#include "OciParam.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/OciParam.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#define __SET_ERROR_HANDLE(_error, _status, _OCIError) \
    conn()->setErrorHandle(_error, _status, _OCIError, \
            true, __THIS_FILE__, __LINE__)
#define __SET_ERROR_MSG(_msg) \
    conn()->setErrorMessage(_msg, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(OciParam, SQL::Param)
 
OciParam::OciParam()
    : Param(NULL)
{
    __buffer = NULL;
    __inputIndicator = -1;
    __inputStream = NULL;
    __inputValue = NULL;
}
 
OciParam::~OciParam()
{
    if (OciData::__descType) {
        __DCL_ASSERT(__data.desc != NULL);
        __DCL_VERIFY(
            conn()->DescriptorFree(
                __data.desc,
                OciData::__descType
            ) == OCI_SUCCESS
        );
        OciData::__descType = 0;
    }
 
    if (__buffer) {
        free(__buffer);
        __buffer = NULL;
    }
}
 
OciQuery* OciParam::query() const
{
    return (OciQuery*)Param::__queryHandle;
}
 
bool OciParam::init(SQL::Query* _queryHandle, ub4 _position)
{
    Param::__queryHandle = _queryHandle;
    OciData::__position = _position;
    OciData::__dynamicMode = OCI_DATA_AT_EXEC;
 
    return true;
}
 
bool OciParam::onAfterExecute()
{
    if ((OciData::__descType == OCI_DTYPE_LOB)
            && (__inputValue || __inputStream)) {
        if (__inputValue) {
            ub4 byte_amt = OciData::__valueSize;
            sword status = OCILobWrite(
                conn()->svcHandle(),            // OCISvcCtx *svchp,
                conn()->errorHandle(),          // OCIError *errhp,
                (OCILobLocator*)__data.desc,    // OCILobLocator *locp,
                &byte_amt,                      // ub4 *amtp,
                1,                              // ub4 offset,
                __inputValue,                   // void *bufp,
                OciData::__valueSize,           // ub4 buflen,
                OCI_ONE_PIECE,                  // ub1 piece,
                NULL,                           // void* ctxp,
                (OCICallbackLobWrite)NULL,      // OCICallbackLobWrite(cbfp)
                0,                              // ub2 csid,
                SQLCS_IMPLICIT                  // ub1 csfrm
            );
            __DCL_TRACE2_N(L"OCILobWrite [%d] byte_amt[%d]\n", status, byte_amt);
            if (status != OCI_SUCCESS) {
                __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
                return false;
            }
        }
        else {
            try {
                char buf[4096];
                size_t total = 0;
                for ( ; ; ) {
                    size_t n = __MIN(OciData::__valueSize - total, sizeof(buf));
                    n = __inputStream->read(buf, n);
                    ub4 byte_amt = OciData::__valueSize;
 
                    ub1 piece = OCI_ONE_PIECE;
                    if (total == 0) {
                        piece = n < sizeof(buf) ? OCI_ONE_PIECE : OCI_FIRST_PIECE;
                    }
                    else {
                        piece = n < sizeof(buf) ? OCI_LAST_PIECE : OCI_NEXT_PIECE;
                    }
 
                    sword status = OCILobWrite(
                        conn()->svcHandle(),            // OCISvcCtx *svchp,
                        conn()->errorHandle(),          // OCIError *errhp,
                        (OCILobLocator*)__data.desc,    // OCILobLocator *locp,
                        &byte_amt,                      // ub4 *amtp,
                        1 + total,                      // ub4 offset,
                        __inputValue,                   // void *bufp,
                        OciData::__valueSize,           // ub4 buflen,
                        piece,                          // ub1 piece,
                        NULL,                           // void* ctxp,
                        (OCICallbackLobWrite)NULL,      // OCICallbackLobWrite(cbfp)
                        0,                              // ub2 csid,
                        SQLCS_IMPLICIT                  // ub1 csfrm
                    );
                    __DCL_TRACE2_N(L"OCILobWrite [%d] byte_amt[%d]\n", status, byte_amt);
                    if (status != OCI_SUCCESS) {
                        __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
                        return false;
                    }
                    total += byte_amt;
                }
            }
            catch (IOException* _cause) {
                __SET_ERROR_MSG(UTF8Encoder::encode(_cause->toStringAll()));
                _cause->destroy();
                return false;
            }
        }
 
    }
    __inputIndicator = -1;
    __inputStream = NULL;
    __inputValue = NULL;
 
    // calc output datasize
    return OciData::onAfterFetch();
}
 
const wchar_t* OciParam::serverDataTypeName() const
{
    return OciData::serverDataTypeName();
}
 
bool OciParam::__getDataSize(size_t* _size, bool _maxsize)
{
    return OciData::getDataSize(_size, _maxsize);
}
 
bool OciParam::__getData(
    void*           _buf,       // data, OUT
    size_t*         _size,      // sizeof *_buf, IN OUT
    SQL::DataType  _bufType
)
{
    return OciData::getData(_buf, _size, _bufType);
}
 
// output parameter support
bool OciParam::__setOutputType(
    SQL::DataType  _sqlType
)
{
    switch (_sqlType) {
        case SQL::typeInteger:
        case SQL::typeUInteger:
        case SQL::typeFloat:
            _sqlType = SQL::typeNumeric;
            break;
        case SQL::typeInterval:
            _sqlType = SQL::typeIntervalDs;
            break;
        default:
            ;
    }
 
    if (OciData::__descType) {
        // 이전호출 __setData, __setOutputType의 _sqlType과의
        // 호환성을 검사한다.
        if (Param::__dataType != _sqlType) {
            __SET_ERROR_HANDLE(SQL::eInvalidDataType, 0, NULL);
            return false;
        }
        return true;
    }
 
    switch (_sqlType) {
        case SQL::typeInteger:
        case SQL::typeUInteger:
        case SQL::typeFloat:
            _sqlType = SQL::typeNumeric;
        case SQL::typeNumeric: {
            OciData::__valueSize = sizeof(OCINumber);
            OciData::__valueType = SQLT_VNU;
            OciData::__maxDataSize = 132;
            break;
        }
        case SQL::typeDate: {
            OciData::__valueSize = sizeof(OCIDate);
            OciData::__valueType = SQLT_ODT;
            OciData::__maxDataSize = sizeof(SQL::Date);
            break;
        }
        case SQL::typeTime: {
            // Oracle에서 DATE, TIMESTAMP은 모두 TIME만 저장할 수 없다.
            __SET_ERROR_HANDLE(SQL::eNotSupportDataType, 0, NULL);
            break;
        }
        case SQL::typeTimeStamp:
        case SQL::typeTimeStampTz: {
            if (OciData::__descType == 0) {
                ub2 dataType = SQLT_TIMESTAMP;
                ub4 descType = OCI_DTYPE_TIMESTAMP;
                if (_sqlType == SQL::typeTimeStampTz) {
                    dataType = SQLT_TIMESTAMP_TZ;
                    descType = OCI_DTYPE_TIMESTAMP_TZ;
                }
 
                sword status = conn()->DescriptorAlloc(
                    &(__data.desc),
                    descType
                );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
                    return false;
                }
                OciData::__descType = descType;
                OciData::__valueSize = sizeof(OCIDateTime*);
                OciData::__valueType = dataType;
                OciData::__maxDataSize = sizeof(SQL::TimeStamp);
            }
            break;
        }
        case SQL::typeInterval:
            _sqlType = SQL::typeIntervalDs;
        case SQL::typeIntervalYm:
        case SQL::typeIntervalDs: {
            if (OciData::__descType == 0) {
                ub2 dataType = SQLT_INTERVAL_DS;
                ub4 descType = OCI_DTYPE_INTERVAL_DS;
                if (_sqlType == SQL::typeIntervalYm) {
                    dataType = SQLT_INTERVAL_YM;
                    descType = OCI_DTYPE_INTERVAL_YM;
                }
 
                sword status = conn()->DescriptorAlloc(
                    &(__data.desc),
                    OCI_DTYPE_INTERVAL_DS
                );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
                    return false;
                }
                OciData::__descType = descType;
                OciData::__valueSize = sizeof(OCIInterval*);
                OciData::__valueType = dataType;
                OciData::__maxDataSize = sizeof(SQL::Interval);
            }
            break;
        }
        case SQL::typeText: {
            OciData::__valueSize = 4000;
            OciData::__valueType = SQLT_CHR;
            OciData::__maxDataSize = 4000;    // AFC ==> 2000
            break;
        }
        case SQL::typeBinary: {
            OciData::__valueSize = 4000;
            OciData::__valueType = SQLT_BIN;
            OciData::__maxDataSize = 2000;
            break;
        }
        case SQL::typeLongText: {
            OciData::__valueSize = INT32_MAX;
            OciData::__valueType = SQLT_LNG;
            OciData::__maxDataSize = INT32_MAX;
            break;
        }
        case SQL::typeLongBinary: {
            OciData::__valueSize = INT32_MAX;
            OciData::__valueType = SQLT_LBI;
            OciData::__maxDataSize = INT32_MAX;
            break;
        }
        case SQL::typeClob:
        case SQL::typeBlob: {
            if (OciData::__descType == 0) {
                sword status = conn()->DescriptorAlloc(
                    &(__data.desc),
                    OCI_DTYPE_LOB
                );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
                    return false;
                }
                OciData::__descType = OCI_DTYPE_LOB;
                OciData::__valueSize = sizeof(OCILobLocator*);
                OciData::__valueType = _sqlType == SQL::typeClob ? SQLT_CLOB : SQLT_BLOB;
                OciData::__maxDataSize = UINT32_MAX;
            }
            break;
        }
        default: {
            __SET_ERROR_HANDLE(SQL::eNotSupportDataType, 0, NULL);
            return false;
        }
    }
 
    Param::__dataType = _sqlType;
    return true;
}
 
void OciParam::setNull()
{
    // FIX 2025-02-10 See 753 OCIBindByPos
    Param::__dataType = SQL::typeUnknown;
    OciData::__valueType = SQLT_CHR;
    OciData::__valuePtr = NULL;
    OciData::__valueSize = 0;
    OciData::__maxDataSize = 0;
    __inputIndicator = -1;
}
 
bool OciParam::__setData(
    _CONST void*  _val,
    size_t          _size,
    SQL::DataType  _valType,
    SQL::DataType  _sqlType
)
{
    switch (_sqlType) {
        case SQL::typeInteger:
        case SQL::typeUInteger:
        case SQL::typeFloat :
            _sqlType = SQL::typeNumeric;
            break;
        case SQL::typeInterval:
            _sqlType = SQL::typeIntervalDs;
            break;
        default:
            ;
    }
 
    if (OciData::__descType) {
        // 이전호출 __setData, __setOutputType의 _sqlType과의
        // 호환성을 검사한다.
        if (Param::__dataType != _sqlType) {
            __SET_ERROR_HANDLE(SQL::eInvalidDataType, 0, NULL);
            return false;
        }
        return true;
    }
 
    switch (_valType) {
        case SQL::typeInteger :
        case SQL::typeUInteger: {
            if (_size <= sizeof(int64_t /* 2025-02-03 월 int32_t */)) {
                uword sign = OCI_NUMBER_SIGNED;
                if (_valType == SQL::typeUInteger)
                    sign = OCI_NUMBER_UNSIGNED;
 
                sword status = OCINumberFromInt(
                    conn()->errorHandle(),      // OCIError *err,
                    (CONST dvoid*)_val,         // CONST dvoid *inum,
                    _size,                      // uword inum_length,
                    sign,                       // uword inum_s_flag,
                    &__data.number              // OCINumber *number
                );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
                    return false;
                }
            }
    #if 0
            // 2025-02-03 월
            // 32bit OS에서 이것을 사용했었다.
            else if (_size == sizeof(int64_t)) {
                ByteString str;
                if (_valType == SQL::typeInteger)
                    str = Int64::toByteString(*(int64_t*)_val, 10);
                else
                    str = UInt64::toByteString(*(uint64_t*)_val, 10);
 
                status = OCINumberFromText(
                    conn()->errorHandle(),      // OCIError *err,
                    (CONST OraText*)str.data(), // CONST OraText *str,
                    str.length(),               // ub4 str_length,
                    NULL,                       // CONST OraText *fmt,
                    0,                          // ub4 fmt_length,
                    NULL,                       // CONST OraText *nls_params,
                    0,                          // ub4 nls_p_length,
                    &__data.num                 // OCINumber *number
                );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
                    return false;
                }
            }
    #endif
            else {
                __SET_ERROR_HANDLE(SQL::eInvalidDataSize, 0, NULL);
                return false;
            }
            OciData::__valuePtr = &__data;
            OciData::__valueSize = sizeof(OCINumber);
            OciData::__valueType = SQLT_VNU;
            OciData::__maxDataSize = 132;
            break;
        }
        case SQL::typeFloat: {
            if (_size <= sizeof(double)) {
                sword status = OCINumberFromReal(
                conn()->errorHandle(),      // OCIError *err,
                    (CONST dvoid*)_val,     // CONST dvoid *rnum,
                    _size,                  // uword rnum_length,
                    &__data.number          // OCINumber *number
                );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
                    return false;
                }
            }
            else {
                __SET_ERROR_HANDLE(SQL::eInvalidDataSize, 0, NULL);
                return false;
            }
            OciData::__valuePtr = &__data;
            OciData::__valueSize = sizeof(OCINumber);
            OciData::__valueType = SQLT_VNU;
            OciData::__maxDataSize = 132;
            break;
        }
        case SQL::typeDate: {
            if (_size == sizeof(SQL::Date)) {
                memset(&__data.date, 0, sizeof(OCIDate));
                const SQL::Date* p = (const SQL::Date*)_val;
                OCIDateSetDate(
                    &(__data.date),         // OCIDate *date,
                    p->year,                // sb2 year,
                    p->month,              // ub1 month,
                    p->day                   // ub1 day
                );
                OciData::__valuePtr = &__data;
                OciData::__valueSize = sizeof(OCIDate);
                OciData::__valueType = SQLT_ODT;
                OciData::__maxDataSize = sizeof(SQL::Date);
            }
            else {
                __SET_ERROR_HANDLE(SQL::eInvalidDataSize, 0, NULL);
                return false;
            }
            break;
        }
        case SQL::typeTime: {
            // Oracle에서 DATE, TIMESTAMP 모두 시간만 저장할 수 없다.
            __SET_ERROR_HANDLE(SQL::eNotSupportDataType, 0, NULL);
            return false;
        }
        case SQL::typeTimeStamp: {
            if (_size == sizeof(SQL::TimeStamp)) {
                if (!setTimeStamp((const SQL::TimeStamp*)_val, _size, _sqlType))
                    return false;
            }
            else {
                __SET_ERROR_HANDLE(SQL::eInvalidDataSize, 0, NULL);
                return false;
            }
            break;
        }
        case SQL::typeInterval: {
            if (_size == sizeof(SQL::Interval)) {
                if (!setInterval((const SQL::Interval*)_val, _size, _sqlType))
                    return false;
            }
            else {
                __SET_ERROR_HANDLE(SQL::eInvalidDataSize, 0, NULL);
                return false;
            }
            break;
        }
        case SQL::typeText: {
            if (_sqlType == SQL::typeNumeric) {
                sword status = OCINumberFromText(
                conn()->errorHandle(),      // OCIError *err,
                    (CONST OraText*)_val,   // CONST OraText *str,
                    _size,                  // ub4 str_length,
                    NULL,                   // CONST OraText *fmt,
                    0,                      // ub4 fmt_length,
                    NULL,                   // CONST OraText *nls_params,
                    0,                      // ub4 nls_p_length,
                    &__data.number          // OCINumber *number
                );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
                    return false;
                }
                OciData::__valuePtr = &__data;
                OciData::__valueSize = sizeof(OCINumber);
                OciData::__valueType = SQLT_VNU;
                OciData::__maxDataSize = 132;
                break;
            }
        }
        case SQL::typeBinary: {
            switch (_sqlType) {
                case SQL::typeText: {
                    OciData::__valueType = SQLT_CHR;
                    OciData::__maxDataSize = 4000;
                    break;
                }
                case SQL::typeBinary: {
                    OciData::__valueType = SQLT_BIN;
                    OciData::__maxDataSize = 2000;
                    break;
                }
                case SQL::typeLongText: {
                    OciData::__valueType = SQLT_LNG;
                    OciData::__maxDataSize = INT32_MAX;
                    break;
                }
                case SQL::typeLongBinary: {
                    OciData::__valueType = SQLT_LBI;
                    OciData::__maxDataSize = INT32_MAX;
                    break;
                }
                case SQL::typeClob:
                case SQL::typeBlob: {
                    if (OciData::__descType == 0) {
                        sword status = conn()->DescriptorAlloc(
                            &(__data.desc),
                            OCI_DTYPE_LOB
                        );
                        if (status != OCI_SUCCESS) {
                            __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
                            return false;
                        }
                        OciData::__descType = OCI_DTYPE_LOB;
                        OciData::__valueSize = sizeof(OCILobLocator*);
                        OciData::__valueType = _sqlType == SQL::typeClob ? SQLT_CLOB : SQLT_BLOB;
                        OciData::__maxDataSize = UINT32_MAX;
                    }
                    break;
                }
                default: {
                    __SET_ERROR_HANDLE(SQL::eNotSupportDataType, 0, NULL);
                    return false;
                }
            }
            if (OciData::__descType) {
                OciData::__valuePtr = NULL;
                __inputValue = _val;
            }
            else {
                OciData::__valuePtr = _val;
            }
            OciData::__valueSize = _size;
 
            break;
        }
        case SQL::typeInputStream: {
            switch (_sqlType) {
                case SQL::typeText: {
                    OciData::__valueType = SQLT_CHR;
                    OciData::__maxDataSize = 4000;
                    break;
                }
                case SQL::typeBinary: {
                    OciData::__valueType = SQLT_BIN;
                    OciData::__maxDataSize = 2000;
                    break;
                }
                case SQL::typeLongText: {
                    OciData::__valueType = SQLT_LNG;
                    OciData::__maxDataSize = INT32_MAX;
                    break;
                }
                case SQL::typeLongBinary: {
                    OciData::__valueType = SQLT_LBI;
                    OciData::__maxDataSize = INT32_MAX;
                    break;
                }
                case SQL::typeClob:
                case SQL::typeBlob: {
                    if (OciData::__descType == 0) {
                        sword status = conn()->DescriptorAlloc(
                            &(__data.desc),
                            OCI_DTYPE_LOB
                        );
                        if (status != OCI_SUCCESS) {
                            __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
                            return false;
                        }
                        OciData::__descType = OCI_DTYPE_LOB;
                        OciData::__valueSize = sizeof(OCILobLocator*);
                        OciData::__valueType = _sqlType == SQL::typeClob ? SQLT_CLOB : SQLT_BLOB;
                        OciData::__maxDataSize = UINT32_MAX;
                    }
                    break;
                }
                default: {
                    __SET_ERROR_HANDLE(SQL::eNotSupportDataType, 0, NULL);
                    return false;
                }
            }
            OciData::__valuePtr = NULL;
            OciData::__valueSize = _size == (size_t)-1 ? OciData::__maxDataSize : _size;
            __inputStream = (InputStream*)_val;
            break;
        }
        default: {
            __SET_ERROR_HANDLE(SQL::eNotSupportDataType, 0, NULL);
            return false;
        }
    }
 
    Param::__dataType = _sqlType;
    __inputIndicator = 0;
    return true;
}
 
inline int16_t __ABS(int16_t n)
{
    return n < 0 ? -n : n;
}
 
bool OciParam::setTimeStamp(
    const SQL::TimeStamp* _val,
    size_t          _size,
    SQL::DataType  _sqlType
)
{
    OciConnection* _conn = conn();
    sword status = OCI_SUCCESS;
 
    if (OciData::__descType == 0) {
        ub2 dataType = SQLT_TIMESTAMP;
        ub4 descType = OCI_DTYPE_TIMESTAMP;
        if (_sqlType == SQL::typeTimeStampTz) {
            dataType = SQLT_TIMESTAMP_TZ;
            descType = OCI_DTYPE_TIMESTAMP_TZ;
        }
 
        status = _conn->DescriptorAlloc(
            &(__data.desc),
            descType
        );
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
            return false;
        }
 
        OciData::__descType = descType;
        OciData::__valueType = dataType;
        OciData::__maxDataSize = sizeof(SQL::TimeStamp);
    }
 
    ByteString strTz;
    OraText* pTz = NULL;
    size_t nTzLen = 0;
    if (_sqlType == SQL::typeTimeStampTz) {
        strTz = ByteString::format(
            //          6,
            "%02d:%02d",
            _val->tzoff / 60,
            __ABS(_val->tzoff % 60)
        );
        pTz = (OraText*)strTz.data();
        nTzLen = strTz.length();
    }
 
    status = OCIDateTimeConstruct(
        conn()->sessionHandle(),    // dvoid *hndl,
        conn()->errorHandle(),      // OCIError *err,
        (OCIDateTime*)__data.desc,  // OCIDateTime *datetime,
        _val->year,                 // sb2 year,
        _val->month,               // ub1 month,
        _val->day,                   // ub1 day,
        _val->hour,                 // ub1 hour,
        _val->min,                   // ub1 min,
        _val->sec,                   // ub1 sec,
        _val->frac,                 // ub4 fsec,
        pTz,                        // OraText *timezone,
        nTzLen                      // size_t timezone_length
    );
    if (status != OCI_SUCCESS) {
        __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
        return false;
    }
 
    OciData::__valueSize = sizeof(OCIDateTime*);
    return true;
}
 
bool OciParam::setInterval(
    const SQL::Interval* _val,
    size_t          _size,
    SQL::DataType  _sqlType
)
{
    OciConnection* _conn = conn();
    sword status = OCI_SUCCESS;
 
    if (OciData::__descType == 0) {
        ub2 dataType = SQLT_INTERVAL_DS;
        ub4 descType = OCI_DTYPE_INTERVAL_DS;
        if (_sqlType == SQL::typeIntervalYm) {
            dataType = SQLT_INTERVAL_YM;
            descType = OCI_DTYPE_INTERVAL_YM;
        }
 
        status = _conn->DescriptorAlloc(
            &(__data.desc),
            descType
        );
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
            return false;
        }
 
        OciData::__descType = descType;
        OciData::__valueType = dataType;
        OciData::__maxDataSize = sizeof(SQL::Interval);
    }
 
    if (OciData::__valueType == SQLT_INTERVAL_YM) {
        // set zero
        // 이부분이 빠지면 Query::execute에서
        status = OCIIntervalFromText(
            conn()->sessionHandle(),    // dvoid *hndl,
            conn()->errorHandle(),      // OCIError *err,
            (CONST OraText*)"0-0",      // CONST OraText *inpstring,
            3,                          // size_t str_len,
            (OCIInterval*)__data.desc   // OCIInterval *result
        );
        if (status == OCI_SUCCESS)
            status = OCIIntervalSetYearMonth(
                conn()->sessionHandle(),    // dvoid *hndl,
                conn()->errorHandle(),      // OCIError *err,
                _val->years,               // sb4 yr,
                _val->months,             // sb4 mnth,
                (OCIInterval*)__data.desc   // OCIInterval *result
            );
    }
    else {
        status = OCIIntervalFromText(
            conn()->sessionHandle(),    // dvoid *hndl,
            conn()->errorHandle(),      // OCIError *err,
            (CONST OraText*)"0 00:00:00",   // CONST OraText *inpstring,
            10,                         // size_t str_len,
            (OCIInterval*)__data.desc   // OCIInterval *result
        );
        if (status == OCI_SUCCESS)
            status = OCIIntervalSetDaySecond(
                conn()->sessionHandle(),    // dvoid *hndl,
                conn()->errorHandle(),      // OCIError *err,
                _val->days,                 // sb4 dy,
                _val->hours,               // sb4 hr,
                _val->mins,                 // sb4 mm,
                _val->secs,                 // sb4 ss,
                _val->fracs,               // sb4 fsec,
                (OCIInterval*)__data.desc   // OCIInterval *result
            );
    }
#if defined(__DCL_DEBUG) && 1
    if (status == OCI_SUCCESS) {
        ub4 valid = 0;
        status = OCIIntervalCheck(
            conn()->sessionHandle(),        // dvoid *hndl,
            conn()->errorHandle(),          // OCIError *err,
            (CONST OCIInterval*)__data.desc, // CONST OCIInterval *interval,
            &valid                          // ub4 *valid
        );
    }
#endif
 
    if (status != OCI_SUCCESS) {
        __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
        return false;
    }
 
    OciData::__valueSize = sizeof(OCIInterval*);
    return true;
}
 
bool OciParam::doBind()
{
    if (OciData::__valueType == 0) {
        // then out bind only param
        __DCL_ASSERT(OciData::__valuePtr == NULL);
        __DCL_ASSERT(OciData::__descType == 0);
        __DCL_ASSERT(__buffer == NULL);
    }
 
    // __DCL_TRACE3_N("%ls, %d, %p\n", Param::__name.data(), 
    //  OciData::__valueSize, OciData::__valuePtr);
    OCIBind* bindp = NULL;
    sword status = OCIBindByPos(
        query()->stmtHandle(),     // OCIStmt  *stmtp, 
        &bindp,                     // OCIBind  **bindpp,
        conn()->errorHandle(),      // OCIError *errhp,
        OciData::__position,     // ub4      position,
        NULL,                       // dvoid    *valuep,
        OciData::__valueSize,       // sb4      value_sz,
        OciData::__valueType,       // ub2      dty,
        &__inputIndicator,          // dvoid    *indp,
        NULL,                       // ub2      *alenp,
        &(OciData::__returnCode),  // ub2      *rcodep,
        0,                          // ub4      maxarr_len,
        NULL,                       // ub4      *curelep, 
        OciData::__dynamicMode        // ub4      mode
    );
    if (status != OCI_SUCCESS) {
        __DCL_TRACE2_N(L"OCIBindByPos status[%d] position[%d]\n",
            status, OciData::__position);
        __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
        return false;
    }
    __DCL_ASSERT(bindp != NULL);            // bindDynamic은 bindByPos 이후에
    if (OciData::__dynamicMode == OCI_DATA_AT_EXEC) {
        status = OCIBindDynamic(
            bindp,                      // OCIBind      *bindp,
            conn()->errorHandle(),      // OCIError     *errhp,
            this,                       // dvoid        *ictxp,
            OciParam::inbindCallback,   // OCICallbackInBind    (icbfp)
            this,                       // dvoid        *octxp
            OciParam::outbindCallback  // OCICallbackOutBind   (ocbfp)
        );
        if (status != OCI_SUCCESS) {
            __DCL_TRACE2_N(L"OCIBindDynamic status[%d] position[%d]\n",
                status, OciData::__position);
            __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
            return false;
        }
    }
 
    return true;
}
 
sb4 OciParam::inbindCallback(
    dvoid*      _ictxp,
    OCIBind*    _bindp,
    ub4         _iter,
    ub4         _index,
    dvoid**     _bufpp,
    ub4*        _alenp,
    ub1*        _piecep,
    dvoid**     _indpp
)
{
    return ((OciParam*)_ictxp)->inbindCallback(
        _bindp,
        _iter,
        _index,
        _bufpp,
        _alenp,
        _piecep,
        _indpp
    );
}
 
sb4 OciParam::outbindCallback(
    dvoid*      _octxp,
    OCIBind*    _bindp,
    ub4         _iter,
    ub4         _index,
    dvoid**     _bufpp,
    ub4**       _alenpp,
    ub1*        _piecep,
    dvoid**     _indpp,
    ub2**       _rcodepp
)
{
    return ((OciParam*)_octxp)->outbindCallback(
        _bindp,
        _iter,
        _index,
        _bufpp,
        _alenpp,
        _piecep,
        _indpp,
        _rcodepp
    );
}
 
sb4 OciParam::inbindCallback(
    OCIBind*    _bindp,
    ub4         _iter,
    ub4         _index,
    dvoid**     _bufpp,
    ub4*        _alenp,
    ub1*        _piecep,
    dvoid**     _indpp
)
{
    __DCL_ASSERT(OciData::__dynamicMode == OCI_DATA_AT_EXEC);
 
#if defined(__DCL_DEBUG) && 0
    switch (*_piecep) {
        case OCI_ONE_PIECE:
            __DCL_TRACE1_N("OCI_ONE_PIECE [%d]\n", __position);
            break;
        case OCI_FIRST_PIECE:
            __DCL_TRACE1_N("OCI_FIRST_PIECE [%d]\n", __position);
            break;
        case OCI_NEXT_PIECE:
            __DCL_TRACE1_N("OCI_NEXT_PIECE [%d]\n", __position);
            break;
        case OCI_LAST_PIECE:
            __DCL_TRACE1_N("OCI_LAST_PIECE [%d]\n", __position);
    }
#endif
 
    if (__inputIndicator == -1) {
        *_bufpp = NULL;
        *_alenp = 0;
        *_piecep = OCI_ONE_PIECE;
        *_indpp = &__inputIndicator;
        return OCI_CONTINUE;
    }
 
    if (OciData::__descType) {
        if (OciData::__descType != OCI_DTYPE_LOB) {
            // OCI_DTYPE_TIMESTAMP, OCI_DTYPE_TIMESTAMP_TZ
            // OCI_DTYPE_INTERVAL_YM, OCI_DTYPE_INTERVAL_DS
            *_bufpp = __data.desc;
            *_alenp = sizeof(void*);
        }
        else {
            // outbindCallback 이후 onAfterExecute 에서 OCILobWrite 한다.
            __inputIndicator = -1;
            *_bufpp = NULL;
            *_alenp = 0;
        }
        *_piecep = OCI_ONE_PIECE;
        *_indpp = &__inputIndicator;
        return OCI_CONTINUE;
    }
    else {
        if (__inputStream) {
            __DCL_ASSERT(OciData::__valueType == SQLT_CHR
                || OciData::__valueType == SQLT_BIN
                || OciData::__valueType == SQLT_LNG
                || OciData::__valueType == SQLT_LBI);
 
            if (!__buffer) {
                __buffer = malloc(__DYNAMIC_BUFFER_SIZE);
                if (!__buffer) {
                    __SET_ERROR_HANDLE(SQL::eOutOfMemory, 0, NULL);
                    return OCI_ERROR;
                }
            }
 
            __DCL_ASSERT(__buffer != NULL);
            size_t read = __MIN((size_t)OciData::__valueSize, __DYNAMIC_BUFFER_SIZE);
 
            if (read) {
                try {
                    read = __inputStream->read(__buffer, read);
                }
                catch (IOException* _cause) {
                    __SET_ERROR_MSG(UTF8Encoder::encode(_cause->toStringAll()));
                    _cause->destroy();
                    return OCI_ERROR;
                }
            }
 
            if (*_piecep == OCI_FIRST_PIECE) {
                if (read == (size_t)OciData::__valueSize)
                    *_piecep = OCI_ONE_PIECE;
            }
            else {
                // OCI_NEXT_PIECE
                if (read == 0 || read == (size_t)OciData::__valueSize)
                    *_piecep = OCI_LAST_PIECE;
            }
 
            OciData::__valueSize -= read;
            *_bufpp = __buffer;
            *_alenp = read;
            *_indpp = NULL;
        }
        else {
            // 나머지 경우 OciData::__valuePtr는 
            // 외부에서 받은 char*, byte_t* 그리고 &OciParam::__data 이다.
            *_bufpp = OciData::__valuePtr;
            *_alenp = OciData::__valueSize;
            *_piecep = OCI_ONE_PIECE;
            *_indpp = &__inputIndicator;
        }
    }
    return OCI_CONTINUE;
}
 
sb4 OciParam::outbindCallback(
    OCIBind*    _bindp,
    ub4         _iter,
    ub4         _index,
    dvoid**     _bufpp,
    ub4**       _alenpp,
    ub1*        _piecep,
    dvoid**     _indpp,
    ub2**       _rcodepp
)
{
    __DCL_ASSERT(OciData::__dynamicMode == OCI_DATA_AT_EXEC);
 
#if defined(__DCL_DEBUG) && 0
    if (_index == 0) {
        ub4 rows = 0;
        ub4 size = sizeof(rows);
        sword status = OCIAttrGet(
            _bindp,                 // const void *trgthndlp
            OCI_HTYPE_BIND,         // ub4 trghndltyp
            &rows,                  // void *attributep
            &size,                  // ub4 *sizep
            OCI_ATTR_ROWS_RETURNED, // ub4 attrtype
            conn()->errorHandle()   // OCIError *errhp
        );
        __DCL_ASSERT(size == sizeof(rows));
        if (status != OCI_SUCCESS) {
            return OCI_ERROR;
        }
    }
    switch (*_piecep) {
        case OCI_ONE_PIECE :
            __DCL_TRACE1_N(L"OCI_ONE_PIECE [%d]\n", __position);
            break;
        case OCI_FIRST_PIECE :
            __DCL_TRACE1_N(L"OCI_FIRST_PIECE [%d]\n", __position);
            break;
        case OCI_NEXT_PIECE :
            __DCL_TRACE1_N(L"OCI_NEXT_PIECE [%d]\n", __position);
            break;
        case OCI_LAST_PIECE :
            __DCL_TRACE1_N(L"OCI_LAST_PIECE [%d]\n", __position);
    }
#endif
 
    if (OciData::__valueType == SQLT_CHR
            || OciData::__valueType == SQLT_BIN
            || OciData::__valueType == SQLT_LNG 
            || OciData::__valueType == SQLT_LBI) {
        if (*_piecep == OCI_ONE_PIECE)
            *_piecep = OCI_FIRST_PIECE;
 
        if (*_piecep == OCI_FIRST_PIECE) {
            if (!__buffer) {
                __buffer = malloc(__DYNAMIC_BUFFER_SIZE);
                if (!__buffer) {
                    __SET_ERROR_HANDLE(SQL::eOutOfMemory, 0, NULL);
                    return OCI_ERROR;
                }
            }
 
            OciData::__valuePtr = __buffer;
            if (OciData::__bytesOutput)
                __bytesOutput->reset();
        }
        else {
            // 두번째 PIECE 부터는 이전 데이터를 내부 스트림에 보관한다.
            if (!OciData::__bytesOutput) {
                OciData::__bytesOutput = new BytesOutputStream();
                if (!OciData::__bytesOutput) {
                    __SET_ERROR_HANDLE(SQL::eOutOfMemory, 0, NULL);
                    return OCI_ERROR;
                }
            }
 
            __DCL_ASSERT(OciData::__bytesOutput != NULL);
            try {
                OciData::__bytesOutput->write(
                    OciData::__valuePtr,
                    OciData::__callbackActualLength
                    );
            }
            catch(IOException* _cause) {
                __SET_ERROR_MSG(UTF8Encoder::encode(_cause->toStringAll()));
                _cause->destroy();
                return OCI_ERROR;
            }
        }
 
        OciData::__callbackActualLength = __DYNAMIC_BUFFER_SIZE;
        OciData::__indicator = -1;
 
        *_bufpp = OciData::__valuePtr;
        *_alenpp = &(OciData::__callbackActualLength);
        *_indpp = &(OciData::__indicator);
        *_rcodepp = &(OciData::__returnCode);
    }
    else {
        // 버퍼가 OCIDateTime*, OCILogLocator*, OCIRowid* 와 같은
        // void*의 디스크립터 일 경우 ppvBuffer에는 이들 디스크립터의
        // 값을 넣어 주어야 한다.
        // 그러나, OciData::getData에서는 OciData::__valuePtr를 사용하여
        // 값을 얻기 때문에 이들의 주소를 할당해야 한다.
        // OCIDateTime의 경우 *(OCIDateTime**)OciData::__valuePtr 와 같이 사용된다.
        //
        // OCINumber, OCIDate와 같은 경우 이들의 포인터를 할당한다.
        if (OciData::__descType) {
            OciData::__valuePtr = &__data.desc;
            OciData::__callbackActualLength = sizeof(void*);
            *_bufpp = __data.desc;
        }
        else {
            OciData::__valuePtr = &__data;
            OciData::__callbackActualLength = OciData::__valueSize;
            *_bufpp = &__data;
        }
        OciData::__indicator = -1;
 
        *_piecep = OCI_ONE_PIECE;
        *_alenpp = &(OciData::__callbackActualLength);//NULL;
        *_indpp = &(OciData::__indicator);
        *_rcodepp = &(OciData::__returnCode);
    }
 
    return OCI_CONTINUE;
}
 
__DCL_END_NAMESPACE