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 wchar_t __THIS_FILE__[] = __T("dcl/sql/OciData.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#undef __SET_ERROR
#define __SET_ERROR(_error, status, pError) \
    conn()->setErrorStatus(_error, status, pError, \
            true, __THIS_FILE__, __LINE__)
 
OciData::OciData()
{
    __queryHandle = NULL;
    __position = 0;
    __descType = 0;
    __dynamicMode = OCI_DEFAULT;
 
    __dataType = SQLT_CHR;
    __value = NULL;
    __valueSize = 0;
    __indicator = -1;    // null
    __actualLength = 0;
    __callbackActualLength = 0;
    __returnCode = 0;
 
    __bytesOutput = NULL;
    __dataSize = 0;
    __maxDataSize = 0;
}
 
OciData::~OciData()
{
    if (OciData::__bytesOutput) {
        delete OciData::__bytesOutput;
        // OciData::__bytesOutput = NULL;
    }
}
 
#ifdef __DCL_DEBUG
OciConnection* OciData::conn() const
{
    __DCL_ASSERT(__queryHandle != NULL);
    return __queryHandle->conn();
}
#endif
 
bool OciData::onAfterFetch()
{
    // after fetch
    // after execute in outbind
 
    if (__indicator == -1)
        return true;
 
    OciConnection* pConnection = conn();
    OCIError* pError = pConnection->errorHandle();
    sword status = OCI_SUCCESS;
 
    switch(__dataType) {
        case SQLT_CHR :
        case SQLT_AFC :
        case SQLT_BIN :
        case SQLT_LNG :
        // case SQLT_RDD :      SQLT_CHR로 OciField.cpp(213)
        case SQLT_LBI: {
            if (__dynamicMode == OCI_DEFAULT)
                __callbackActualLength = __actualLength;
 
            if (__bytesOutput)
                __dataSize = __bytesOutput->size();
            else
                __dataSize = 0;
            __dataSize += __callbackActualLength;
            break;
        }
        case SQLT_CLOB :
        case SQLT_BLOB :
        case SQLT_CFILE :
        case SQLT_BFILE: {
            OCISvcCtx* pSvcCtx = pConnection->svcctxHandle();
            ub8 nLength = 0;
            if (__descType == OCI_DTYPE_FILE) {
                status = ::OCILobFileOpen(
                        pSvcCtx,
                        pError,
                        *(OCILobLocator**)__value,
                        OCI_FILE_READONLY
                        );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR(SQL::eServerError, status, pError);
                    return false;
                }
            }
 
            status = ::OCILobGetLength2(
                    pSvcCtx,
                    pError,
                    *(OCILobLocator**)__value,
                    &nLength
                    );
            if (status != OCI_SUCCESS) {
                __SET_ERROR(SQL::eServerError, status, pError);
                return false;
            }
 
            if (__descType == OCI_DTYPE_FILE) {
                status = ::OCILobFileClose(
                        pSvcCtx,
                        pError,
                        *(OCILobLocator**)__value
                        );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR(SQL::eServerError, status, pError);
                    return false;
                }
            }
 
            switch (__dataType) {
                case SQLT_CLOB:
                case SQLT_CFILE:
                    __dataSize = nLength * 3; // UTF-8
                    break;
                default:
                    __dataSize = nLength;
            }
            break;
        }
        default: {
            __dataSize = OciData::__maxDataSize;
        }
    }
 
    return true;
}
 
bool OciData::getDataSize(size_t* _size, bool _maxSize)
{
    if (_maxSize) {
        *_size = OciData::__maxDataSize;
        return true;
    }
    else {
        if (__queryHandle->stmtType() == OCI_STMT_SELECT) {
            if (!__queryHandle->inState(SQL::Query::stFetched)) {
                __SET_ERROR(SQL::eNotFetched, 0, NULL);
                return false;
            }
        }
        else {
            if (!__queryHandle->inState(SQL::Query::stExecuted)) {
                __SET_ERROR(SQL::eNotExecuted, 0, NULL);
                return false;
            }
        }
 
        if (__indicator == -1) {
            __SET_ERROR(SQL::eValueIsNull, 0, NULL);
            return false;
        }
        *_size = OciData::__dataSize;
    }
 
    return true;
}
 
