OciData.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <oci.h>
 
#include <stdlib.h>     // strtoll, strtoull
#include <string.h>     // memcpy, strncpy
 
#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/BytesOutputStream.h>
#include <dcl/SQLCore.h>
 
#include "OciConnection.h"
#include "OciQuery.h"
#include "OciData.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/OciData.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__)
 
OciData::OciData()
{
    __position = 0;
    __dynamicMode = OCI_DEFAULT;
 
    __valueType = SQLT_CHR;
    __descType = 0;
    __valuePtr = NULL;
    __valueSize = 0;
    __indicator = -1;
    __actualLength = 0;
    __returnCode = 0;
    __callbackActualLength = 0;
 
    __bytesOutput = NULL;
    __dataSize = 0;
    __maxDataSize = 0;
}
 
OciData::~OciData()
{
    if (OciData::__bytesOutput) {
        delete OciData::__bytesOutput;
        // OciData::__bytesOutput = NULL;
    }
}
 
bool OciData::onAfterFetch()
{
    // after fetch
    // after execute in outbind
    if (__indicator == -1)
        return true;
 
    sword status = OCI_SUCCESS;
    switch(__valueType) {
        case SQLT_CHR:
        case SQLT_AFC:
        case SQLT_BIN:
        // case SQLT_RDD: SQLT_CHR로
        // See. OciField::init, OciData::__TYPE_SIZE
        case SQLT_LNG:
        case SQLT_LBI: {
            if (__dynamicMode == OCI_DEFAULT) {
                // OCIDefineByPos OCI_DEFAULT만 __actualLength에 있다.
                __dataSize = __actualLength;
            }
            else {
                // OCI_DYNAMIC_FETCH, OCI_DATA_AT_EXEC3
                // OutBind 파라미터의 __dynamicMode는 모두 OCI_DATA_AT_EXEC 이다.
                // OCI_LAST_PIECE 이전은 __bytesOutput에 보관되어 있다.
                // OCI_LAST_PIECE 길이는 __callbackActualLength에 있다.
                __dataSize = (__bytesOutput ? __bytesOutput->size() : 0)
                    + __callbackActualLength;
            }
            break;
        }
        case SQLT_CLOB:
        case SQLT_BLOB:
        case SQLT_CFILE:
        case SQLT_BFILE: {
            ub4 len = 0;
            if (__descType == OCI_DTYPE_FILE) {
                status = OCILobFileOpen(
                    conn()->svcHandle(),            // OCISvcCtx *svchp
                    conn()->errorHandle(),          // OCIError *errhp
                    *(OCILobLocator**)__valuePtr, // OCILobLocator *filep
                    OCI_FILE_READONLY               // ub1 mode
                );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
                    return false;
                }
            }
 
            status = OCILobGetLength(
                conn()->svcHandle(),                // OCISvcCtx *svchp
                conn()->errorHandle(),              // OCIError *errhp
                *(OCILobLocator**)__valuePtr,     // OCILobLocator *locp
                &len                                // ub4 *lenp
            );
            if (status != OCI_SUCCESS) {
                __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
                return false;
            }
 
            if (__descType == OCI_DTYPE_FILE) {
                status = OCILobFileClose(
                    conn()->svcHandle(),            // OCISvcCtx *svchp
                    conn()->errorHandle(),          // OCIError *errhp
                    *(OCILobLocator**)__valuePtr  // OCILobLocator *locp
                );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
                    return false;
                }
            }
 
            switch (__valueType) {
                case SQLT_CLOB:
                case SQLT_CFILE:
                    __dataSize = len * 3; // UTF-8
                    break;
                default:
                    __dataSize = len;
            }
            break;
        }
        default: {
            __dataSize = OciData::__maxDataSize;
        }
    }
 
    return true;
}
 
const wchar_t* OciData::serverDataTypeName() const
{
    return OciData::__TYPE_NAME(__valueType);
}
 
