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 wchar_t __THIS_FILE__[] = __T("dcl/sql/OciConnection.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#undef __SET_ERROR
#define __SET_ERROR(_error, status, pError) \
    setErrorStatus(_error, status, pError, \
        true, __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 (__error) {
        status = OCIHandleFree(__error, OCI_HTYPE_ERROR);
        if (status != OCI_SUCCESS) {
            __DCL_TRACE0_N(__T("OCIHandleFree Fail! : __error\n"));
        }
        __error = NULL;
    }
 
    if (__env) {
        status = OCIHandleFree(__env, OCI_HTYPE_ENV);
        if (status != OCI_SUCCESS) {
            __DCL_TRACE0_N(__T("OCIHandleFree Fail! : __env\n"));
        }
        __env = NULL;
    }
}
 
void OciConnection::destroy()
{
    delete this;
}
 
/*
    pszConnectionString에 가능한 property
        USER,
        PASSWORD,
        DATABASE,
        MODE
*/
 
bool OciConnection::__open(const char* _connString, size_t _connlen)
{
    ListedByteStringToByteStringMap map;
    Connection::splitConnectionString(_connString, _connlen, map);
 
    ByteString strDatabase = map["DATABASE"];
    ByteString strUser = map["USER"];
    ByteString strPassword = map["PASSWORD"];
    ByteString strMode = map["MODE"];
 
    ub4 nOperationMode = OCI_DEFAULT;
    if (!strMode.isEmpty()) {
        if (!strMode.compareNoCase("SYSDBA"))
            nOperationMode = OCI_SYSDBA;
        else if (!strMode.compareNoCase("SYSOPER"))
            nOperationMode = OCI_SYSOPER;
        else {
            __SET_ERROR(SQL::eInvalidConnectionString, 0, NULL);
            return false;
        }
    }
 
    if (strUser.isEmpty()) {
        __SET_ERROR(SQL::eInvalidConnectionString, 0, NULL);
        return false;
    }
 
    sword status = OCI_SUCCESS;
    // __env, __error은 ~OciConnection에서 OCIHandleFree한다.
    // close후 다시 open할 수 있다.
    if (!__env) {
        status = ::OCIEnvCreate(
            &__env,
            OCI_ENV_NO_MUTEX | OCI_THREADED | OCI_OBJECT,
            (void*)0, 0, 0, 0,
            (size_t)0, (void**)0
            );
        if (status != OCI_SUCCESS) {
            __SET_ERROR(SQL::eServerError, status, NULL);
            goto __on_error;
        }
    }
 
    if (!__error) {
        status = OCIHandleAlloc((void**)&__error, OCI_HTYPE_ERROR);
        if (status != OCI_SUCCESS) {
            __SET_ERROR(SQL::eServerError, status, NULL);
            goto __on_error;
        }
    }
 
    status = OCIHandleAlloc((void**)&__error2, OCI_HTYPE_ERROR);
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, NULL);
        goto __on_error;
    }
 
    status = OCIHandleAlloc((void**)&__server, OCI_HTYPE_SERVER);
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, NULL);
        goto __on_error;
    }
 
    status = OCIHandleAlloc((void**)&__svcctx, OCI_HTYPE_SVCCTX);
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, NULL);
        goto __on_error;
    }
    
    status = OCIHandleAlloc((void**)&__session, OCI_HTYPE_SESSION);
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, NULL);
        goto __on_error;
    }
 
    status = OCIHandleAlloc((void**)&__trans, OCI_HTYPE_TRANS);
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, NULL);
        goto __on_error;
    }
 
    status = ::OCIServerAttach(
            __server,
            __error, 
            strDatabase.isEmpty()? NULL : (text*)strDatabase.data(), 
            strDatabase.isEmpty()? 0 : strDatabase.length(),
            OCI_DEFAULT
            );
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, __error);
        goto __on_error;
    }
 
