OciParam.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <oci.h>
 
#include <stdlib.h>     // malloc, free
 
#include <dcl/Object.h>
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#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 wchar_t __THIS_FILE__[] = __T("dcl/sql/OciParam.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#undef __SET_ERROR
#define __SET_ERROR(_error, status, pError) \
    conn()->setErrorStatus(_error, status, pError, \
            true, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(OciParam, SQL::Param)
 
OciParam::OciParam()
    : Param(NULL)
{
    __bind = NULL;
    __inputIndicator = -1;
 
    __buffer = NULL;
    __inputStream = NULL;
}
 
OciParam::~OciParam()
{
    if (OciData::__descType) {
        __DCL_ASSERT(__data.desc != NULL);
        __DCL_VERIFY(
            conn()->OCIDescriptorFree(
                __data.desc,
                OciData::__descType
                ) == OCI_SUCCESS);
        OciData::__descType = 0;
    }
 
    if (__buffer) {
        free(__buffer);
        __buffer = NULL;
    }
}
 
bool OciParam::init(SQL::Query* _queryHandle, ub4 _position)
{
    Param::__queryHandle = _queryHandle;
 
    OciData::__queryHandle = (OciQuery*)_queryHandle;
    OciData::__position = _position;
    OciData::__dynamicMode = OCI_DATA_AT_EXEC;
 
    return true;
}
 
bool OciParam::onAfterExecute()
{
    __inputIndicator = -1;
    __inputStream = NULL;
 
    // calc output datasize
    return OciData::onAfterFetch();
}
 
// out bind support
bool OciParam::__setDataType(
        SQL::DataType  _dataType
        )
{
    if (Param::__dataType != SQL::typeUnknown) {
        if (Param::__dataType != _dataType) {
            __SET_ERROR(SQL::eInvalidDataType, 0, NULL);
            return false;
        }
        return true;
    }
 
    OciConnection* pConnection = conn();
    sword status = OCI_SUCCESS;
 
    switch(_dataType) {
        case SQL::typeInteger:
        case SQL::typeUInteger:
        case SQL::typeFloat:
            _dataType = SQL::typeNumeric;
        case SQL::typeNumeric: {
            OciData::__valueSize = sizeof(OCINumber);
            OciData::__dataType = SQLT_VNU;
            OciData::__maxDataSize = 132;
            break;
        }
        case SQL::typeTime: {
            // Oracle에서 DATE, TIMESTAMP은 모두 TIME만 저장할 수 없다.
            __SET_ERROR(SQL::eNotSupportDataType, 0, NULL);
            break;
        }
        case SQL::typeDate:
            _dataType = SQL::typeTimeStamp;
        case SQL::typeTimeStamp :
        case SQL::typeTimeStampTz: {
            ub2 dataType = SQLT_TIMESTAMP;
            ub4 descType = OCI_DTYPE_TIMESTAMP;
            if (_dataType == SQL::typeTimeStampTz) {
                dataType = SQLT_TIMESTAMP_TZ;
                descType = OCI_DTYPE_TIMESTAMP_TZ;
            }
 
            status = pConnection->OCIDescriptorAlloc(
                    &(__data.desc),
                    descType
                    );
            if (status != OCI_SUCCESS) {
                __SET_ERROR(SQL::eServerError, status, NULL);
                return false;
            }
            OciData::__descType = descType;
            OciData::__valueSize = sizeof(OCIDateTime*);
            OciData::__dataType = dataType;
            OciData::__maxDataSize = sizeof(SQL::TimeStamp);
            break;
        }
        case SQL::typeInterval:
            _dataType = SQL::typeIntervalDs;
        case SQL::typeIntervalYm :
        case SQL::typeIntervalDs: {
            ub2 dataType = SQLT_INTERVAL_DS;
            ub4 descType = OCI_DTYPE_INTERVAL_DS;
            if (_dataType == SQL::typeIntervalYm) {
                dataType = SQLT_INTERVAL_YM;
                descType = OCI_DTYPE_INTERVAL_YM;
            }
 
            status = pConnection->OCIDescriptorAlloc(
                    &(__data.desc),
                    OCI_DTYPE_INTERVAL_DS
                    );
            if (status != OCI_SUCCESS) {
                __SET_ERROR(SQL::eServerError, status, NULL);
                return false;
            }
            OciData::__descType = descType;
            OciData::__valueSize = sizeof(OCIInterval*);
            OciData::__dataType = dataType;
            OciData::__maxDataSize = sizeof(SQL::Interval);
            break;
        }
        case SQL::typeText: {
            OciData::__valueSize = 4000;
            OciData::__dataType = SQLT_CHR;
            OciData::__maxDataSize = 4000;    // AFC ==> 2000
            break;
        }
        case SQL::typeBinary: {
            OciData::__valueSize = 4000;
            OciData::__dataType = SQLT_BIN;
            OciData::__maxDataSize = 2000;
            break;
        }
        case SQL::typeLongText: {
            OciData::__valueSize = INT32_MAX;
            OciData::__dataType = SQLT_LNG;
            OciData::__maxDataSize = INT32_MAX;
            break;
        }
        case SQL::typeLongBinary: {
            OciData::__valueSize = INT32_MAX;
            OciData::__dataType = SQLT_LBI;
            OciData::__maxDataSize = INT32_MAX;
            break;
        }
        case SQL::typeClob: {
            status = pConnection->OCIDescriptorAlloc(
                    &(__data.desc),
                    OCI_DTYPE_LOB
                    );
            if (status != OCI_SUCCESS) {
                __SET_ERROR(SQL::eServerError, status, NULL);
                return false;
            }
            OciData::__descType = OCI_DTYPE_LOB;
            OciData::__valueSize = sizeof(OCILobLocator*);
            OciData::__dataType = SQLT_CLOB;
            OciData::__maxDataSize = UINT32_MAX;
            break;
        }
        case SQL::typeBlob: {
            status = pConnection->OCIDescriptorAlloc(
                    &(__data.desc),
                    OCI_DTYPE_LOB
                    );
            if (status != OCI_SUCCESS) {
                __SET_ERROR(SQL::eServerError, status, NULL);
                return false;
            }
            OciData::__descType = OCI_DTYPE_LOB;
            OciData::__valueSize = sizeof(OCILobLocator*);
            OciData::__dataType = SQLT_BLOB;
            OciData::__maxDataSize = UINT32_MAX;
            break;
        }
        default: {
            __SET_ERROR(SQL::eNotSupportDataType, 0, NULL);
            return false;
        }
    }
 
    Param::__dataType = _dataType;
    return true;
}
 
bool OciParam::isNull() const
{
    return OciData::__indicator == -1;
}
 
const wchar_t* OciParam::serverDataTypeName() const
{
    return OciData::dataTypeName(OciData::__dataType);
}
 
bool OciParam::__getDataSize(
        size_t*         _size,
        bool            _maxSize
        )
{
    return OciData::getDataSize(_size, _maxSize);
}
 
bool OciParam::__getData(
        void*           _pv,
        size_t*         _size,      // IN, OUT
        SQL::DataType  _dataType
        )
{
    return OciData::getData(_pv, _size, _dataType);
}
 
void OciParam::setNull()
{
    // FIX 2025-02-10 See 753 OCIBindByPos
    Param::__dataType = SQL::typeUnknown;
    OciData::__dataType = SQLT_CHR;
    OciData::__value = NULL;
    OciData::__valueSize = 0;
    OciData::__maxDataSize = 0;
    __inputIndicator = -1;
}
 
bool OciParam::__setData(
        _CONST void*  _pv,
        size_t          _size,
        SQL::DataType  _dataType,
        SQL::DataType  _assignType
        )
{
    switch(_assignType) {
        case SQL::typeInteger:
        case SQL::typeUInteger:
        case SQL::typeFloat :
            _assignType = SQL::typeNumeric;
            break;
        case SQL::typeDate:
            _assignType = SQL::typeTimeStamp;
            break;
        case SQL::typeInterval:
            _assignType = SQL::typeIntervalDs;
            break;
        default :
            ;
    }
 
    if (Param::__dataType != SQL::typeUnknown) {
        if (Param::__dataType != _assignType) {
            __SET_ERROR(SQL::eInvalidDataType, 0, NULL);
            return false;
        }
    }
 
    OCIError* pError = conn()->errorHandle();
    sword status = OCI_SUCCESS;
 
    switch(_dataType) {
        case SQL::typeInteger :
        case SQL::typeUInteger: {
            if (_size <= sizeof(int64_t /* 2025-02-03 월 int32_t */)) {
                uword sign = OCI_NUMBER_SIGNED;
                if (_dataType == SQL::typeUInteger)
                    sign = OCI_NUMBER_UNSIGNED;
 
                status = ::OCINumberFromInt(
                        pError,                 // OCIError *err,
                        (CONST dvoid*)_pv,      // CONST dvoid *inum,
                        _size,                  // uword inum_length,
                        sign,                   // uword inum_s_flag,
                        &__data.num             // OCINumber *number
                        );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR(SQL::eServerError, status, pError);
                    return false;
                }
            }
    #if 0   //  2025-02-03 월
            else if (_size == sizeof(int64_t)) {
                ByteString str;
                if (_dataType == SQL::typeInteger)
                    str = Int64::toByteString(*(int64_t*)_pv, 10);
                else
                    str = UInt64::toByteString(*(uint64_t*)_pv, 10);
 
                status = ::OCINumberFromText(
                        pError,             // 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(SQL::eServerError, status, pError);
                    return false;
                }
            }
    #endif
            else {
                __SET_ERROR(SQL::eInvalidDataSize, 0, NULL);
                return false;
            }
            OciData::__value = &__data;
            OciData::__valueSize = sizeof(OCINumber);
            OciData::__dataType = SQLT_VNU;
            OciData::__maxDataSize = 132;
            break;
        }
        case SQL::typeFloat: {
            if (_size <= sizeof(double)) {
                status = ::OCINumberFromReal(
                        pError,             // OCIError *err,
                        (CONST dvoid*)_pv,  // CONST dvoid *rnum,
                        _size,              // uword rnum_length,
                        &__data.num         // OCINumber *number
                        );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR(SQL::eServerError, status, pError);
                    return false;
                }
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize, 0, NULL);
                return false;
            }
            OciData::__value = &__data;
            OciData::__valueSize = sizeof(OCINumber);
            OciData::__dataType = SQLT_VNU;
            OciData::__maxDataSize = 132;
            break;
        }
        case SQL::typeDate: {
            if (_size == sizeof(SQL::Date)) {
                const SQL::Date* p = (const SQL::Date*)_pv;
                SQL::TimeStamp ts;
                ts.year = p->year;
                ts.month = p->month;
                ts.day = p->day;
                ts.hour = ts.min = ts.sec = 0;
                ts.frac = 0;
                ts.tzoff = INT16_MIN;
                if (!setTimeStamp(&ts, sizeof(SQL::TimeStamp), SQL::typeTimeStamp))
                    return false;
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize, 0, NULL);
                return false;
            }
            break;
        }
        case SQL::typeTime: {
            // Oracle에서 DATE, TIMESTAMP 모두 시간만 저장할 수 없다.
            __SET_ERROR(SQL::eNotSupportDataType, 0, NULL);
            return false;
        }
        case SQL::typeTimeStamp: {
            if (_size == sizeof(SQL::TimeStamp)) {
                if (!setTimeStamp((const SQL::TimeStamp*)_pv, _size, _assignType))
                    return false;
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize, 0, NULL);
                return false;
            }
            break;
        }
        case SQL::typeInterval: {
            if (_size == sizeof(SQL::Interval)) {
                if (!setInterval((const SQL::Interval*)_pv, _size, _assignType))
                    return false;
            }
            else {
                __SET_ERROR(SQL::eInvalidDataSize, 0, NULL);
                return false;
            }
            break;
        }
        case SQL::typeText: {
            if (_assignType == SQL::typeNumeric) {
                status = ::OCINumberFromText(
                        pError,             // OCIError *err,
                        (CONST OraText*)_pv,    // 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.num         // OCINumber *number
                        );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR(SQL::eServerError, status, pError);
                    return false;
                }
                OciData::__value = &__data;
                OciData::__valueSize = sizeof(OCINumber);
                OciData::__dataType = SQLT_VNU;
                OciData::__maxDataSize = 132;
                break;
            }
        }
        case SQL::typeBinary: {
            switch (_assignType) {
                case SQL::typeText: {
                    OciData::__dataType = SQLT_CHR;
                    OciData::__maxDataSize = 4000;
                    break;
                }
                case SQL::typeBinary: {
                    OciData::__dataType = SQLT_BIN;
                    OciData::__maxDataSize = 2000;
                    break;
                }
                case SQL::typeLongText: {
                    OciData::__dataType = SQLT_LNG;
                    OciData::__maxDataSize = INT32_MAX;
                    break;
                }
                case SQL::typeLongBinary: {
                    OciData::__dataType = SQLT_LBI;
                    OciData::__maxDataSize = INT32_MAX;
                    break;
                }
                default: {
                    __SET_ERROR(SQL::eNotSupportDataType, 0, NULL);
                    return false;
                }
            }
            OciData::__value = _pv;
            OciData::__valueSize = _size;
            break;
        }
        case SQL::typeInputStream: {
            switch (_assignType) {
                case SQL::typeText: {
                    OciData::__dataType = SQLT_CHR;
                    OciData::__maxDataSize = 4000;
                    break;
                }
                case SQL::typeBinary: {
                    OciData::__dataType = SQLT_BIN;
                    OciData::__maxDataSize = 2000;
                    break;
                }
                case SQL::typeLongText: {
                    OciData::__dataType = SQLT_LNG;
                    OciData::__maxDataSize = INT32_MAX;
                    break;
                }
                case SQL::typeLongBinary: {
                    OciData::__dataType = SQLT_LBI;
                    OciData::__maxDataSize = INT32_MAX;
                    break;
                }
                default: {
                    __SET_ERROR(SQL::eNotSupportDataType, 0, NULL);
                    return false;
                }
            }
            OciData::__value = NULL;
            if (_size > INT32_MAX)
                OciData::__valueSize = INT32_MAX;
            else
                OciData::__valueSize = _size;
            __inputStream = (InputStream*)_pv;
            break;
        }
        default: {
            __SET_ERROR(SQL::eNotSupportDataType, 0, NULL);
            return false;
        }
    }
 
    Param::__dataType = _assignType;
    __inputIndicator = 0;
 
    return true;
}
 