bool OciData::getDataSize(size_t* _size, bool _maxsize)
{
    if (_maxsize) {
        *_size = OciData::__maxDataSize;
        return true;
    }
#if 0
    if (query()->stmtType() == OCI_STMT_SELECT) {
        if (!query()->inState(SQL::Query::stFetched)) {
            __SET_ERROR_HANDLE(SQL::eNotFetched, 0, NULL);
            return false;
        }
    }
    else {
        if (!query()->inState(SQL::Query::stExecuted)) {
            __SET_ERROR_HANDLE(SQL::eNotExecuted, 0, NULL);
            return false;
        }
    }
#endif
    *_size = __indicator == -1 ? (size_t)-1 : OciData::__dataSize;
    return true;
}
 
bool OciData::getData(void* _buf, size_t* _size, SQL::DataType _bufType)
{
#if 0
    if (query()->stmtType() == OCI_STMT_SELECT) {
        if (!query()->inState(SQL::Query::stFetched)) {
            __SET_ERROR_HANDLE(SQL::eNotFetched, 0, NULL);
            return false;
        }
    }
    else {
        if (!query()->inState(SQL::Query::stExecuted)) {
            __SET_ERROR_HANDLE(SQL::eNotExecuted, 0, NULL);
            return false;
        }
    }
#endif
    if (__indicator == -1) {
        __SET_ERROR_HANDLE(SQL::eValueIsNull, 0, NULL);
        return false;
    }
 
    switch(_bufType) {
        case SQL::typeInteger:
        case SQL::typeUInteger: {
            return getInteger(_buf, _size, _bufType);
        }
        case SQL::typeFloat: {
            return getFloat(_buf, _size);
        }
        case SQL::typeDate: {
            if (*_size != sizeof(SQL::Date)) {
                *_size = sizeof(SQL::Date);
                __SET_ERROR_HANDLE(SQL::eInvalidBufferSize, 0, NULL);
                return false;
            }
            SQL::TimeStamp ts;
            bool r = getTimeStamp(&ts);
            if (r) {
                SQL::Date* p = (SQL::Date*)_buf;
                p->year = ts.year;
                p->month = ts.month;
                p->day = ts.day;
            }
            return r;
        }
        case SQL::typeTime: {
            if (*_size != sizeof(SQL::typeTime)) {
                *_size = sizeof(SQL::typeTime);
                __SET_ERROR_HANDLE(SQL::eInvalidBufferSize, 0, NULL);
                return false;
            }
            SQL::TimeStamp ts;
            bool r = getTimeStamp(&ts);
            if (r) {
                SQL::Time* p = (SQL::Time*)_buf;
                p->hour = ts.hour;
                p->min = ts.min;
                p->sec = ts.sec;
                p->frac = ts.frac;
                p->tzoff = ts.tzoff;
            }
            return r;
        }
        case SQL::typeTimeStamp: {
            if (*_size != sizeof(SQL::TimeStamp)) {
                *_size = sizeof(SQL::TimeStamp);
                __SET_ERROR_HANDLE(SQL::eInvalidBufferSize, 0, NULL);
                return false;
            }
            return getTimeStamp((SQL::TimeStamp*)_buf);
        }
        case SQL::typeInterval: {
            if (*_size != sizeof(SQL::Interval)) {
                *_size = sizeof(SQL::Interval);
                __SET_ERROR_HANDLE(SQL::eInvalidBufferSize, 0, NULL);
                return false;
            }
            return getInterval((SQL::Interval*)_buf);
        }
        case SQL::typeText: {
            if (__valueType == SQLT_VNU) {
                return getNumericText((char*)_buf, _size);
            }
        }
        case SQL::typeBinary: {
            return getBytes((byte_t*)_buf, _size);
        }
        case SQL::typeOutputStream: {
            return writeTo((OutputStream*)_buf, _size);
        }
        default: {
            __DCL_ASSERT(false);        // SQL::Field::getData bug
        }
    }
 
    return true;
}
 