bool OciData::getData(void* _pv, size_t* _size, SQL::DataType _dataType)
{
    if (__queryHandle->stmtType() == OCI_STMT_SELECT) {
        if (!__queryHandle->inState(SQL::Query::stFetched)) {
            __SET_ERROR(SQL::eNotFetched, 0, NULL);
            return false;
        }
    }
    else {
        if (!__queryHandle->inState(SQL::Query::stExecuted)) {
            __SET_ERROR(SQL::eNotExecuted, 0, NULL);
            return false;
        }
    }
 
    if (__indicator == -1) {
        __SET_ERROR(SQL::eValueIsNull, 0, NULL);
        return false;
    }
 
    switch(_dataType) {
        case SQL::typeInteger:
        case SQL::typeUInteger: {
            return getInteger(_pv, _size, _dataType);
        }
        case SQL::typeFloat: {
            return getFloat(_pv, _size);
        }
        case SQL::typeDate: {
            if (*_size != sizeof(SQL::Date)) {
                *_size = sizeof(SQL::Date);
                __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
                return false;
            }
            SQL::TimeStamp ts;
            size_t size = sizeof(ts);
            bool r = getTimeStamp(&ts);
            if (r) {
                SQL::Date* p = (SQL::Date*)_pv;
                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(SQL::eInvalidBufferSize, 0, NULL);
                return false;
            }
            SQL::TimeStamp ts;
            size_t size = sizeof(ts);
            bool r = getTimeStamp(&ts);
            if (r) {
                SQL::Time* p = (SQL::Time*)_pv;
                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(SQL::eInvalidBufferSize, 0, NULL);
                return false;
            }
            return getTimeStamp((SQL::TimeStamp*)_pv);
        }
        case SQL::typeInterval: {
            if (*_size != sizeof(SQL::Interval)) {
                *_size = sizeof(SQL::Interval);
                __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
                return false;
            }
            return getInterval((SQL::Interval*)_pv);
        }
        case SQL::typeText: {
            if (__dataType == SQLT_VNU)
                return getNumericText((char*)_pv, _size);
        }
        case SQL::typeBinary: {
            return getBytes((byte_t*)_pv, _size);
        }
        case SQL::typeOutputStream: {
            return writeTo((OutputStream*)_pv, _size);
        }
        //  case SQL::typeDate :
        //  case SQL::typeTime :
        default: {
            __DCL_ASSERT(false);        // SQL::Field::getData bug
        }
    }
 
    return true;
}
 
bool OciData::getInteger(void* _pv, size_t* _size, SQL::DataType _dataType)
{
    __DCL_ASSERT(__dataType == SQLT_VNU); // OciField::init bug
 
    OCIError* pError = conn()->errorHandle();
    sword status = OCI_SUCCESS;
    if (*_size <= sizeof(int64_t /* 2025-02-03 월 int32_t */)) {
        status = ::OCINumberToInt(
                pError,                     // OCIError *err,
                (CONST OCINumber*)__value,   // CONST OCINumber *number,
                *_size,                 // uword rsl_length,
                _dataType == SQL::typeInteger ? // uword rsl_flag,
                    OCI_NUMBER_SIGNED : OCI_NUMBER_UNSIGNED,
                _pv                         // dvoid *rsl
                );
        if (status != OCI_SUCCESS) {
            __SET_ERROR(SQL::eServerError, status, pError);
            return false;
        }
    }
    else {
        *_size = sizeof(int64_t);
        __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
        return false;
    }
 
    return true;
}
 
