OciConnection.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <oci.h>
 
#include <ctype.h>      // isspace
#include <string.h>     // strncpy, strlen
 
#include <dcl/Object.h>
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/Regex.h>
#include <dcl/SQLCore.h>
 
#include "OciConnection.h"
#include "OciQuery.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/OciConnection.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#define __SET_ERROR_HANDLE(_error, status, _OCIError) \
    setErrorHandle(_error, status, _OCIError, \
        true, __THIS_FILE__, __LINE__)
#define __SET_ERROR_MSG(_msg) \
    setErrorMessage(_msg, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(OciConnection, SQL::Connection)
 
OciConnection::OciConnection(const wchar_t* _serverTitle)
    : Connection(_serverTitle)
{
    Connection::__canTransact = true;
 
    __lastStatus = OCI_SUCCESS;
    __lastError = NULL;
 
    __env = NULL;
    __error = NULL;
    __error2 = NULL;
 
    __server = NULL;
    __svcctx = NULL;
    __session = NULL;
    __trans = NULL;
 
    __serverAttached = false;
    __sessionStarted = false;
}
 
OciConnection::~OciConnection()
{
    sword status = OCI_SUCCESS;
    if (__sessionStarted) {
        __DCL_TRACE0_N(L"Warning!! The connection was not closed\n");
        close();
    }
 
    if (__error) {
        status = OCIHandleFree(__error, OCI_HTYPE_ERROR);
        if (status != OCI_SUCCESS) {
            __DCL_TRACE0_N(L"OCIHandleFree Fail! : __error\n");
        }
        __error = NULL;
    }
 
    if (__env) {
        status = OCIHandleFree(__env, OCI_HTYPE_ENV);
        if (status != OCI_SUCCESS) {
            __DCL_TRACE0_N(L"OCIHandleFree Fail! : __env\n");
        }
        __env = NULL;
    }
}
 
void OciConnection::destroy()
{
    delete this;
}
 
/*
    _conns 에 가능한 property
        USER,
        PASSWORD,
        DATABASE,
        MODE
*/
 
bool OciConnection::__open(const char* _conns, size_t _connlen)
{
    ListedByteStringToByteStringMap map;
    Connection::splitConnStr(_conns, _connlen, map);
 
    ByteString _DATABASE = map["DATABASE"];
    ByteString _USER = map["USER"];
    ByteString _PASSWORD = map["PASSWORD"];
    ByteString _MODE = map["MODE"];
 
    ub4 operationMode = OCI_DEFAULT;
    if (!_MODE.isEmpty()) {
        if (!_MODE.compareNoCase("SYSDBA"))
            operationMode = OCI_SYSDBA;
        else if (!_MODE.compareNoCase("SYSOPER"))
            operationMode = OCI_SYSOPER;
        else {
            __SET_ERROR_HANDLE(SQL::eInvalidConnectionString, 0, NULL);
            return false;
        }
    }
 
    if (_USER.isEmpty()) {
        __SET_ERROR_HANDLE(SQL::eInvalidConnectionString, 0, NULL);
        return false;
    }
 
    for ( ; ; ) {
        sword status = OCI_SUCCESS;
        // __env, __error은 ~OciConnection에서 OCIHandleFree한다.
        // close후 다시 open할 수 있다.
        if (!__env) {
            status = OCIEnvCreate(
                &__env,                    // OCIEnv **envhpp
                OCI_ENV_NO_MUTEX        // ub4 mode
                    | OCI_THREADED | OCI_OBJECT,
                NULL,                   // const void *ctxp
                NULL,                   // const void *(*malocfp)
                NULL,                   // const void *(*ralocfp)
                NULL,                   // const void (*mfreefp)
                0,                      // size_t xtramemsz
                NULL                    // void **usrmempp
            );
            if (status != OCI_SUCCESS) {
                __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
                break;  // goto __on_error;
            }
        }
 
        if (!__error) {
            status = HandleAlloc((void**)&__error, OCI_HTYPE_ERROR);
            if (status != OCI_SUCCESS) {
                __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
                break;  // goto __on_error;
            }
        }
 
        status = HandleAlloc((void**)&__error2, OCI_HTYPE_ERROR);
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
            break;  // goto __on_error;
        }
 
        status = HandleAlloc((void**)&__server, OCI_HTYPE_SERVER);
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
            break;  // goto __on_error;
        }
 
        status = HandleAlloc((void**)&__svcctx, OCI_HTYPE_SVCCTX);
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
            break;  // goto __on_error;
        }
 
        status = HandleAlloc((void**)&__session, OCI_HTYPE_SESSION);
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
            break;  // goto __on_error;
        }
 
        status = HandleAlloc((void**)&__trans, OCI_HTYPE_TRANS);
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
            break;  // goto __on_error;;
        }
 
        status = OCIServerAttach(
            __server,                   // OCIServer *srvhp
            __error,                 // OCIError *errhp
            _DATABASE.isEmpty()         // const OraText *dblink
                ? NULL : (text*)_DATABASE.data(),
            _DATABASE.isEmpty()         // sb4 dblink_len
                ? 0 : (sb4) _DATABASE.length(),
            OCI_DEFAULT                 // ub4 mode
        );
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            break;  // goto __on_error;
        }
        __serverAttached = true;
 