bool OciData::getInteger(void* _buf, size_t* _size, SQL::DataType _bufType)
{
    __DCL_ASSERT(__valueType == SQLT_VNU);   // OciField::init bug
 
    sword status = OCI_SUCCESS;
    if (*_size <= sizeof(int64_t /* 2025-02-03 월 int32_t */)) {
        status = OCINumberToInt(
            conn()->errorHandle(),          // OCIError *err,
            (CONST OCINumber*)__valuePtr, // CONST OCINumber *number,
            *_size,                         // uword rsl_length,
            _bufType == SQL::typeInteger ?  // uword rsl_flag,
                OCI_NUMBER_SIGNED : OCI_NUMBER_UNSIGNED,
            _buf                            // dvoid *rsl
        );
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
            return false;
        }
    }
    else {
        *_size = sizeof(int64_t);
        __SET_ERROR_HANDLE(SQL::eInvalidBufferSize, 0, NULL);
        return false;
    }
 
    return true;
}
 
bool OciData::getFloat(void* _buf, size_t* _size)
{
    switch (__valueType) {
        case SQLT_BFLOAT: {
            switch (*_size) {
                case sizeof(float): {
                    *(float*)_buf = *(float*)__valuePtr;
                    break;
                }
                case sizeof(double) : {
                    *(double*)_buf = *(float*)__valuePtr;
                    break;
                }
                default: {
                    *_size = sizeof(float);
                    __SET_ERROR_HANDLE(SQL::eInvalidBufferSize, 0, NULL);
                    return false;
                }
            }
            break;
        }
        case SQLT_BDOUBLE: {
            switch (*_size) {
                case sizeof(double) : {
                    *(double*)_buf = *(double*)__valuePtr;
                    break;
                }
                default: {
                    *_size = sizeof(double);
                    __SET_ERROR_HANDLE(SQL::eInvalidBufferSize, 0, NULL);
                    return false;
                }
            }
            break;
        }
        case SQLT_VNU: {
            if (*_size <= sizeof(long double)) {
                // long double 의 storage size
                // MSVC/WIN32   8
                // GCC/Linux    12
                sword status = OCINumberToReal(
                    conn()->errorHandle(),          // OCIError *err,
                    (CONST OCINumber*)__valuePtr, // CONST OCINumber *number,
                    *_size,                         // uword rsl_length,
                    _buf                            // dvoid *rsl
                );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
                    return false;
                }
            }
            else {
                *_size = sizeof(double);
                __SET_ERROR_HANDLE(SQL::eInvalidBufferSize, 0, NULL);
                return false;
            }
            break;
        }
        default: {
            __DCL_ASSERT(false);
        }
    }
 
    return true;
}
 
bool OciData::getNumericText(char* pBuf, size_t* _size)
{
    __DCL_ASSERT(__valueType == SQLT_VNU);   // OciField::init bug
 
    ub4 n = 133;
    ByteBuffer* buf = ByteBuffer::create_e(n);
    sword status = OCINumberToText(
        conn()->errorHandle(),              // OCIError *err,
        (CONST OCINumber*)__valuePtr,     // CONST OCINumber *number,
        (const OraText*)"TM",               // CONST OraText *fmt,
        2,                                  // ub4 fmt_length,
        NULL,                               // CONST OraText *nls_params,
        0,                                  // ub4 nls_p_length,
        &n,                                 // ub4 *buf_size,
        (text*)buf->data()                  // text *buf
    );
    if (status != OCI_SUCCESS) {
        if (buf->__allocLength < n) {
            ByteBuffer::extend(buf, n);
        }
        status = OCINumberToText(
            conn()->errorHandle(),          // OCIError *err,
            (CONST OCINumber*)__valuePtr, // CONST OCINumber *number,
            (CONST OraText*)"TM",           // CONST OraText *fmt,
            2,                              // ub4 fmt_length,
            NULL,                           // CONST OraText *nls_params,
            0,                              // ub4 nls_p_length,
            &n,                             // ub4 *buf_size,
            (text*)buf->data()              // text *buf
        );
    }
    if (status != OCI_SUCCESS) {
        buf->release();
        __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
        return false;
    }
 
    buf->__dataLength = n;
    ByteString s = buf;
    buf->release();
 
    if (*_size < (size_t)s.length()) {
        *_size = (size_t)s.length();
        __SET_ERROR_HANDLE(SQL::eInvalidBufferSize, 0, NULL);
        return false;
    }
 
    strncpy(pBuf, s.data(), s.length());
    if (*_size > (size_t)s.length()) {
        *_size = (size_t)s.length();
        pBuf[*_size] = '\0';
    }
 
    return true;
}
 