inline int16_t __ABS(int16_t n)
{
    return n < 0 ? -n : n;
}
 
bool OciParam::setTimeStamp(
        const SQL::TimeStamp* _pv,
        size_t _size,
        SQL::DataType _assignType
        )
{
    OciConnection* _conn = conn();
    sword status = OCI_SUCCESS;
 
    if (OciData::__descType == 0) {
        __DCL_ASSERT(OciData::__descType == 0);
    
        ub2 dataType = SQLT_TIMESTAMP;
        ub4 descType = OCI_DTYPE_TIMESTAMP;
        if (_assignType == SQL::typeTimeStampTz) {
            dataType = SQLT_TIMESTAMP_TZ;
            descType = OCI_DTYPE_TIMESTAMP_TZ;
        }
 
        status = _conn->OCIDescriptorAlloc(
                &(__data.desc),
                descType
                );
        if (status != OCI_SUCCESS) {
            __SET_ERROR(SQL::eServerError, status, NULL);
            return false;
        }
 
        OciData::__descType = descType;
        OciData::__dataType = dataType;
        OciData::__maxDataSize = sizeof(SQL::TimeStamp);
    }
 
    ByteString strTz;
    OraText* pTz = NULL;
    size_t nTzLen = 0;
    if (_assignType == SQL::typeTimeStampTz) {
        strTz = ByteString::format(
            //          6,
            "%02d:%02d",
            _pv->tzoff / 60,
            __ABS(_pv->tzoff % 60)
            );
        pTz = (OraText*)strTz.data();
        nTzLen = strTz.length();
    }
 
    OCISession* pSession = _conn->sessionHandle();
    OCIError* pError = _conn->errorHandle();
 
    status = ::OCIDateTimeConstruct(
            pSession,       // dvoid *hndl,
            pError,         // OCIError *err,
            (OCIDateTime*)__data.desc,  // OCIDateTime *datetime,
            _pv->year,      // sb2 year,
            _pv->month,        // ub1 month,
            _pv->day,        // ub1 day,
            _pv->hour,      // ub1 hour,
            _pv->min,        // ub1 min,
            _pv->sec,        // ub1 sec,
            _pv->frac,      // ub4 fsec,
            pTz,            // OraText *timezone,
            nTzLen          // size_t timezone_length
            );
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, NULL);
        return false;
    }
 
    OciData::__value = &__data;
    OciData::__valueSize = sizeof(OCIDateTime*);
 
    return true;
}
 