#if defined(__DCL_DEBUG) && __TRACE_THIS
        char buf[256];
        status = OCINlsGetInfo(
            __env,                     // void* hndl
            __error,                 // OCIError *errhp
            (OraText*)buf,              // OraText *buf
            sizeof(buf),                // size_t buflen
            OCI_NLS_CHARACTER_SET       // ub2 item
        );
        if (status == OCI_SUCCESS) {
            __DCL_TRACE1_N(L"[%hs]\n", buf);
        }
        else {
            __DCL_TRACE1_N(L"[%d]\n", status);
        }
        status = OCINlsGetInfo(
            __env,                     // void* hndl
            __error,                 // OCIError *errhp
            (OraText*)buf,              // OraText *buf
            sizeof(buf),                // size_t buflen
            OCI_NLS_LANGUAGE            // ub2 item
        );
        if (status == OCI_SUCCESS) {
            __DCL_TRACE1_N(L"[%hs]\n", buf);
        }
        else {
            __DCL_TRACE1_N(L"[%d]\n", status);
        }
        status = OCINlsGetInfo(
            __env,                     // void* hndl
            __error,                 // OCIError *errhp
            (OraText*)buf,              // OraText *buf
            sizeof(buf),                // size_t buflen
            OCI_NLS_ABLANGUAGE          // ub2 item
        );
        if (status == OCI_SUCCESS) {
            __DCL_TRACE1_N(L"[%hs]\n", buf);
        }
        else {
            __DCL_TRACE1_N(L"[%d]\n", status);
        }
        status = OCINlsGetInfo(
            __env,                     // void* hndl
            __error,                 // OCIError *errhp
            (OraText*)buf,              // OraText *buf
            sizeof(buf),                // size_t buflen
            OCI_NLS_TERRITORY           // ub2 item
        );
        if (status == OCI_SUCCESS) {
            __DCL_TRACE1_N(L"[%hs]\n", buf);
        }
        else {
            __DCL_TRACE1_N(L"[%d]\n", status);
        }