bool OciData::getFloat(void* _pv, size_t* _size)
{
    __DCL_ASSERT(__dataType == SQLT_VNU); // OciField::init bug
 
    OCIError* pError = conn()->errorHandle();
    if (*_size <= sizeof(long double)) {
        // long double 의 storage size
        // MSVC/WIN32   8
        // GCC/Linux    12
        sword status = ::OCINumberToReal(
                pError,                     // OCIError *err,
                (CONST OCINumber*)__value,   // CONST OCINumber *number,
                *_size,                     // uword rsl_length,
                _pv                         // dvoid *rsl
                );
        if (status != OCI_SUCCESS) {
            __SET_ERROR(SQL::eServerError, status, pError);
            return false;
        }
    }
    else {
        *_size = sizeof(double);
        __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
        return false;
    }
 
    return true;
}
 
bool OciData::getNumericText(char* pBuf, size_t* _size)
{
    __DCL_ASSERT(__dataType == SQLT_VNU); // OciField::init bug
 
    OCIError* pError = conn()->errorHandle();
    ub4 n = 133;
    ByteBuffer* buf = ByteBuffer::create_e(n);
    sword status = ::OCINumberToText(
                pError,                     // OCIError *err,
                (CONST OCINumber*)__value,   // 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(
                pError,                     // OCIError *err,
                (CONST OCINumber*)__value,   // 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(SQL::eServerError, status, pError);
        return false;
    }
 
    buf->__dataLength = n;
    ByteString s = buf;
    buf->release();
 
    if (*_size < (size_t)s.length()) {
        *_size = (size_t)s.length();
        __SET_ERROR(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* _pv)
{
    OCISession* pSession = conn()->sessionHandle();
    OCIError* pError = conn()->errorHandle();
 
    sb2 nYear   = 0;
    ub1 nMonth  = 0;
    ub1 nDay    = 0;
    ub1 nHour   = 0;
    ub1 nMin    = 0;
    ub1 nSec    = 0;
    ub4 nFSec   = 0;
    
    _pv->tzoff = INT16_MIN;
 
    sword status = OCI_SUCCESS;
 
    switch(__dataType) {
    //  case SQLT_DAT :
        case SQLT_ODT: {
            OCIDateGetDate(
                    (CONST OCIDate*)__value,
                    &nYear,
                    &nMonth,
                    &nDay
                    );
            OCIDateGetTime(
                    (CONST OCIDate*)__value,
                    &nHour,
                    &nMin,
                    &nSec
                    );
            break;
        }
        case SQLT_TIMESTAMP :
        case SQLT_TIMESTAMP_TZ :
        case SQLT_TIMESTAMP_LTZ: {
            status = ::OCIDateTimeGetDate(
                    pSession,               // dvoid *hndl,
                    pError,                 // OCIError *err,
                    *(CONST OCIDateTime**)__value,   // CONST OCIDateTime *datetime,
                    &nYear,                 // sb2 *year,
                    &nMonth,                // ub1 *month,
                    &nDay                   // ub1 *day 
                    );
            if (status == OCI_SUCCESS)
                status = ::OCIDateTimeGetTime(
                        pSession,               // dvoid *hndl,
                        pError,                 // OCIError *err,
                        *(OCIDateTime**)__value, // OCIDateTime *datetime,
                        &nHour,                 // ub1 *hour,
                        &nMin,                  // ub1 *min,
                        &nSec,                  // ub1 *sec,
                        &nFSec                  // ub4 *fsec
                        );
            if (status == OCI_SUCCESS && __dataType != SQLT_TIMESTAMP) {
                sb1 tzHour = 0;
                sb1 tzMin = 0;
 
                status = ::OCIDateTimeGetTimeZoneOffset(
                        pSession,               // dvoid *hndl,
                        pError,                 // OCIError *err,
                        *(CONST OCIDateTime**)__value,   // CONST OCIDateTime *datetime,
                        &tzHour,                // sb1 *hour,
                        &tzMin                  // sb1 *min,
                        );
                if (status != OCI_SUCCESS) {
                    __SET_ERROR(SQL::eServerError, status, pError);
                    return false;
                }
                //  __DCL_TRACE2_N("TZ : %+03d:%02d\n", hour, min);
                _pv->tzoff = tzHour * 60 + tzMin;
            }
            break;
        }
        default: {
            __DCL_ASSERT(false);    // OciField::init bug
        }
    }
 
    _pv->year = nYear;
    _pv->month = nMonth;
    _pv->day = nDay;
    _pv->hour = nHour;
    _pv->min = nMin;
    _pv->sec = nSec;
    _pv->frac = nFSec;
 
    return true;
}
 
bool OciData::getInterval(SQL::Interval* _pv)
{
    OCISession* pSession = conn()->sessionHandle();
    OCIError* pError = conn()->errorHandle();
 
    sb4 nYear = 0;
    sb4 nMonth = 0;
    sb4 nDay = 0;
    sb4 nHour = 0;
    sb4 nMin = 0;
    sb4 nSec = 0;
    sb4 nFSec = 0;
    sword status = OCI_SUCCESS;
 
    switch(__dataType) {
        case SQLT_INTERVAL_YM :
            status = OCIIntervalGetYearMonth(
                    pSession,       // dvoid *hndl,
                    pError,         // OCIError *err,
                    &nYear,         // sb4 *yr,
                    &nMonth,        // sb4 *mnth,
                    *(CONST OCIInterval**)__value    // CONST OCIInterval *interval
                    );
            break;
        case SQLT_INTERVAL_DS :
            status = OCIIntervalGetDaySecond(
                    pSession,       // dvoid *hndl,
                    pError,         // OCIError *err,
                    &nDay,          // sb4 *dy,
                    &nHour,         // sb4 *hr,
                    &nMin,          // sb4 *mm,
                    &nSec,          // sb4 *ss,
                    &nFSec,         // sb4 *fsec,
                    *(CONST OCIInterval**)__value    // CONST OCIInterval *interval
                    );
            break;
        default :
            __DCL_ASSERT(false);    // OciField::init bug
    }
 
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, pError);
        return false;
    }
 
    _pv->years = nYear;
    _pv->months = nMonth;
    _pv->days = nDay;
    _pv->hours = nHour;
    _pv->mins = nMin;
    _pv->secs = nSec;
    _pv->fracs = nFSec;
    return true;
}
 