bool OciData::getTimeStamp(SQL::TimeStamp* _buf)
{
    sb2 year    = 0;
    ub1 month   = 0;
    ub1 day = 0;
    ub1 hour    = 0;
    ub1 min = 0;
    ub1 sec = 0;
    ub4 fsec    = 0;
 
    _buf->tzoff = INT16_MIN;
 
    sword status = OCI_SUCCESS;
    switch(__valueType) {
    //  case SQLT_DAT :
        case SQLT_ODT: {
            OCIDateGetDate(
                (CONST OCIDate*)__valuePtr,       // const OCIDate *date
                &year,                          // sb2 *year
                &month,                         // ub1 *month
                &day                            // ub1 *day
            );
            OCIDateGetTime(
                (CONST OCIDate*)__valuePtr,       // const OCIDate *date
                &hour,                          // ub1 *hour
                &min,                           // ub1 *min
                &sec                            // ub1 *sec
            );
            break;
        }
        case SQLT_TIMESTAMP :
        case SQLT_TIMESTAMP_TZ :
        case SQLT_TIMESTAMP_LTZ: {
            status = OCIDateTimeGetDate(
                conn()->sessionHandle(),            // dvoid *hndl,
                conn()->errorHandle(),              // OCIError *err,
                *(CONST OCIDateTime**)__valuePtr, // CONST OCIDateTime *datetime,
                &year,                              // sb2 *year,
                &month,                             // ub1 *month,
                &day                                // ub1 *day 
            );
            if (status == OCI_SUCCESS)
                status = OCIDateTimeGetTime(
                    conn()->sessionHandle(),        // dvoid *hndl,
                    conn()->errorHandle(),          // OCIError *err,
                    *(OCIDateTime**)__valuePtr,       // OCIDateTime *datetime,
                    &hour,                          // ub1 *hour,
                    &min,                           // ub1 *min,
                    &sec,                           // ub1 *sec,
                    &fsec                           // ub4 *fsec
                );
            if (status == OCI_SUCCESS && __valueType != SQLT_TIMESTAMP) {
                sb1 tzHour = 0;
                sb1 tzMin = 0;
                status = OCIDateTimeGetTimeZoneOffset(
                    conn()->sessionHandle(),            // dvoid *hndl,
                    conn()->errorHandle(),              // OCIError *err,
                    *(CONST OCIDateTime**)__valuePtr, // CONST OCIDateTime *datetime,
                    &tzHour,                            // sb1 *hour,
                    &tzMin                              // sb1 *min,
                );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
                    return false;
                }
                //  __DCL_TRACE2_N("TZ : %+03d:%02d\n", hour, min);
                _buf->tzoff = tzHour * 60 + tzMin;
            }
            break;
        }
        default: {
            __DCL_ASSERT(false);    // OciField::init bug
        }
    }
 
    _buf->year = year;
    _buf->month = month;
    _buf->day = day;
    _buf->hour = hour;
    _buf->min = min;
    _buf->sec = sec;
    _buf->frac = fsec;
 
    return true;
}
 
bool OciData::getInterval(SQL::Interval* _buf)
{
    sb4 year = 0;
    sb4 month = 0;
    sb4 day = 0;
    sb4 hour = 0;
    sb4 min = 0;
    sb4 sec = 0;
    sb4 fsec = 0;
    sword status = OCI_SUCCESS;
 
    switch(__valueType) {
        case SQLT_INTERVAL_YM: {
            status = OCIIntervalGetYearMonth(
                conn()->sessionHandle(),            // dvoid *hndl,
                conn()->errorHandle(),              // OCIError *err,
                &year,                              // sb4 *yr,
                &month,                             // sb4 *mnth,
                *(CONST OCIInterval**)__valuePtr  // CONST OCIInterval *interval
            );
            break;
        }
        case SQLT_INTERVAL_DS: {
            status = OCIIntervalGetDaySecond(
                conn()->sessionHandle(),            // dvoid *hndl,
                conn()->errorHandle(),              // OCIError *err,
                &day,                               // sb4 *dy,
                &hour,                              // sb4 *hr,
                &min,                               // sb4 *mm,
                &sec,                               // sb4 *ss,
                &fsec,                              // sb4 *fsec,
                *(CONST OCIInterval**)__valuePtr  // CONST OCIInterval *interval
            );
            break;
        }
        default: {
            __DCL_ASSERT(false);    // OciField::init bug
        }
    }
 
    if (status != OCI_SUCCESS) {
        __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
        return false;
    }
 
    _buf->years = year;
    _buf->months = month;
    _buf->days = day;
    _buf->hours = hour;
    _buf->mins = min;
    _buf->secs = sec;
    _buf->fracs = fsec;
    return true;
}
 