bool OciParam::setInterval(
        const SQL::Interval* _pv,
        size_t _size,
        SQL::DataType _assignType
        )
{
    OciConnection* _conn = conn();
    sword status = OCI_SUCCESS;
 
    if (OciData::__descType == 0) {
        __DCL_ASSERT(OciData::__descType == 0);
 
        ub2 dataType = SQLT_INTERVAL_DS;
        ub4 descType = OCI_DTYPE_INTERVAL_DS;
        if (_assignType == SQL::typeIntervalYm) {
            dataType = SQLT_INTERVAL_YM;
            descType = OCI_DTYPE_INTERVAL_YM;
        }
        
        status = _conn->OCIDescriptorAlloc(
                &(__data.desc),
                descType
                );
        if (status != OCI_SUCCESS) {
            __SET_ERROR(SQL::eServerError, status, NULL);
            return false;
        }
 
        OciData::__descType = descType;
        OciData::__dataType = dataType;
        OciData::__maxDataSize = sizeof(SQL::Interval);
    }
 
    OCISession* pSession = _conn->sessionHandle();
    OCIError* pError = _conn->errorHandle();
 
    if (OciData::__dataType == SQLT_INTERVAL_YM) {
        // set zero
        // 이부분이 빠지면 Query::execute에서
        status = ::OCIIntervalFromText(
                pSession,               // dvoid *hndl,
                pError,                 // 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(
                pSession,           // dvoid *hndl,
                pError,             // OCIError *err,
                _pv->years,            // sb4 yr,
                _pv->months,          // sb4 mnth,
                (OCIInterval*)__data.desc   // OCIInterval *result
                );
    }
    else {
        status = ::OCIIntervalFromText(
                pSession,           // dvoid *hndl,
                pError,             // 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(
                pSession,           // dvoid *hndl,
                pError,             // OCIError *err,
                _pv->days,          // sb4 dy,
                _pv->hours,            // sb4 hr,
                _pv->mins,          // sb4 mm,
                _pv->secs,          // sb4 ss,
                _pv->fracs,            // sb4 fsec,
                (OCIInterval*)__data.desc   // OCIInterval *result
                );
    }
#if defined(__DCL_DEBUG) && 1
    if (status == OCI_SUCCESS) {
        ub4 valid = 0;
        status = ::OCIIntervalCheck(
                pSession,   // dvoid *hndl,
                pError,         // OCIError *err,
                (CONST OCIInterval*)__data.desc, // CONST OCIInterval *interval,
                &valid      // ub4 *valid
                );
    }
#endif
 
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, NULL);
        return false;
    }
 
    OciData::__value = &__data;
    OciData::__valueSize = sizeof(OCIInterval*);
 
    return true;
}
 