inline size_t __MIN(size_t x, size_t y)
{
    return x < y ? x : y;
}
 
bool OciData::getBytes(byte_t* _pv, size_t* _size)
{
    switch(__dataType) {
        case SQLT_RDD: {
            if (*_size < __dataSize) {
                *_size = __dataSize;
                __SET_ERROR(SQL::eInvalidBufferSize, 0, NULL);
                return false;
            }
        }
        case SQLT_CHR :
        case SQLT_AFC :
        case SQLT_BIN :
        case SQLT_LNG :
        case SQLT_LBI: {
            size_t nTotalSize = __MIN(__dataSize, *_size);
            size_t nTotalCopy = 0;
            if (nTotalSize) {
                size_t nCopy = 0;
                if (__bytesOutput) {
                    nCopy = __MIN(nTotalSize - nTotalCopy, __bytesOutput->size());
                    if (nCopy) {
                        memcpy(_pv, __bytesOutput->data(), nCopy);
                        nTotalCopy = nCopy;
                    }
                }
 
                nCopy = __MIN(nTotalSize - nTotalCopy, __callbackActualLength);
                if (nCopy) {
                    memcpy(_pv + nTotalCopy, __value, nCopy);
                    nTotalCopy += nCopy;
                }
 
                if (nTotalCopy < *_size)
                    *(_pv + nTotalCopy) = '\0';
            }
            *_size = nTotalCopy;
            break;
        }
        case SQLT_CLOB:
        case SQLT_BLOB:
        case SQLT_CFILE:
        case SQLT_BFILE: {
            if (*_size && __dataSize)
                return getBytesFromLob(_pv, _size);
            else
                *_size = 0;
            break;
        }
        default: {
            __DCL_ASSERT(false);    // OciField::init bug
        }
    }
 
    return true;
}
 