inline size_t __MIN(size_t x, size_t y)
{
    return x < y ? x : y;
}
 
bool OciData::getBytes(byte_t* _buf, size_t* _size)
{
    switch(__valueType) {
        case SQLT_RDD: {
            if (*_size < __dataSize) {
                *_size = __dataSize;
                __SET_ERROR_HANDLE(SQL::eInvalidBufferSize, 0, NULL);
                return false;
            }
        }
        case SQLT_CHR :
        case SQLT_AFC :
        case SQLT_BIN :
        case SQLT_LNG :
        case SQLT_LBI: {
            size_t total = 0;
            if (__dynamicMode == OCI_DEFAULT) {
                __DCL_ASSERT(__dataSize == __actualLength);
                total = __MIN(__actualLength, *_size);
                memcpy(_buf, __valuePtr, total);
            }
            else {
                // __dataSize는 __bytesOutput + __callbackActualLength
                if (__bytesOutput) {
                    total = __MIN(__bytesOutput->size(), *_size);
                    memcpy(_buf, __bytesOutput->data(), total);
                }
                size_t copy = __MIN(__callbackActualLength, *_size - total);
                memcpy(_buf + total, __valuePtr, copy);
                total += copy;
            }
            if (total < *_size) {
                *(_buf + total) = '\0';
            }
            *_size = total;
            break;
        }
        case SQLT_CLOB:
        case SQLT_BLOB:
        case SQLT_CFILE:
        case SQLT_BFILE: {
            if (*_size && __dataSize)
                return getBytesFromLob(_buf, _size);
            else
                *_size = 0;
            break;
        }
        default: {
            __DCL_ASSERT(false);    // OciField::init bug
        }
    }
 
    return true;
}
 
bool OciData::writeTo(OutputStream* _output, size_t* _size)
{
    switch(__valueType) {
        case SQLT_RDD: {
            if (*_size < __dataSize) {
                *_size = __dataSize;
                __SET_ERROR_HANDLE(SQL::eInvalidBufferSize, 0, NULL);
                return false;
            }
        }
        case SQLT_CHR:
        case SQLT_AFC:
        case SQLT_BIN:
        case SQLT_LNG:
        case SQLT_LBI: {
            try {
                size_t total = 0;
                if (__dynamicMode == OCI_DEFAULT) {
                    __DCL_ASSERT(__dataSize == __actualLength);
                    total = __MIN(__actualLength, *_size);
                    _output->write(__valuePtr, total);
                }
                else {
                    // __dataSize는 __bytesOutput + __callbackActualLength
                    if (__bytesOutput) {
                        total = __MIN(__bytesOutput->size(), *_size);
                        _output->write(__bytesOutput->data(), total);
                    }
                    size_t copy = __MIN(__callbackActualLength, *_size - total);
                    _output->write(__valuePtr, copy);
                    total += copy;
                }
                *_size = total;
            }
            catch (IOException* e) {
                e->destroy();
                return false;
            }
            break;
        }
        case SQLT_CLOB :
        case SQLT_BLOB :
        case SQLT_CFILE :
        case SQLT_BFILE: {
            if (*_size && __dataSize)
                return writeToFromLob(_output, _size);
            else
                *_size = 0;
            break;
        }
        default: {
            __DCL_ASSERT(false);    // OciField::init bug
        }
    }
 
    return true;
}
 