#endif
 
        status = OCIAttrSet(
            __svcctx,                   // void *trgthndlp
            OCI_HTYPE_SVCCTX,           // ub4 trghndltyp
            __server,                   // void *attributep
            0,                          // ub4 size
            OCI_ATTR_SERVER,            // ub4 attrtype
            __error                      // OCIError *errhp
        );
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            break;  // goto __on_error;
        }
 
        status = OCIAttrSet(
            __session,                 // void *trgthndlp
            OCI_HTYPE_SESSION,          // ub4 trghndltyp
            (void*)_USER.data(),        // void *attributep
            (ub4) _USER.length(),       // ub4 size
            OCI_ATTR_USERNAME,          // ub4 attrtype
            __error                      // OCIError *errhp
        );
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            break;  // goto __on_error;
        }
 
        status = OCIAttrSet(
            __session,                 // void *trgthndlp
            OCI_HTYPE_SESSION,          // ub4 trghndltyp
            (void*)_PASSWORD.data(),    // void *attributep
            (ub4) _PASSWORD.length(),           // ub4 size
            OCI_ATTR_PASSWORD,          // ub4 attrtype
            __error                      // OCIError *errhp
        );
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            break;  // goto __on_error;
        }
 
        status = OCISessionBegin(
            __svcctx,                   // OCISvcCtx *svchp
            __error,                 // OCIError *errhp
            __session,                 // OCISession *usrhp
            OCI_CRED_RDBMS,             // ub4 credt
            operationMode               // ub4 mode
        );
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            break;  // goto __on_error;
        }
 
        __sessionStarted = true;
        status = OCIAttrSet(
            __svcctx,                   // void *trgthndlp
            OCI_HTYPE_SVCCTX,           // ub4 trghndltyp
            __server,                   // void *attributep
            0,                          // ub4 size
            OCI_ATTR_SERVER,            // ub4 attrtype
            __error                      // OCIError *errhp
        );
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            break;  // goto __on_error;
        }
 
        status = OCIAttrSet(
            __svcctx,                   // void *trgthndlp
            OCI_HTYPE_SVCCTX,           // ub4 trghndltyp
            (void*)__session,          // void *attributep
            0,                          // ub4 size
            OCI_ATTR_SESSION,           // ub4 attrtype
            __error                      // OCIError *errhp
        );
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            break;  // goto __on_error;
        }
 
        status = OCIAttrSet(
            __svcctx,                   // void *trgthndlp
            OCI_HTYPE_SVCCTX,           // ub4 trghndltyp
            __trans,                 // void *attributep
            0,                          // ub4 size
            OCI_ATTR_TRANS,             // ub4 attrtype
            __error                      // OCIError *errhp
        );
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            break;  // goto __on_error;
        }
 
        return true;
    }
 
// __on_error:
    closeHelper(false);
    return false;
}
 
bool OciConnection::__close()
{
    return closeHelper(true);
}
 
bool OciConnection::closeHelper(bool _normal)
{
    sword status = OCI_SUCCESS;
    OCIError* _OCIError = __error;
    bool r = true;
 
    if (!_normal) {
        // 이전에 오류가 있었다.
        // cleanup에서 __error2가 사용된다.
        _OCIError = __error2;
    }
 
    if (__sessionStarted) {
        status = OCISessionEnd(
            __svcctx,                   // OCISvcCtx *svchp
            _OCIError,                  // OCIError *errhp
            __session,                 // OCISession *usrhp
            OCI_DEFAULT                 // ub4 mode
        );
        if ((status != OCI_SUCCESS) && _normal) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            r = false;
        }
        __sessionStarted = false;
    }
 
    if (__serverAttached) {
        status = OCIServerDetach(
            __server,                   // OCIServer *srvhp
            _OCIError,                  // OCIError *errhp
            OCI_DEFAULT                 // ub4 mode
        );
        if ((status != OCI_SUCCESS) && _normal) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            r = false;
        }
        __serverAttached = false;
    }
 
    if (__trans) {
        status = OCIHandleFree(__trans, OCI_HTYPE_TRANS);
        if ((status != OCI_SUCCESS) && _normal) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            r = false;
        }
        __trans = NULL;
    }
 
    if (__session) {
        status = OCIHandleFree(__session, OCI_HTYPE_SESSION);
        if ((status != OCI_SUCCESS) && _normal) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            r = false;
        }
        __session = NULL;
    }
 
    if (__server) {
        status = OCIHandleFree(__server, OCI_HTYPE_SERVER);
        if ((status != OCI_SUCCESS) && _normal) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            r = false;
        }
        __server = NULL;
    }
 
    if (__svcctx) {
        status = OCIHandleFree(__svcctx, OCI_HTYPE_SVCCTX);
        if ((status != OCI_SUCCESS) && _normal) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            r = false;
        }
        __svcctx = NULL;
    }
 
    if (__error2) {
        status = OCIHandleFree(__error2, OCI_HTYPE_ERROR);
        if ((status != OCI_SUCCESS) && _normal) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            r = false;
        }
        __error2 = NULL;
    }
 
    return r;
}
 