bool OciData::writeTo(OutputStream* pOutput, size_t* _size)
{
    switch(__dataType) {
        case SQLT_RDD :
        case SQLT_CHR :
        case SQLT_AFC :
        case SQLT_BIN :
        case SQLT_LNG :
        case SQLT_LBI: {
            try {
                size_t nTotalSize = __MIN(__dataSize, *_size);
                size_t nTotalWritten = 0;
                if (nTotalSize) {
                    size_t nWrite = 0;
                    if (__bytesOutput) {
                        nWrite = __MIN(nTotalSize - nTotalWritten, __bytesOutput->size());
                        if (nWrite) {
                            pOutput->write(__bytesOutput->data(), nWrite);
                            nTotalWritten += nWrite;
                        }
                    }
 
                    nWrite = __MIN(nTotalSize - nTotalWritten, __callbackActualLength);
                    if (nWrite) {
                        pOutput->write(__value, nWrite);
                        nTotalWritten += nWrite;
                    }
                }
 
                *_size = nTotalWritten;
            }
            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(pOutput, _size);
            else
                *_size = 0;
            break;
        }
        default: {
            __DCL_ASSERT(false);    // OciField::init bug
        }
    }
 
    return true;
}
 
bool OciData::getBytesFromLob(byte_t* _pbuf, size_t* _size)
{
    __DCL_ASSERT(__dataType == SQLT_CLOB
            || __dataType == SQLT_BLOB
            || __dataType == SQLT_BFILE
            || __dataType == SQLT_CFILE
            );
 
    OCISvcCtx*  pSvcCtx = conn()->svcctxHandle();
    OCIError*   pError = conn()->errorHandle();
    sword status = OCI_SUCCESS;
    if (__descType == OCI_DTYPE_FILE) {
        status = ::OCILobFileOpen(
                pSvcCtx,
                pError,
                *(OCILobLocator**)__value,
                OCI_FILE_READONLY
                );
        if (status != OCI_SUCCESS) {
            __SET_ERROR(SQL::eServerError, status, pError);
            return false;
        }
    }
 
    bool bResult = true;
    size_t nTotalRead = 0;
    ub4 nRead = 0;
    while(nTotalRead < *_size) {
        nRead = *_size - nTotalRead;
        status = ::OCILobRead(
                pSvcCtx,
                pError,
                *((OCILobLocator**)__value),
                &nRead,
                1 + nTotalRead,     // offset
                _pbuf,              // bufp,
                nRead,              // bufl,
                NULL,               // ctxp
                (OCICallbackLobRead)NULL,
                0,
                SQLCS_IMPLICIT);
        if (status == OCI_ERROR) {
            __SET_ERROR(SQL::eServerError, status, pError);
            bResult = false;
            break;
        }
        
        // OCI_SUCCESS, OCI_NEED_DATA
        if (nRead) {
            nTotalRead += nRead;
            _pbuf += nRead;
        }
        else
            break;  // done
        
//      if (status != OCI_NEED_DATA)
//          break;
    }
 
    if (__descType == OCI_DTYPE_FILE) {
        if (bResult) {
            status = ::OCILobFileClose(
                    pSvcCtx,
                    pError,
                    *(OCILobLocator**)__value);
            if (status != OCI_SUCCESS) {
                __SET_ERROR(SQL::eServerError, status, pError);
                return false;
            }
        }
        else {
            // 이전에 에러가 발생했다. Close 만 시킨다.
            status = ::OCILobFileClose(
                        pSvcCtx,
                        conn()->errorHandle2(),
                        *(OCILobLocator**)__value);
            if (status != OCI_SUCCESS) {
                __DCL_TRACE0(__T("Warning - OCILobFileClose Fail!\n"));
            }
        }
    }
 
    if (*_size > nTotalRead)
        *(_pbuf + nTotalRead) = '\0';
 
    *_size = nTotalRead;
 
    return bResult;
}
 