bool OciData::getBytesFromLob(byte_t* _buf, size_t* _size)
{
    __DCL_ASSERT(__valueType == SQLT_CLOB
        || __valueType == SQLT_BLOB
        || __valueType == SQLT_BFILE
        || __valueType == SQLT_CFILE
    );
 
    sword status = OCI_SUCCESS;
    if (__descType == OCI_DTYPE_FILE) {
        status = OCILobFileOpen(
            conn()->svcHandle(),            // OCISvcCtx *svchp
            conn()->errorHandle(),          // OCIError *errhp
            *(OCILobLocator**)__valuePtr, // OCILobLocator *locp
            OCI_FILE_READONLY               // ub1 mode
        );
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
            return false;
        }
    }
 
    // Lob로부터 csfrm를 확인한다.
    // BLOB(0), CLOB(1), NCLOB(2) 이다.
    // OCILobRead 호출에서 csfrm 값이 다르면, ORA-24806: LOB form mismatch 로 실패한다.
    // NCLOB를 NLS_LANG을 적용하여 변환하여 읽어라
    ub1 csfrm = 0;
    status = OCILobCharSetForm(
        conn()->envHandle(),                // OCIEnv *envhp
        conn()->errorHandle(),              // OCIError *errhp  
        *(OCILobLocator**)__valuePtr,     // const OCILobLocator *locp
        &csfrm                              // ub1 *csfrm
    );
    if (status != OCI_SUCCESS) {
        __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
        return false;
    }
    __DCL_TRACE2_N(L"__dataSize[%zd] csfrm[%d]\n", __dataSize, csfrm);
 
    bool r = true;
    size_t total = 0;
    while(total < *_size) {
        byte_t* buf = _buf + total;
        size_t bufl = *_size - total;
        ub4 byte_amt = bufl;
        //ub8 char_amt = byte_amt / 3;
        //ub1 piece = total == 0 ? OCI_FIRST_PIECE : OCI_NEXT_PIECE;
        status = OCILobRead(                // 2
            conn()->svcHandle(),            // OCISvcCtx *svchp
            conn()->errorHandle(),          // OCIError *errhp
            *((OCILobLocator**)__valuePtr),   // OCILobLocator *locp
            &byte_amt,                      // ub8 *byte_amtp
        //  NULL,                           // ub8 *char_amtp
            1 + total,                      // ub8 offset
            buf,                            // void *bufp
            bufl,                           // ub8 bufl
        //  piece,                          // ub1 piece
            NULL,                           // void *ctxp
            (OCICallbackLobRead)NULL,       // OCICallbackLobRead2 (cbfp)
            0,                              // ub2 csid
            csfrm                           // ub1 csfrm
        );
        if (status == OCI_ERROR) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
            r = false;
            break;
        }
 
        // OCI_SUCCESS, OCI_NEED_DATA
        if (byte_amt) {
            total += byte_amt;
        }
        else {
            break;  // done
        }
    }
 
    if (__descType == OCI_DTYPE_FILE) {
        if (r) {
            status = OCILobFileClose(
                conn()->svcHandle(),            // OCISvcCtx *svchp
                conn()->errorHandle(),          // OCIError *errhp
                *(OCILobLocator**)__valuePtr  // OCILobLocator *locp
            );
            if (status != OCI_SUCCESS) {
                __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
                return false;
            }
        }
        else {
            // 이전에 에러가 발생했다. Close 만 시킨다.
            status = OCILobFileClose(
                conn()->svcHandle(),            // OCISvcCtx *svchp
                conn()->errorHandle2(),         // OCIError *errhp
                *(OCILobLocator**)__valuePtr  // OCILobLocator *locp
            );
            if (status != OCI_SUCCESS) {
                __DCL_TRACE0(__T("Warning - OCILobFileClose Fail!\n"));
            }
        }
    }
 
    if (total < *_size) {
        *(_buf + total) = '\0';
    }
    *_size = total;
    return r;
}
 
