OciField.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/OutputStream.h>
#include <dcl/BytesOutputStream.h>
#include <dcl/Charset.h>
#include <dcl/SQLCore.h>
 
#include "OciConnection.h"
#include "OciQuery.h"
#include "OciField.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/OciField.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#undef __SET_ERROR
#define __SET_ERROR(_error, status, pError) \
    conn()->setErrorStatus(_error, status, pError, \
            true, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(OciField, SQL::Field)
 
OciField::OciField()
    : Field(NULL)
{
    __define = NULL;
    __dataType = 0;
 
    __bufferSize = 0;
}
 
OciField::~OciField()
{
    if (OciData::__descType) {
        __DCL_VERIFY(
            conn()->OCIDescriptorFree(
                *(void**)OciData::__value,
                OciData::__descType
                ) == OCI_SUCCESS);
    }
 
    if (OciData::__value) {
        free(OciData::__value);
//      OciData::__value = NULL;
    }
}
 
bool OciField::init(SQL::Query* _queryHandle, size_t _position)
{
    __DCL_ASSERT(_queryHandle != NULL);
 
    Field::__queryHandle = _queryHandle;
    OciData::__queryHandle = (OciQuery*)_queryHandle;
    OciData::__position = _position; // 1, 2, 3, ...
 
    OciConnection* pConnection = conn();
    OCIError* pError = pConnection->errorHandle();
    OCIStmt* pStmt = query()->stmtHandle();
    sword status = OCI_SUCCESS;
 
    OCIParam* _param = NULL;
    status = ::OCIParamGet(
            pStmt, 
            OCI_HTYPE_STMT,
            pError,
            (dvoid**)&_param,
            OciData::__position);
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, pError);
        return false;
    }
 
    text* name = NULL;
    ub4  size = 0;
    status = ::OCIAttrGet(_param, OCI_DTYPE_PARAM,
            &name,
            &size,
            OCI_ATTR_NAME,
            pError);
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, pError);
        return false;
    }
 
    try {
        Field::__name = UTF8Decoder::decode((const char*)name, size);
    }
    catch (CharsetConvertException* _e) {
        __SET_ERROR(SQL::eServerError, status, pError);
        conn()->setErrorEx(UTF8Encoder::encode(_e->toStringAll()));
        _e->destroy();
        return false;
    }
    
    status = ::OCIAttrGet(_param, OCI_DTYPE_PARAM,
            &__dataType,
            NULL,
            OCI_ATTR_DATA_TYPE,
            pError);
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, pError);
        return false;
    }
 
    ub2 dataSize = 0;
    status = ::OCIAttrGet(_param, OCI_DTYPE_PARAM,
            &dataSize,
            NULL,
            OCI_ATTR_DATA_SIZE,
            pError);
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, pError);
        return false;
    }
 
    sb2 precision;
    sb1 scale;
    status = ::OCIAttrGet(_param, OCI_DTYPE_PARAM,
        &precision,
        NULL,
        OCI_ATTR_PRECISION,
        pError);
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, pError);
        return false;
    }
    status = ::OCIAttrGet(_param, OCI_DTYPE_PARAM,
        &scale,
        NULL,
        OCI_ATTR_SCALE,
        pError);
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, pError);
        return false;
    }
    Field::__precision = precision;
    Field::__scale = scale;
    __DCL_TRACE3_N(L"[%ls] precision[%d] scale[%d]\n", __name.data(), precision, scale);
 
    __DCL_ASSERT(OciData::__value == NULL);
    __bufferSize = 0;
    OciData::__valueSize = 0;
    OciData::__dynamicMode = OCI_DEFAULT;
    switch(__dataType) {
        case SQLT_NUM: {
            __bufferSize = OciData::__valueSize = sizeof(OCINumber);
            OciData::__dataType = SQLT_VNU;
            Field::__dataType = SQL::typeNumeric;
            OciData::__maxDataSize = 132; // between 1.0 x 10^-130 
            // and 9.9...9 x 10^125
            // (38 nines followed by 88 zeroes)
            break;
        }
        case SQLT_DAT: {
            __bufferSize = OciData::__valueSize = sizeof(OCIDate);
            OciData::__dataType = SQLT_ODT;
            Field::__dataType = SQL::typeTimeStamp;
            OciData::__maxDataSize = sizeof(SQL::TimeStamp);
            break;
        }
        case SQLT_TIMESTAMP: {
            __bufferSize = OciData::__valueSize = sizeof(OCIDateTime*);
            OciData::__descType = OCI_DTYPE_TIMESTAMP;
            OciData::__dataType = __dataType;
            Field::__dataType = SQL::typeTimeStamp;
            OciData::__maxDataSize = sizeof(SQL::TimeStamp);
            break;
        }
        case SQLT_TIMESTAMP_TZ: {
            __bufferSize = OciData::__valueSize = sizeof(OCIDateTime*);
            OciData::__descType = OCI_DTYPE_TIMESTAMP_TZ;
            OciData::__dataType = __dataType;
            Field::__dataType = SQL::typeTimeStampTz;
            OciData::__maxDataSize = sizeof(SQL::TimeStamp);
            break;
        }
        case SQLT_TIMESTAMP_LTZ: {
            __bufferSize = OciData::__valueSize = sizeof(OCIDateTime*);
            OciData::__descType = OCI_DTYPE_TIMESTAMP_LTZ;
            OciData::__dataType = __dataType;
            Field::__dataType = SQL::typeTimeStampTz;
            OciData::__maxDataSize = sizeof(SQL::TimeStamp);
            break;
        }
        case SQLT_INTERVAL_YM: {
            __bufferSize = OciData::__valueSize = sizeof(OCIInterval*);
            OciData::__descType = OCI_DTYPE_INTERVAL_YM;
            OciData::__dataType = __dataType;
            Field::__dataType = SQL::typeIntervalYm;
            OciData::__maxDataSize = sizeof(SQL::Interval);
            break;
        }
        case SQLT_INTERVAL_DS: {
            __bufferSize = OciData::__valueSize = sizeof(OCIInterval*);
            OciData::__descType = OCI_DTYPE_INTERVAL_DS;
            OciData::__dataType = __dataType;
            Field::__dataType = SQL::typeIntervalDs;
            OciData::__maxDataSize = sizeof(SQL::Interval);
            break;
        }
        case SQLT_CHR: {        // VARCHAR2, NVARCHAR2
            __bufferSize = OciData::__valueSize = dataSize;
            OciData::__dataType = __dataType;
            Field::__dataType = SQL::typeText;
            // OciData::__maxDataSize = 4000;
            OciData::__maxDataSize = dataSize;
            break;
        }
        case SQLT_AFC: {        // CHAR, NCHAR, ANSI Fixed Char
            __bufferSize = OciData::__valueSize = dataSize;
            OciData::__dataType = __dataType;
            Field::__dataType = SQL::typeText;
            // OciData::__maxDataSize = 2000;
            OciData::__maxDataSize = dataSize;
            break;
        }
        case SQLT_BIN: {
            // OciData::__dynamicMode = OCI_DYNAMIC_FETCH;
            __bufferSize = OciData::__valueSize = dataSize;
            OciData::__dataType = __dataType;
            Field::__dataType = SQL::typeBinary;
            // OciData::__maxDataSize = 2000;
            OciData::__maxDataSize = dataSize;
            break;
        }
        case SQLT_RDD: {
            OciData::__dynamicMode = OCI_DYNAMIC_FETCH;
            // oci.h
            //#define OCI_ROWID_LEN 23
            // ROWID를 CHR로 받으면 base64로 인코딩되어 리턴한다.
            // 초기 버퍼를 3의 배수로 정한다.
            __bufferSize = 24;
            OciData::__valueSize = 4000;
            OciData::__dataType = SQLT_CHR;
            Field::__dataType = SQL::typeText;
            OciData::__maxDataSize = 4000;
            break;
        }
        case SQLT_LNG: {
            OciData::__dynamicMode = OCI_DYNAMIC_FETCH;
            __bufferSize = DYNAMIC_BUFFER_SIZE;
            OciData::__valueSize = INT32_MAX;
            OciData::__dataType = __dataType;
            Field::__dataType = SQL::typeLongText;
            OciData::__maxDataSize = INT32_MAX;      // 2^31 - 1
            break;
        }
        case SQLT_LBI: {
            OciData::__dynamicMode = OCI_DYNAMIC_FETCH;
            __bufferSize = DYNAMIC_BUFFER_SIZE;
            OciData::__valueSize = INT32_MAX;
            OciData::__dataType = __dataType;
            Field::__dataType = SQL::typeLongBinary;
            OciData::__maxDataSize = INT32_MAX;      // 2^31 - 1
            break;
        }
        case SQLT_CLOB :
        case SQLT_CFILE: {
            __bufferSize = OciData::__valueSize = sizeof(OCILobLocator*);
            if (__dataType == SQLT_CFILE)
                OciData::__descType = OCI_DTYPE_FILE;
            else
                OciData::__descType = OCI_DTYPE_LOB;
            OciData::__dataType = __dataType;
            Field::__dataType = SQL::typeClob;
            OciData::__maxDataSize = UINT32_MAX;
            break;
        }
        case SQLT_BLOB :
        case SQLT_BFILE: {
            __bufferSize = OciData::__valueSize = sizeof(OCILobLocator*);
            if (__dataType == SQLT_BFILE)
                OciData::__descType = OCI_DTYPE_FILE;
            else
                OciData::__descType = OCI_DTYPE_LOB;
            OciData::__dataType = __dataType;
            Field::__dataType = SQL::typeBlob;
            OciData::__maxDataSize = UINT32_MAX;
            break;
        }
        default: {
#ifdef __DCL_DEBUG
            __DCL_ASSERT(false);
#else
            __SET_ERROR(SQL::eNotSupportDataType, 0, NULL);
            return false;
#endif
        }
    }
 
    OciData::__actualLength = __bufferSize;
    OciData::__value = malloc(__bufferSize);
    if (!OciData::__value) {
        __SET_ERROR(SQL::eOutOfMemory, 0, NULL);
        return false;
    }
 
    if (OciData::__descType) {
        status = pConnection->OCIDescriptorAlloc(
                (dvoid**)OciData::__value,
                OciData::__descType
                );
        if (status != OCI_SUCCESS) {
            __SET_ERROR(SQL::eServerError, status, NULL);
            return false;
        }
    }
 
    if (OciData::__dynamicMode == OCI_DYNAMIC_FETCH) {
        status = ::OCIDefineByPos(
                pStmt,                  // OCIStmt *stmtp,
                &__define,              // OCIDefine **defnpp,
                pError,                 // OCIError *errhp,
                OciData::__position, // ub4 position,
                NULL,                   // dvoid *valuep,
                OciData::__valueSize,   // sb4 value_sz,
                OciData::__dataType, // ub2 dty,
                NULL,                   // dvoid *indp,
                NULL,                   // ub2 *rlenp,
                NULL,                   // ub2 *rcodep,
                OCI_DYNAMIC_FETCH       // ub4 mode 
                );
        if (status == OCI_SUCCESS)
            status = OCIDefineDynamic(
                    __define,           // OCIDefine *defnp,
                    pError,             // OCIError *errhp,
                    this,               // dvoid *octxp,
                    CallbackDefine
                    );
    }
    else {
        status = ::OCIDefineByPos(
                pStmt,
                &__define,
                pError,
                OciData::__position,
                OciData::__value,
                OciData::__valueSize,
                OciData::__dataType,
                &(OciData::__indicator),
                &(OciData::__actualLength),
                &(OciData::__returnCode),
                OCI_DEFAULT
                );
    }
 
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, pError);
        return false;
    }
 
    return true;
}
 