bool OciData::writeToFromLob(OutputStream* pOutput, size_t* _size)
{
    __DCL_ASSERT(__dataType == SQLT_CLOB
            || __dataType == SQLT_BLOB
            || __dataType == SQLT_BFILE
            || __dataType == SQLT_CFILE
            );
 
    OCISvcCtx*  pSvcCtx = conn()->svcctxHandle();
    OCIError*   pError = conn()->errorHandle();
    sword status = OCI_SUCCESS;
    if (__descType == OCI_DTYPE_FILE) {
        status = ::OCILobFileOpen(
                pSvcCtx,
                pError,
                *(OCILobLocator**)__value,
                OCI_FILE_READONLY
                );
        if (status != OCI_SUCCESS) {
            __SET_ERROR(SQL::eServerError, status, pError);
            return false;
        }
    }
 
    bool bResult = true;
    size_t nTotalRead = 0;
    ub4 nRead = 0;
    char buf[4096];
    while(nTotalRead < *_size) {
        nRead = __MIN(*_size - nTotalRead, sizeof(buf));
        status = ::OCILobRead(
                pSvcCtx,
                pError,
                *((OCILobLocator**)__value),
                &nRead,
                1 + nTotalRead,     // offset
                buf,             // bufp
                nRead,              // bufl
                NULL,               // ctxp
                (OCICallbackLobRead)NULL,
                0,
                SQLCS_IMPLICIT);
        if (status == OCI_ERROR) {
            __SET_ERROR(SQL::eServerError, status, pError);
            bResult = false;
            break;
        }
 
        if (nRead) {
            try {
                pOutput->write(buf, nRead);
            }
            catch(IOException* e) {
                e->destroy();
                bResult = false;
                break;
            }
 
            nTotalRead += nRead;
        }
        else {
            break;  // done
        }
 
//      if (status != OCI_NEED_DATA)
//          break;
    }
 
    if (__descType == OCI_DTYPE_FILE) {
        if (bResult) {
            status = ::OCILobFileClose(
                    pSvcCtx,
                    pError,
                    *(OCILobLocator**)__value);
            if (status != OCI_SUCCESS) {
                __SET_ERROR(SQL::eServerError, status, pError);
                return false;
            }
        }
        else {
            // 이전에 에러가 발생했다. Close 만 시킨다.
            status = ::OCILobFileClose(
                    pSvcCtx,
                    conn()->errorHandle2(),
                    *(OCILobLocator**)__value);
            if (status != OCI_SUCCESS) {
                __DCL_TRACE0(__T("Warning - OCILobFileClose Fail!\n"));
            }
        }
    }
 
    *_size = nTotalRead;
    return bResult;
}
 
//#ifdef __DCL_DEBUG
//#define SQLTYPE_NAME(_dataType, name) case _dataType : return #_dataType "-" name
//#else
#define SQLTYPE_NAME(_dataType, name) case _dataType : return L ## name
//#endif
 
const wchar_t* OciData::dataTypeName(ub2 _dataType)
{
    switch(_dataType) {
        SQLTYPE_NAME(SQLT_NUM, "NUMBER");
        SQLTYPE_NAME(SQLT_VNU, "NUMBER");   // for OciParam
        SQLTYPE_NAME(SQLT_DAT, "DATE");
        SQLTYPE_NAME(SQLT_ODT, "DATE");     // for OciParam
        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";
}
 
__DCL_END_NAMESPACE