bool OciData::writeToFromLob(OutputStream* _output, size_t* _size)
{
    __DCL_ASSERT(__valueType == SQLT_CLOB
        || __valueType == SQLT_BLOB
        || __valueType == SQLT_BFILE
        || __valueType == SQLT_CFILE
    );
 
    sword status = OCI_SUCCESS;
    if (__descType == OCI_DTYPE_FILE) {
        status = OCILobFileOpen(
            conn()->svcHandle(),            // OCISvcCtx *svchp
            conn()->errorHandle(),          // OCIError *errhp
            *(OCILobLocator**)__valuePtr, // OCILobLocator *filep
            OCI_FILE_READONLY               // ub1 mode
        );
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
            return false;
        }
    }
 
    // Lob로부터 csfrm를 확인한다.
    // BLOB(0), CLOB(1), NCLOB(2) 이다.
    // OCILobRead 호출에서 csfrm 값이 다르면, ORA-24806: LOB form mismatch 로 실패한다.
    // NCLOB를 NLS_LANG을 적용하여 변환하여 읽어라
    ub1 csfrm = 0;
    status = OCILobCharSetForm(
        conn()->envHandle(),                // OCIEnv *envhp
        conn()->errorHandle(),              // OCIError *errhp
        *(OCILobLocator**)__valuePtr,     // const OCILobLocator *locp
        &csfrm                              // ub1 *csfrm
    );
    if (status != OCI_SUCCESS) {
        __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
        return false;
    }
    __DCL_TRACE2_N(L"__dataSize[%zd] csfrm[%d]\n", __dataSize, csfrm);
 
    bool r = true;
    size_t total = 0;
    char buf[4096];
    while(total < *_size) {
        size_t bufl = __MIN(*_size - total, sizeof(buf));
        ub4 byte_amt = bufl;
        status = OCILobRead(                // 2
            conn()->svcHandle(),            // OCISvcCtx *svchp
            conn()->errorHandle(),          // OCIError *errhp
            *((OCILobLocator**)__valuePtr),   // OCILobLocator *locp
            &byte_amt,                      // oraub8 *byte_amtp,
        //  NULL,                           // oraub8 *char_amtp
            1 + total,                      // oraub8 offset
            buf,                            // void *bufp
            bufl,                           // oraub8 bufl
        //  piece,                          // ub1 piece
            NULL,                           // void *ctxp
            (OCICallbackLobRead)NULL,       // OCICallbackLobRead2 (cbfp)
            0,                              // ub2 csid
            csfrm                           // ub1 csfrm
        );
        if (status == OCI_ERROR) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
            r = false;
            break;
        }
 
        // OCI_SUCCESS, OCI_NEED_DATA
        if (byte_amt) {
            try {
                _output->write(buf, byte_amt);
            }
            catch(IOException* e) {
                e->destroy();
                r = false;
                break;
            }
 
            total += byte_amt;
        }
        else {
            break;  // done
        }
    }
 
    if (__descType == OCI_DTYPE_FILE) {
        if (r) {
            status = OCILobFileClose(
                conn()->svcHandle(),            // OCISvcCtx *svchp
                conn()->errorHandle(),          // OCIError *errhp
                *(OCILobLocator**)__valuePtr  // OCILobLocator *filep
            );
            if (status != OCI_SUCCESS) {
                __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
                return false;
            }
        }
        else {
            // 이전에 에러가 발생했다. Close 만 시킨다.
            status = OCILobFileClose(
                conn()->svcHandle(),            // OCISvcCtx *svchp
                conn()->errorHandle2(),         // OCIError *errhp
                *(OCILobLocator**)__valuePtr  // OCILobLocator *filep
            );
            if (status != OCI_SUCCESS) {
                __DCL_TRACE0(__T("Warning - OCILobFileClose Fail!\n"));
            }
        }
    }
 
    *_size = total;
    return r;
}
 
#define SQLTYPE_NAME(_sqlt, _name) case _sqlt : return L ## _name
 