bool OciField::isNull() const
{ 
    return OciData::__indicator == -1; 
}
 
const wchar_t* OciField::serverDataTypeName() const
{
    return OciData::dataTypeName(__dataType);
}
 
bool OciField::__getDataSize(size_t* _size, bool _maxSize)
{
    return OciData::getDataSize(_size, _maxSize);
}
 
bool OciField::__getData(
        void*           _pv,
        size_t*         _size,
        SQL::DataType  _dataType
        )
{
    return OciData::getData(_pv, _size, _dataType);
}
 
sb4 OciField::CallbackDefine(
        dvoid       *octxp,
        OCIDefine   *defnp,
        ub4         iter,
        dvoid       **bufpp,
        ub4         **alenpp,
        ub1         *piecep,
        dvoid       **indpp,
        ub2         **rcodep
        )
{
    return ((OciField*)octxp)->onCallbackDefine(
                defnp,
                iter,
                bufpp,
                alenpp,
                piecep,
                indpp,
                rcodep
                );
}
 
sb4 OciField::onCallbackDefine(
        OCIDefine   *pDefine,
        ub4         nIterator,
        dvoid       **ppvBuffer,
        ub4         **ppnActualLength,
        ub1         *pnPiece,
        dvoid       **ppvIndicator,
        ub2         **ppnReturnCode
        )
{
    __DCL_ASSERT(OciData::__dynamicMode == OCI_DYNAMIC_FETCH);
/*
#ifdef __DCL_DEBUG
    switch(*pnPiece)
    {
    case OCI_ONE_PIECE :
        __DCL_TRACE0_N("OCI_ONE_PIECE\n");
        break;
    case OCI_FIRST_PIECE :
        __DCL_TRACE0_N("OCI_FIRST_PIECE\n");
        break;
    case OCI_NEXT_PIECE :
        __DCL_TRACE0_N("OCI_NEXT_PIECE\n");
        break;
    case OCI_LAST_PIECE :
        __DCL_TRACE0_N("OCI_LAST_PIECE\n");
    }
#endif
*/
    if (*pnPiece == OCI_ONE_PIECE)
        *pnPiece = OCI_FIRST_PIECE;
 
    if (*pnPiece == OCI_FIRST_PIECE) {
        if (OciData::__bytesOutput)
            OciData::__bytesOutput->reset();
    }
    else {
        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(__value, OciData::__callbackActualLength);
        }
        catch(IOException* e) {
            conn()->setErrorEx(
                UTF8Encoder::encode(e->toStringAll())
            );
            e->destroy();
            return OCI_ERROR;
        }
    }
 
    OciData::__callbackActualLength = __bufferSize;
    *ppvBuffer = OciData::__value;
    *ppnActualLength = &(OciData::__callbackActualLength);
    *ppvIndicator = &(OciData::__indicator);
    *ppnReturnCode = &(OciData::__returnCode);
 
    return OCI_CONTINUE;
}
 
__DCL_END_NAMESPACE