#if defined(__DCL_DEBUG) && __TRACE_THIS
    char buf[256];
    status = OCINlsGetInfo(__env, __error,
        (OraText*) buf, sizeof(buf), OCI_NLS_CHARACTER_SET);
    if (status == OCI_SUCCESS) {
        __DCL_TRACE1_N(L"[%hs]\n", buf);
    }
    else {
        __DCL_TRACE1_N(L"[%d]\n", status);
    }
    status = OCINlsGetInfo(__env, __error,
        (OraText*)buf, sizeof(buf), OCI_NLS_LANGUAGE);
    if (status == OCI_SUCCESS) {
        __DCL_TRACE1_N(L"[%hs]\n", buf);
    }
    else {
        __DCL_TRACE1_N(L"[%d]\n", status);
    }
    status = OCINlsGetInfo(__env, __error,
        (OraText*)buf, sizeof(buf), OCI_NLS_ABLANGUAGE);
    if (status == OCI_SUCCESS) {
        __DCL_TRACE1_N(L"[%hs]\n", buf);
    }
    else {
        __DCL_TRACE1_N(L"[%d]\n", status);
    }
    status = OCINlsGetInfo(__env, __error,
        (OraText*)buf, sizeof(buf), OCI_NLS_TERRITORY);
    if (status == OCI_SUCCESS) {
        __DCL_TRACE1_N(L"[%hs]\n", buf);
    }
    else {
        __DCL_TRACE1_N(L"[%d]\n", status);
    }
#endif
 
    __serverAttached = true;
 
    status = ::OCIAttrSet(
            __svcctx,
            OCI_HTYPE_SVCCTX, 
            __server, 
            (ub4)0, 
            OCI_ATTR_SERVER, 
            __error
            );
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, __error);
        goto __on_error;
    }
 
    status = ::OCIAttrSet(
            __session, 
            OCI_HTYPE_SESSION, 
            (void*)strUser.data(), 
            strUser.length(),
            OCI_ATTR_USERNAME,
            __error
            );
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, __error);
        goto __on_error;
    }
 
    status = ::OCIAttrSet(
            __session,
            OCI_HTYPE_SESSION,
            (void*)strPassword.data(),
            strPassword.length(),
            OCI_ATTR_PASSWORD,
            __error
            );
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, __error);
        goto __on_error;
    }
 
    status = ::OCISessionBegin(
            __svcctx, 
            __error, 
            __session,
            OCI_CRED_RDBMS, 
            nOperationMode
            );
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, __error);
        goto __on_error;
    }
 
    __sessionStarted = true;
    status = ::OCIAttrSet(
            __svcctx,
            OCI_HTYPE_SVCCTX, 
            __server, 
            (ub4)0, 
            OCI_ATTR_SERVER, 
            __error
            );
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, __error);
        goto __on_error;
    }
 
    status = ::OCIAttrSet(
            __svcctx, 
            OCI_HTYPE_SVCCTX,
            (void*)__session,
            0,
            OCI_ATTR_SESSION,
            __error
            );
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, __error);
        goto __on_error;
    }
 
    status = ::OCIAttrSet(
            __svcctx,
            OCI_HTYPE_SVCCTX,
            __trans,
            0,
            OCI_ATTR_TRANS,
            __error
            );
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, __error);
        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* pError = __error;
    bool bReturn = true;
 
    if (!_normal) {
        // 이전에 오류가 있었다.
        // cleanup에서 __error2가 사용된다.
        pError = __error2;
    }
 
    if (__sessionStarted) {
        status = ::OCISessionEnd(
                __svcctx,
                pError,
                __session,
                OCI_DEFAULT
                );
        if ((status != OCI_SUCCESS) && _normal) {
            __SET_ERROR(SQL::eServerError, status, __error);
            bReturn = false;
        }
        __sessionStarted = false;
    }
 
    if (__serverAttached) {
        status = ::OCIServerDetach(
                __server,
                pError,
                OCI_DEFAULT
                );
        if ((status != OCI_SUCCESS) && _normal) {
            __SET_ERROR(SQL::eServerError, status, __error);
            bReturn = false;
        }
        __serverAttached = false;
    }
 
    if (__trans) {
        status = OCIHandleFree(__trans, OCI_HTYPE_TRANS);
        if ((status != OCI_SUCCESS) && _normal) {
            __SET_ERROR(SQL::eServerError, status, __error);
            bReturn = false;
        }
        __session = NULL;
    }
 
    if (__session) {
        status = OCIHandleFree(__session, OCI_HTYPE_SESSION);
        if ((status != OCI_SUCCESS) && _normal) {
            __SET_ERROR(SQL::eServerError, status, __error);
            bReturn = false;
        }
        __session = NULL;
    }
 
    if (__server) {
        status = OCIHandleFree(__server, OCI_HTYPE_SERVER);
        if ((status != OCI_SUCCESS) && _normal) {
            __SET_ERROR(SQL::eServerError, status, __error);
            bReturn = false;
        }
        __server = NULL;
    }
 
    if (__svcctx) {
        status = OCIHandleFree(__svcctx, OCI_HTYPE_SVCCTX);
        if ((status != OCI_SUCCESS) && _normal) {
            __SET_ERROR(SQL::eServerError, status, __error);
            bReturn = false;
        }
        __svcctx = NULL;
    }
 
    if (__error2) {
        status = OCIHandleFree(__error2, OCI_HTYPE_ERROR);
        if ((status != OCI_SUCCESS) && _normal) {
            __SET_ERROR(SQL::eServerError, status, __error);
            bReturn = false;
        }
        __error2 = NULL;
    }
 
    return bReturn;
}
 