bool OciConnection::executeHelper(const char* _sql, size_t _sqllen)
{
    OCIStmt* stmt = NULL;
    for ( ; ; ) {
        sword status = HandleAlloc((void**)&stmt, OCI_HTYPE_STMT);
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, NULL);
            break;  // goto __on_error;
        }
 
        status = OCIStmtPrepare2(
            svcHandle(),               // OCISvcCtx      *svchp
            &stmt,                      // OCIStmt       **stmthp
            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, __error);
            break;  // goto __on_error;
        }
 
        ub2 stmtType = __OCI_STMT_TYPE_UNKNOWN;
        ub4 size = sizeof(stmtType);
        status = OCIAttrGet(
            stmt,                       // const void *trgthndlp
            OCI_DTYPE_PARAM,            // ub4 trghndltyp
            &stmtType,                  // void *attributep
            &size,                      // ub4 *sizep
            OCI_ATTR_SCALE,             // ub4 attrtype
            errorHandle()                // OCIError *errhp
        );
        __DCL_ASSERT(size == sizeof(stmtType));
        if (status != OCI_SUCCESS) {
            __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
            break;  // goto __on_error;
        }
 
        status = OCIStmtExecute(
            svcHandle(),               // OCISvcCtx *svchp
            stmt,                       // OCIStmt *stmtp
            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_HANDLE(SQL::eServerError, status, __error);
            break;  // goto __on_error;
        }
 
        OCIHandleFree(stmt, OCI_HTYPE_STMT);
        return true;
    }
 
// __on_error:
    if (stmt) {
        OCIHandleFree(stmt, OCI_HTYPE_STMT);
    }
    return false;
}
 
enum StmtType {
    StmtOther,
    StmtTransBegin,
    StmtTransEnd,
};
 
typedef struct {
    StmtType type;
    const char* pattern;
} STMT_PATTERN;
 
static STMT_PATTERN sp[] = {
    { StmtTransBegin, "SET[[:space:]]+TRANSACTION"    },
    { StmtTransEnd,     "COMMIT|ROLLBACK"               },
    { StmtOther,       NULL                            }
};
 
static StmtType __GetStmtType(const char* _sql)
{
    for(size_t i = 0; sp[i].type != StmtOther; i++) {
        try {
            if (Regex::test(sp[i].pattern, _sql, true))
                return sp[i].type;
        }
        catch(Exception* _e) {
            _e->destroy();
        }
    }
    return StmtOther;
}
 
bool OciConnection::__execute(const char* _sql, size_t _sqllen)
{
    if(executeHelper(_sql, _sqllen)) {
        switch(__GetStmtType(_sql)) {
            case StmtTransBegin :
                __SET_STATE(Connection::stInTransaction);
                break;
            case StmtTransEnd :
                __UNSET_STATE(Connection::stInTransaction);
                break;
            case StmtOther :
            default :
                ;
        }
        return true;
    }
 
    return false;
}
 
bool OciConnection::__startTrans()
{
    __DCL_ASSERT(__svcctx != NULL);
    uword timeout = 60;
    ub4 flags = OCI_TRANS_READWRITE;
    sword status = OCITransStart(
        __svcctx,                   // OCISvcCtx *svchp
        __error,                 // OCIError *errhp
        timeout,                    // uword timeout
        flags                       // ub4 flags
    );
    if (status != OCI_SUCCESS) {
        __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
        return false;
    }
    __SET_STATE(Connection::stInTransaction);
    return true;
}
 
bool OciConnection::__commitTrans()
{
    __DCL_ASSERT(__svcctx != NULL);
    sword status = OCITransCommit(
        __svcctx,                   // OCISvcCtx *svchp
        __error,                 // OCIError *errhp
        OCI_DEFAULT                 // ub4 flags
    );
    if (status != OCI_SUCCESS) {
        __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
        return false;
    }
    __UNSET_STATE(stInTransaction);
    return true;
}
 