bool OciParam::doBind()
{
    sword status = OCI_SUCCESS;
    OciConnection* pConnection = conn();
    OCIError* pError = pConnection->errorHandle();
    OCIStmt* pStmt = query()->stmtHandle();
 
    if (OciData::__dataType == 0) {
        // then out bind only param
        __DCL_ASSERT(OciData::__value == NULL);
        __DCL_ASSERT(OciData::__descType == 0);
        __DCL_ASSERT(__buffer == NULL);
    }
 
    // __DCL_TRACE3_N("%s, %d, %p\n", Param::__name.data(), 
    //  OciData::__valueSize, OciData::__value);
    status = ::OCIBindByPos(
            pStmt,                  // OCIStmt  *stmtp, 
            &__bind,                // OCIBind  **bindp,
            pError,                 // OCIError *errhp,
            OciData::__position, // ub4      position,
            NULL,                   // dvoid    *valuep,
            OciData::__valueSize,   // sb4      value_sz,
            OciData::__dataType, // 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) {
        __SET_ERROR(SQL::eServerError, status, pError);
        conn()->setErrorEx(ByteString::format("position[%d]", OciData::__position));
        return false;
    }
    __DCL_ASSERT(__bind != NULL);   // bindDynamic은 bindByPos 이후에
    if (OciData::__dynamicMode == OCI_DATA_AT_EXEC) {
        status = ::OCIBindDynamic(
                __bind,             // OCIBind      *bindp,
                pError,                 // OCIError     *errhp,
                this,                   // dvoid        *ictxp,
                OciParam::CallbackInBind,
                this,                   // dvoid        *octxp
                OciParam::CallbackOutBind
                );
        if (status != OCI_SUCCESS) {
            __SET_ERROR(SQL::eServerError, status, pError);
            conn()->setErrorEx(ByteString::format("position[%d]", OciData::__position));
            return false;
        }
    }
 
    return true;
}
 