const wchar_t* OciData::__TYPE_NAME(ub2 _sqlt)
{
    switch(_sqlt) {
        SQLTYPE_NAME(SQLT_NUM,      "NUMBER");
        SQLTYPE_NAME(SQLT_VNU,      "NUMBER");
        SQLTYPE_NAME(SQLT_IBFLOAT,  "BFLOAT");
        SQLTYPE_NAME(SQLT_IBDOUBLE, "DOUBLE");
        SQLTYPE_NAME(SQLT_DAT,      "DATE");
        SQLTYPE_NAME(SQLT_ODT,      "DATE");
        SQLTYPE_NAME(SQLT_TIMESTAMP,     "TIMESTAMP");
        SQLTYPE_NAME(SQLT_TIMESTAMP_TZ,  "TIMESTAMP WITH TIME ZONE");
        SQLTYPE_NAME(SQLT_TIMESTAMP_LTZ, "TIMESTAMP WITH LOCAL TIME ZONE");
        SQLTYPE_NAME(SQLT_INTERVAL_YM,   "INTERVAL YEAR TO MONTH");
        SQLTYPE_NAME(SQLT_INTERVAL_DS,   "INTERVAL DAY TO SECOND");
        SQLTYPE_NAME(SQLT_CHR,      "VARCHAR2");
        SQLTYPE_NAME(SQLT_AFC,      "CHAR");
        SQLTYPE_NAME(SQLT_BIN,      "RAW");
        SQLTYPE_NAME(SQLT_LNG,      "LONG");
        SQLTYPE_NAME(SQLT_LBI,      "LONG RAW");
        SQLTYPE_NAME(SQLT_CLOB,     "CLOB");
        SQLTYPE_NAME(SQLT_BLOB,     "BLOB");
        SQLTYPE_NAME(SQLT_BFILE,    "BFILE");
        SQLTYPE_NAME(SQLT_CFILE,    "CFILE");
        SQLTYPE_NAME(SQLT_RDD,      "ROWID");
    }
    return L"Unknown Type: Driver is not Support";
}
 
ub4 OciData::__TYPE_SIZE(ub2 _sqlt, ub4 _size)
{
    ub4 size = 0;
    switch (_sqlt) {
        case SQLT_NUM:
        case SQLT_VNU:
            size = sizeof(OCINumber);
            break;
        case SQLT_IBFLOAT:
            size = sizeof(float);
            break;
        case SQLT_IBDOUBLE:
            size = sizeof(double);
            break;
        case SQLT_DAT:
        case SQLT_ODT:
            size = sizeof(OCIDate);
            break;
        case SQLT_LNG:
        case SQLT_LBI:
            size = __DYNAMIC_BUFFER_SIZE;
            break;
        case SQLT_TIMESTAMP:
        case SQLT_TIMESTAMP_TZ:
        case SQLT_TIMESTAMP_LTZ:
        case SQLT_INTERVAL_YM:
        case SQLT_INTERVAL_DS:
        case SQLT_CLOB:
        case SQLT_BLOB:
        case SQLT_CFILE:
        case SQLT_BFILE:
            size = sizeof(void*);
            break;
        case SQLT_RDD:
            size = OCI_ROWID_LEN;
            break;
        case SQLT_CHR:
        case SQLT_AFC:
        case SQLT_BIN:
        default:
            size = _size;
    }
    return size;
}
 
size_t OciData::__TYPE_ALIGN(size_t _offset, ub2 _sqlt)
{
    size_t size = 0;
    switch (_sqlt) {
        case SQLT_IBFLOAT:
            size = sizeof(float);
            break;
        case SQLT_IBDOUBLE:
            size = sizeof(double);
            break;
        case SQLT_NUM:
        case SQLT_VNU:              // struct OCINumber
        case SQLT_DAT:
        case SQLT_ODT:              // struct OCIDate
            size = sizeof(long);
            break;
        case SQLT_TIMESTAMP:        // OCIDateTime*
        case SQLT_TIMESTAMP_TZ:
        case SQLT_TIMESTAMP_LTZ:
        case SQLT_INTERVAL_YM:      // OCIInterval*
        case SQLT_INTERVAL_DS:
        case SQLT_CLOB:             // OCILobLocator*
        case SQLT_BLOB:
        case SQLT_CFILE:
        case SQLT_BFILE:
            size = sizeof(void*);
            break;
        case SQLT_RDD:
        case SQLT_LNG:
        case SQLT_LBI:
        case SQLT_CHR:
        case SQLT_AFC:
        case SQLT_BIN:
        default:
            size = sizeof(char);
    }
    return (_offset + size - 1) & ~(size - 1);
}
 
__DCL_END_NAMESPACE