bool OciConnection::__rollbackTrans()
{
    __DCL_ASSERT(__svcctx != NULL);
    sword status = OCITransRollback(
        __svcctx,                   // OCISvcCtx *svchp
        __error,                 // OCIError *errhp
        OCI_DEFAULT                 // ub4 flags
    );
    if (status != OCI_SUCCESS) {
        __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
        return false;
    }
    __UNSET_STATE(stInTransaction);
    return true;
}
 
bool OciConnection::__createQueryInstance(SQL::Query** _queryHandleOut)
{
    __DCL_ASSERT(_queryHandleOut != NULL);
    SQL::Query* pNewQuery = new OciQuery(this);
    if (!pNewQuery) {
        __SET_ERROR_HANDLE(SQL::eOutOfMemory, 0, NULL);
        return false;
    }
    *_queryHandleOut = pNewQuery;
    return true;
}
 
// oci.h
// OCI_ERROR_MAXMSG_SIZE    1024
bool OciConnection::__getErrorMessage(char* _buf, size_t* _buflen)
{
    size_t len = 0;
    if (__lastStatus == OCI_ERROR) {
        sb4 errorcode = 0;
        if (OCIErrorGet(
            __error,             // void *hndlp
            (ub4)1,                 // ub4 recordno
            (text*)NULL,            // OraText *sqlstate
            &errorcode,             // sb4 *errcodep
            (text*)_buf,            // OraText *bufp
            (ub4) *_buflen,         // ub4 bufsiz
            OCI_HTYPE_ERROR         // ub4 type
        ) != OCI_SUCCESS) {
            // 드라이버 버그!!
            *_buflen = 0;
            return false;
        }
        len = ByteString::length(_buf, *_buflen);
        for(; len > 0; len--) {
            if (!isspace((unsigned)_buf[len - 1]))
                break;
        }
    }
    else {
        const char* psz = "";
        switch(__lastStatus) {
            case OCI_SUCCESS_WITH_INFO : 
                psz = "OCI_SUCCESS_WITH_INFO"; 
                break;
            case OCI_RESERVED_FOR_INT_USE :
                psz = "OCI_RESERVED_FOR_INT_USE";
                break;
            case OCI_NO_DATA : 
                psz = "OCI_NO_DATA"; 
                break;
            case OCI_ERROR :
                psz = "OCI_ERROR";
                break;
            case OCI_INVALID_HANDLE : 
                psz = "OCI_INVALID_HANDLE"; 
                break;
            case OCI_NEED_DATA : 
                psz = "OCI_NEED_DATA"; 
                break;
            case OCI_STILL_EXECUTING :
                psz = "OCI_STILL_EXECUTING"; 
                break;
            case OCI_CONTINUE : 
                psz = "OCI_CONTINUE"; 
                break;
            case OCI_ROWCBK_DONE :
                psz = "OCI_ROWCBK_DONE";
                break;
            default : 
        //      __DCL_ASSERT(false);
                ;
        }
 
        len = strlen(psz);
        if (*_buflen < len) {
            len = *_buflen;
        }
        strncpy(_buf, psz, len);
    }
 
    if (!__errorMessage.isEmpty()) {
        ByteString str;
        if (len)
            str = ", " + __errorMessage;
        else
            str = __errorMessage;
 
        if ((*_buflen - len) >= str.length()) {
            // 버퍼가 남이 있다면
            // 이전에 len > 0 이면 버퍼의 시작위치를 옮기다.
            _buf += len;
            strncpy(_buf, str.data(), str.length());
            len += str.length();
        }
    }
 
    if (len < *_buflen) {
        *_buflen = len;
        *(_buf + *_buflen) = '\0';
    }
    return len > 0;
}
 
bool OciConnection::__getServerInfo(char* _buf, size_t* _buflen)
{
    sword status = OCIServerVersion(
        __server,                       // void *hndlp
        __error,                     // OCIError *errhp
        (text*)_buf,                    // OraText *bufp
        (ub4) *_buflen,                 // ub4 bufsz
        OCI_HTYPE_SERVER                // ub1 hndltype
    );
    if (status != OCI_SUCCESS) {
        __SET_ERROR_HANDLE(SQL::eServerError, status, __error);
        return false;
    }
    *_buflen = ByteString::length(_buf, *_buflen);
    return true;
}
 
__DCL_END_NAMESPACE