bool OciConnection::executeHelper(const char* _sql, size_t _sqllen)
{
    OCIStmt* pStmt = NULL;
    sword status = OCIHandleAlloc((void**)&pStmt, OCI_HTYPE_STMT);
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, NULL);
        goto __on_error;
    }
 
    status = ::OCIStmtPrepare(
            pStmt,
            __error,
            (CONST text*)_sql,
            _sqllen,
            OCI_NTV_SYNTAX,
            OCI_DEFAULT
            );
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, __error);
        goto __on_error;
    }
 
    ub2 nStmtType;
    status = ::OCIAttrGet(
            pStmt, 
            OCI_HTYPE_STMT, 
            &nStmtType,
            NULL, 
            OCI_ATTR_STMT_TYPE, 
            __error
            );
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, __error);
        goto __on_error;
    }   
    
    status = ::OCIStmtExecute(
            __svcctx,
            pStmt,
            __error,
            1, //(m_nStmtType == OCI_STMT_SELECT) ? 0 : 1,
            0,
            NULL,
            NULL,
            OCI_DEFAULT
            );
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, __error);
        goto __on_error;
    }
 
    OCIHandleFree(pStmt, OCI_HTYPE_STMT);
 
    return true;
 
__on_error:
    if (pStmt)
        OCIHandleFree(pStmt, 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 n)
{
    if(executeHelper(_sql, n)) {
        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, __error, timeout, flags);
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, __error);
        return false;
    }
    __SET_STATE(Connection::stInTransaction);
    return true;
}
 
bool OciConnection::__commitTrans()
{
    __DCL_ASSERT(__svcctx != NULL);
    sword status = ::OCITransCommit(__svcctx, __error, OCI_DEFAULT);
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, __error);
        return false;
    }
    __UNSET_STATE(stInTransaction);
    return true;
}
 
bool OciConnection::__rollbackTrans()
{
    __DCL_ASSERT(__svcctx != NULL);
    sword status = ::OCITransRollback(__svcctx, __error, OCI_DEFAULT);
    if (status != OCI_SUCCESS) {
        __SET_ERROR(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(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 nErrorCode = 0;
        if (::OCIErrorGet(
                __error, 
                (ub4)1, 
                (text*)NULL,
                &nErrorCode,
                (text*)_buf,
                *_buflen,
                OCI_HTYPE_ERROR
                ) != OCI_SUCCESS) {
            // 드라이버 버그!!
            *_buflen = 0;
            return false;
        }
        len = strlen(_buf);
        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 (!__errorMessageEx.isEmpty()) {
        ByteString str;
        if (len)
            str = ", " + __errorMessageEx;
        else
            str = __errorMessageEx;
 
        if ((*_buflen - len) >= str.length())    {
            // 버퍼가 남이 있다면
 
            // 이전에 len > 0 이면 버퍼의 시작위치를 옮기다.
            _buf += len;
 
            strncpy(_buf, str.data(), str.length());
            len += str.length();
        }
    }
 
    if (len)
        *_buflen = len;
    else {
        const char* psz = "Driver Bug!!";
        len = strlen(psz);
        if (*_buflen > len)
            *_buflen = len;
        strncpy(_buf, psz, *_buflen);
    }
    
    return true;
}
 
bool OciConnection::__getServerInfo(char* _buf, size_t* _buflen)
{
    sword status = ::OCIServerVersion(
            __server,
            __error,
            (text*)_buf,
            *_buflen,
            OCI_HTYPE_SERVER
            );
    if (status != OCI_SUCCESS) {
        __SET_ERROR(SQL::eServerError, status, __error);
        return false;
    }
    *_buflen = strlen(_buf);
    return true;
}
 
__DCL_END_NAMESPACE