sb4 OciParam::CallbackInBind(
        dvoid       *ictxp,
        OCIBind     *bindp,
        ub4         iter,
        ub4         index,
        dvoid       **bufpp,
        ub4         *alenp,
        ub1         *piecep,
        dvoid       **indpp
            )
{
    return ((OciParam*)ictxp)->onCallbackInBind(
            bindp,
            iter,
            index,
            bufpp,
            alenp,
            piecep,
            indpp
            );
}
    
sb4 OciParam::CallbackOutBind(
        dvoid       *octxp,
        OCIBind     *bindp,
        ub4         iter,
        ub4         index,
        dvoid       **bufpp,
        ub4         **alenpp,
        ub1         *piecep,
        dvoid       **indpp,
        ub2         **rcodepp
        )
{
    return ((OciParam*)octxp)->onCallbackOutBind(
            bindp,
            iter,
            index,
            bufpp,
            alenpp,
            piecep,
            indpp,
            rcodepp
            );
}
 
inline size_t __MIN(size_t x, size_t y)
{
    return x < y ? x : y;
}
 
sb4 OciParam::onCallbackInBind(
        OCIBind*    pBind,
        ub4         nIterator,
        ub4         _index,
        dvoid**     ppvBuffer,
        ub4*        pnActualLength,
        ub1*        pnPiece,
        dvoid**     ppvIndicator
        )
{
 
//#ifdef __DCL_DEBUG
//  switch(*pnPiece)
//  {
//  case OCI_ONE_PIECE :
//      __DCL_TRACE1_N(L"OCI_ONE_PIECE: %s\n", UTF8Decoder::decode(Param::__name).data());
//      break;
//  case OCI_FIRST_PIECE :
//      __DCL_TRACE1_N(L"OCI_FIRST_PIECE: %s\n", UTF8Decoder::decode(Param::__name).data());
//      break;
//  case OCI_NEXT_PIECE :
//      __DCL_TRACE1_N(L"OCI_NEXT_PIECE: %s\n", UTF8Decoder::decode(Param::__name).data());
//      break;
//  case OCI_LAST_PIECE :
//      __DCL_TRACE1_N(L"OCI_LAST_PIECE: %s\n", UTF8Decoder::decode(Param::__name).data());
//  }
//#endif
 
    if (__inputIndicator == -1) {
        *ppvBuffer = NULL;
        *pnActualLength = 0;
        *pnPiece = OCI_ONE_PIECE;
        *ppvIndicator = &__inputIndicator;
        return OCI_CONTINUE;
    }
 
    if (__inputStream) {
        __DCL_ASSERT(OciData::__dataType == SQLT_CHR 
            || OciData::__dataType == SQLT_BIN
            || OciData::__dataType == SQLT_LNG
            || OciData::__dataType == SQLT_LBI);
 
        if (!__buffer) {
            __buffer = malloc(DYNAMIC_BUFFER_SIZE);
            if (!__buffer) {
                __SET_ERROR(SQL::eOutOfMemory, 0, NULL);
                return OCI_ERROR;
            }
        }
 
        __DCL_ASSERT(__buffer != NULL);
 
        size_t nRead = __MIN((size_t)OciData::__valueSize, DYNAMIC_BUFFER_SIZE);
 
        if (nRead) {
            try {
                nRead = __inputStream->read(__buffer, nRead);
            }
            catch(IOException* e) {
                conn()->setErrorEx(UTF8Encoder::encode(e->toStringAll()));
                e->destroy();
                return OCI_ERROR;
            }
        }
 
        if (*pnPiece == OCI_FIRST_PIECE) {
            if (nRead == (size_t)OciData::__valueSize)
                *pnPiece = OCI_ONE_PIECE;
        }
        else {
            // OCI_NEXT_PIECE
            if (nRead == 0 || nRead == (size_t)OciData::__valueSize)
                *pnPiece = OCI_LAST_PIECE;
        }
 
        OciData::__valueSize -= nRead;
 
        *ppvBuffer = __buffer;
        *pnActualLength = nRead;
        *ppvIndicator = NULL;
    }
    else {
        if (OciData::__descType) {
            // 입력이 TIMESTAMP와 같은 디스크립터일 경우 버퍼에 이들의 값을
            // 넣어 준다.
            *ppvBuffer = __data.desc;
        }
        else {
            // 나머지 경우 OciData::m_pValue는 
            // 외부에서 받은 char*, byte_t* 그리고 &OciParam::__data 이다.
            *ppvBuffer = OciData::__value;
        }
        *pnActualLength = OciData::__valueSize;
        *pnPiece = OCI_ONE_PIECE;
        *ppvIndicator = &__inputIndicator;
    }
 
    return OCI_CONTINUE;
}
    
