OciQuery.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <oci.h>
 
#if defined(_AIX) || defined(__sun__)
    #include <alloca.h>
#endif
#include <stdlib.h>     // malloc, free, alloca
#include <string.h>     // memset
 
#include <dcl/Object.h>
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/size_t.h>
#include <dcl/SQLCore.h>
 
#include "OciConnection.h"
#include "OciQuery.h"
#include "OciField.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
#define __DCL_TRACE5_N  __DCL_TRACE5
#define __DCL_TRACE6_N  __DCL_TRACE6
#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)
#define __DCL_TRACE5_N(fmt, arg1, arg2, arg3, arg4, arg5)
#define __DCL_TRACE6_N(fmt, arg1, arg2, arg3, arg4, arg5, arg6)
#endif
 
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/sql/OciQuery.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#define __SET_ERROR_HANDLE(_error, _status, _OCIError) \
    conn()->setErrorHandle(_error, _status, _OCIError, \
            true, __THIS_FILE__, __LINE__)
#define __SET_ERROR_NORESET(_error, _status, _OCIError) \
    conn()->setErrorHandle(_error, _status, _OCIError, \
            false, __THIS_FILE__, __LINE__)
#define __SET_ERROR_MSG(_msg) \
    conn()->setErrorMessage(_msg, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(OciQuery, SQL::Query)
 
OciQuery::OciQuery(OciConnection* _connHandle)
    : Query(_connHandle)
{
    Query::__placeholder = L':';
 
    __stmt = NULL;
    __stmtType = __OCI_STMT_TYPE_UNKNOWN;
 
    __fieldsBuffer = NULL;
 
    __params = NULL;
    __fields = NULL;
}
 
OciQuery::~OciQuery()
{
#ifdef __DCL_DEBUG
    if (!reset()) {
        char buf[256];
        size_t buflen = sizeof(buf) - 1;
        bool b = conn()->__getErrorMessage(buf, &buflen);
        buf[b ? buflen : 0] = '\0';
        __DCL_TRACE1(L"Warning! Query reset error! %hs\n", buf);
    }
#else
    (void)reset();
#endif
}
 
void OciQuery::__destroy()
{
    delete this;
}
 
bool OciQuery::reset()
{
    Query::__eof = true;
    Query::__affectedRows = -1;
    __stmtType = __OCI_STMT_TYPE_UNKNOWN;
 
    if (__fields) {
        __DCL_ASSERT(Query::__fieldCount > 0);
        delete[] __fields;
        __fields = NULL;
        Query::__fieldCount = 0;
    }
 
    if (__params) {
        __DCL_ASSERT(Query::__paramCount > 0);
        delete[] __params;
        __params = NULL;
        Query::__paramCount = 0;
    }
 
    if (__fieldsBuffer) {
        free(__fieldsBuffer);
        __fieldsBuffer = NULL;
    }
 
    if (__stmt) {
        sword status = OCIStmtRelease(
            __stmt,                   // OCIStmt *stmthp
            conn()->errorHandle(),  // OCIError *errhp
            NULL,                   // const OraText *key
            0,                      // ub4 keylen
            OCI_DEFAULT             // ub4 mode
        );
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
            return false;
        }
        __stmt = NULL;
    }
 
    return true;
}
 
bool OciQuery::initParams(size_t _paramCount)
{
    __DCL_ASSERT((__stmt != NULL)
        && (_paramCount > 0)
        && (Query::__paramCount == 0)
        && (__params == NULL)
    );
 
#if defined(__DCL_DEBUG) && 1
    ub4 bindCount = 0;
    ub4 size = sizeof(bindCount);
    sword status = OCIAttrGet(
        __stmt,                       // const void *trgthndlp
        OCI_HTYPE_STMT,             // ub4 trghndltyp
        &bindCount,                 // void *attributep
        &size,                      // ub4 *sizep
        OCI_ATTR_BIND_COUNT,        // ub4 attrtype
        conn()->errorHandle()       // OCIError *errhp
    );
    __DCL_ASSERT(size == sizeof(bindCount));
    if (status != OCI_SUCCESS) {
        __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
        return false;
    }
    __DCL_ASSERT(bindCount == _paramCount);
#endif
 
    Query::__paramCount = _paramCount;
    __params = new OciParam[Query::__paramCount];
    if (__params == NULL) {
        __SET_ERROR_HANDLE(SQL::eOutOfMemory, 0, NULL);
        return false;
    }
 
    for(ub4 i = 0; i < Query::__paramCount; i++) {
        if (!__params[i].init(this, i + 1))
            return false;
    }
 
    return true;
}
 
typedef struct __TYPESIZE {
    ub2 sqlt;
    ub4 buflen;
} TYPESIZE;
 
bool OciQuery::initFields()
{
    __DCL_ASSERT((__stmt != NULL)
        && (Query::__fieldCount == 0)
        && (__fields == NULL)
        && (__fieldsBuffer == NULL)
    );
 
    ub4 fieldCount = 0;
    ub4 size = sizeof(fieldCount);
    sword status = OCIAttrGet(
        __stmt,                       // const void *trgthndlp
        OCI_HTYPE_STMT,             // ub4 trghndltyp
        &fieldCount,                // void *attributep
        &size,                      // ub4 *sizep
        OCI_ATTR_PARAM_COUNT,       // ub4 attrtype
        conn()->errorHandle()       // OCIError *errhp
    );
    __DCL_ASSERT(size == sizeof(fieldCount));
    if (status != OCI_SUCCESS) {
        __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
        return false;
    }
 
    TYPESIZE* ts = (TYPESIZE*)alloca(sizeof(TYPESIZE) * fieldCount);
    for (ub4 i = 0; i < fieldCount; i++) {
        OCIParam* param = NULL;
        status = OCIParamGet(
            __stmt,                   // const void *hndlp
            OCI_HTYPE_STMT,         // ub4 htype
            conn()->errorHandle(),  // OCIError *errhp
            (dvoid**)&param,        // void **parmdpp
            i + 1                   // ub4 pos
        );
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
            return false;
        }
 
        ub2 sqlt = 0;
        size = sizeof(sqlt);
        status = OCIAttrGet(
            param,                  // const void *trgthndlp
            OCI_DTYPE_PARAM,        // ub4 trghndltyp
            &sqlt,                  // void *attributep
            &size,                  // ub4 *sizep
            OCI_ATTR_DATA_TYPE,     // ub4 attrtype
            conn()->errorHandle()   // OCIError *errhp
        );
        __DCL_ASSERT(size == sizeof(sqlt));
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
            return false;
        }
 
        // ub2 dataSize 이었었는데, Assert failed 되었다.
        // 반환값의 범위는 0 ~ 4000이다.
        ub4 dataSize = 0;
        size = sizeof(dataSize);
        status = OCIAttrGet(
            param,                  // const void *trgthndlp
            OCI_DTYPE_PARAM,        // ub4 trghndltyp
            &dataSize,              // void *attributep
            &size,                  // ub4 *sizep
            OCI_ATTR_DATA_SIZE,     // ub4 attrtype
            conn()->errorHandle()   // OCIError *errhp
        );
        __DCL_ASSERT(size == sizeof(dataSize));
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
            return false;
        }
 
        ts[i].sqlt = sqlt;
        ts[i].buflen = OciData::__TYPE_SIZE(ts[i].sqlt, dataSize);
        __DCL_TRACE5_N(L"Field [%2d]   size [%6d %6d] type [%3d %ls]\n",
            i + 1, dataSize, ts[i].buflen,
            ts[i].sqlt, OciData::__TYPE_NAME(ts[i].sqlt)
        );
    }
 
    // __fieldsBuffer에 적용할, 레코드 버퍼 크기를 계산한다.
    size_t offset = 0;
    for (ub4 i = 0; i < fieldCount; i++) {
        offset = OciData::__TYPE_ALIGN(offset, ts[i].sqlt);
        __DCL_TRACE5_N(L"Field [%2d] offset [%6zd %6d] type [%3d %ls]\n",
            i + 1, offset, ts[i].buflen, ts[i].sqlt, OciData::__TYPE_NAME(ts[i].sqlt));
        offset += ts[i].buflen;
    }
 
    __DCL_TRACE1_N(L"outBuffer [%zd]\n", offset);
    // Oracle에서 __TYPE_SIZE(field) == 0인 경우는 없다.
    __fieldsBuffer = malloc(offset);
    if (__fieldsBuffer == NULL) {
        __SET_ERROR_HANDLE(SQL::eOutOfMemory, 0, NULL);
        return false;
    }
 
    Query::__fieldCount = fieldCount;
    __fields = new OciField[Query::__fieldCount];
    if (__fields == NULL) {
        __SET_ERROR_HANDLE(SQL::eOutOfMemory, 0, NULL);
        return false;
    }
 
    offset = 0;
    for (ub4 i = 0; i < Query::__fieldCount; i++) {
        offset = OciData::__TYPE_ALIGN(offset, ts[i].sqlt);
        char* buf = (char*)__fieldsBuffer + offset;
        //__DCL_TRACE3_N(L"offset [%4zd %4d] [%p]\n", offset, ts[i].buflen, buf);
        if (!(__fields[i].init(this, i + 1, ts[i].sqlt,
            buf, ts[i].buflen))
        ) {
            return false;
        }
        offset += ts[i].buflen;
    }
 
    return true;
}
 