sb4 OciParam::onCallbackOutBind(
        OCIBind*    pBind,
        ub4         nIterator,
        ub4         _index,
        dvoid**     ppvBuffer,
        ub4**       ppnActualLength,
        ub1*        pnPiece,
        dvoid**     ppvIndicator,
        ub2**       ppnReturnCode
        )
{
    __DCL_ASSERT(OciData::__dynamicMode == OCI_DATA_AT_EXEC);
    /*
    if (_index == 0) {
        ub4 nRows = 0;
        ub4 _size = 0;
 
        sword status = ::OCIAttrGet(
                __bind,
                OCI_HTYPE_BIND,
                &nRows,
                &_size,
                OCI_ATTR_ROWS_RETURNED,
                query()->connection()->errorHandle());
        if (status != OCI_SUCCESS) {
            return OCI_ERROR;
        }
    }
    */
/*
#ifdef __DCL_DEBUG
    switch(*pnPiece) {
    case OCI_ONE_PIECE :
        __DCL_TRACE1_N("OCI_ONE_PIECE: %s\n", Param::__name.data());
        break;
    case OCI_FIRST_PIECE :
        __DCL_TRACE1_N("OCI_FIRST_PIECE: %s\n", Param::__name.data());
        break;
    case OCI_NEXT_PIECE :
        __DCL_TRACE1_N("OCI_NEXT_PIECE: %s\n", Param::__name.data());
        break;
    case OCI_LAST_PIECE :
        __DCL_TRACE1_N("OCI_LAST_PIECE: %s\n", Param::__name.data());
    }
#endif
*/
    if (OciData::__dataType == SQLT_CHR
            || OciData::__dataType == SQLT_BIN
            || OciData::__dataType == SQLT_LNG 
            || OciData::__dataType == SQLT_LBI) {
        if (*pnPiece == OCI_ONE_PIECE)
            *pnPiece = OCI_FIRST_PIECE;
 
        if (*pnPiece == OCI_FIRST_PIECE) {
            if (!__buffer) {
                __buffer = malloc(DYNAMIC_BUFFER_SIZE);
                if (!__buffer) {
                    __SET_ERROR(SQL::eOutOfMemory, 0, NULL);
                    return OCI_ERROR;
                }
            }
 
            OciData::__value = __buffer;
            if (OciData::__bytesOutput)
                __bytesOutput->reset();
        }
        else {
            // 두번째 PIECE 부터는 이전 데이터를 내부 스트림에 보관한다.
            if (!OciData::__bytesOutput) {
                OciData::__bytesOutput = new BytesOutputStream();
                if (!OciData::__bytesOutput) {
                    __SET_ERROR(SQL::eOutOfMemory, 0, NULL);
                    return OCI_ERROR;
                }
            }
            
            __DCL_ASSERT(OciData::__bytesOutput != NULL);
            try {
                OciData::__bytesOutput->write(
                    OciData::__value,
                    OciData::__callbackActualLength
                    );
            }
            catch(IOException* e) {
                conn()->setErrorEx(
                    UTF8Encoder::encode(e->toStringAll())
                );
                e->destroy();
                return OCI_ERROR;
            }
        }
 
        OciData::__callbackActualLength = DYNAMIC_BUFFER_SIZE;
        OciData::__indicator = -1;
 
        *ppvBuffer = OciData::__value;
        *ppnActualLength = &(OciData::__callbackActualLength);
        *ppvIndicator = &(OciData::__indicator);
        *ppnReturnCode = &(OciData::__returnCode);
    }
    else {
        // 버퍼가 OCIDateTime*, OCILogLocator*, OCIRowid* 와 같은
        // void*의 디스크립터 일 경우 ppvBuffer에는 이들 디스크립터의
        // 값을 넣어 주어야 한다.
        // 그러나, OciData::getData에서는 OciData::m_pValue를 사용하여
        // 값을 얻기 때문에 이들의 주소를 할당해야 한다.
        // OCIDateTime의 경우 *(OCIDateTime**)OciData::__value 와 같이 사용된다.
        //
        // OCINumber, OCIDate와 같은 경우 이들의 포인터를 할당한다.
        if (OciData::__descType) {
            OciData::__value = &__data.desc;
            OciData::__callbackActualLength = sizeof(void*);
            *ppvBuffer = __data.desc;
        }
        else {
            OciData::__value = &__data;
            OciData::__callbackActualLength = OciData::__valueSize;
            *ppvBuffer = &__data;
        }
        OciData::__indicator = -1;
 
        *pnPiece = OCI_ONE_PIECE;
        *ppnActualLength = &(OciData::__callbackActualLength);//NULL;
        *ppvIndicator = &(OciData::__indicator);
        *ppnReturnCode = &(OciData::__returnCode);
    }
 
    return OCI_CONTINUE;
}
 
__DCL_END_NAMESPACE