bool OciQuery::__prepare(
    const char* _sql, size_t _sqllen,
    size_t _paramCount
)
{
    if (!reset()) {
        return false;
    }
 
     sword status = OCIStmtPrepare2(
        conn()->svcHandle(),        // OCISvcCtx *svchp
        &__stmt,                  // OCIStmt **stmthp
        conn()->errorHandle(),      // OCIError *errhp
        (const text* )_sql,         // const OraText *stmttext
        (ub4)_sqllen,               // ub4 stmt_len
        NULL,                       // const OraText  *key
        0,                          // ub4 keylen
        OCI_NTV_SYNTAX,             // ub4 language
        OCI_DEFAULT                 // ub4 mode
    );
    if (status != OCI_SUCCESS) {
        __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
        return false;
    }
 
    ub4 size = sizeof(__stmtType);
    status = OCIAttrGet(
        __stmt,                       // const void *trgthndlp
        OCI_HTYPE_STMT,             // ub4 trghndltyp
        &__stmtType,              // void *attributep
        &size,                      // ub4 *sizep
        OCI_ATTR_STMT_TYPE,         // ub4 attrtype
        conn()->errorHandle()       // OCIError *errhp
    );
    __DCL_ASSERT(size == sizeof(__stmtType));
    if (status != OCI_SUCCESS) {
        __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
        return false;
    }
 
    if (_paramCount > 0) {
        if (!initParams(_paramCount))
            return false;
    }
 
    return true;
}
 
bool OciQuery::__execute()
{
    for(size_t i = 0; i < Query::__paramCount; i++) {
        if (!__params[i].doBind())
            return false;
    }
 
    sword status = OCIStmtExecute(
        conn()->svcHandle(),        // OCISvcCtx *svchp
        __stmt,                       // OCIStmt *stmtp
        conn()->errorHandle(),      // OCIError *errhp
        (__stmtType == OCI_STMT_SELECT) ? 0 : 1,  // ub4 iters
        0,                          // ub4 rowoff
        NULL,                       // const OCISnapshot *snap_in
        NULL,                       // OCISnapshot *snap_out
        OCI_DEFAULT                 // ub4 mode
    );
    if (status != OCI_SUCCESS) {
        __SET_ERROR_NORESET(SQL::eServerError, status, conn()->errorHandle());
        return false;
    }
 
    // OCI의 경우 stmt execute 후 fields를 결정할 수 있다.
    if (__stmtType == OCI_STMT_SELECT) {
        if (!initFields()) {
            return false;
        }
 
        Query::__eof = false;
    }
 
    for(size_t i = 0; i < Query::__paramCount; i++) {
        if (!__params[i].onAfterExecute()) {
            return false;
        }
    }
 
    if (__stmtType == OCI_STMT_UPDATE
        || __stmtType == OCI_STMT_INSERT
        || __stmtType == OCI_STMT_DELETE) {
 
        ub8 rowCount = 0;
        ub4 size = sizeof(rowCount);
        status = OCIAttrGet(
            __stmt,                   // const void *trgthndlp
            OCI_HTYPE_STMT,         // ub4 trghndltyp
            &rowCount,              // void *attributep
            &size,                  // ub4 *sizep
            OCI_ATTR_UB8_ROW_COUNT, // ub4 attrtype
            conn()->errorHandle()   // OCIError *errhp
        );
        __DCL_ASSERT(size == sizeof(rowCount));
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, conn()->errorHandle());
            return false;
        }
        Query::__affectedRows = rowCount;
    }
    return true;
}
 
bool OciQuery::__fetch()
{
    __DCL_ASSERT(!Query::__eof);
    sword status = OCIStmtFetch2(
        __stmt,                       // OCIStmt *stmthp
        conn()->errorHandle(),      // OCIError *errhp
        1,                          // ub4 nrows
        OCI_FETCH_NEXT,             // ub2 orientation
        0,                          // sb4 fetchOffset
        OCI_DEFAULT                 // ub4 mode
    );
    switch (status) {
        case OCI_NO_DATA: {
            Query::__eof = true;
            return true;
        }
        case OCI_SUCCESS_WITH_INFO: {
            // 2026-02-28
            // 19.30.0.0.0 버전 AIX에서 처음 발견되었다.
            // 구체적인 내용을 확인해야 한다.
            // 아마도 ODBC의 경우와 유사할 것으로 추정된다.
        }
        case OCI_SUCCESS: {
            for (size_t i = 0; i < Query::__fieldCount; i++) {
                if (!__fields[i].onAfterFetch())
                    return false;
            }
            return true;
        }
        default: {
            ;
        }
    }
 
    __SET_ERROR_NORESET(SQL::eServerError, status, conn()->errorHandle());
    return false;
}
 
bool OciQuery::__getField(size_t _index, SQL::Field** _fieldHandleOut)
{
    __DCL_ASSERT(Query::__fieldCount > 0);
    __DCL_ASSERT((0 <= _index) && (_index < Query::__fieldCount));
    *_fieldHandleOut = &__fields[_index];
    return true;
}
 
bool OciQuery::__getParam(size_t _index, SQL::Param** _paramHandleOut)
{
    __DCL_ASSERT(Query::__paramCount > 0);
    __DCL_ASSERT((0 <= _index) && (_index < Query::__paramCount));
    *_paramHandleOut = &__params[_index];
    return true;
}
 
__DCL_END_NAMESPACE