ODBCConnection.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <string.h>     // strlen, strncpy
 
#ifdef _MSC_VER
#include <windows.h>
#endif
#include <sql.h>
#include <sqlext.h>
 
#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/Charset.h>
#include <dcl/SQLCore.h>
 
#include "ODBCConnection.h"
#include "ODBCQuery.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/ODBCConnection.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#define __SET_ERROR(_error) \
    setErrorStatus(_error, __THIS_FILE__, __LINE__)
#define __SET_ERROR_MSG(_msg) \
    setErrorMessage(_msg, __THIS_FILE__, __LINE__)
#define __SET_ERROR_HANDLE(_rc, _htype, _handle) \
    setErrorHandle(_rc, _htype, _handle, __THIS_FILE__, __LINE__)
#define __SET_INFO_HANDLE(_rc, _htype, _handle) \
    if (_rc == SQL_SUCCESS_WITH_INFO) { \
        setErrorHandle(_rc, _htype, _handle, __THIS_FILE__, __LINE__); \
    }
 
IMPLEMENT_CLASSINFO(ODBCConnection, SQL::Connection)
 
ODBCConnection::ODBCConnection(const wchar_t* _serverTitle)
    : Connection(_serverTitle)
{
    Connection::__canTransact = true;
    __henv = NULL;
    __hdbc = NULL;
 
    __IS_MS_SS = false;
}
 
ODBCConnection::~ODBCConnection()
{
    if (__hdbc) {
        __DCL_TRACE0_N(L"Warning!! The connection was not closed\n");
        close();
    }
 
    if (__henv) {
        SQLRETURN rc_ = SQLFreeHandle(SQL_HANDLE_ENV, __henv);
        if (rc_ != SQL_SUCCESS) {
            __DCL_TRACE1_N(L"SQLFreeHandle(ENV) Fail! [%d]\n", rc_);
        }
        __henv = NULL;
    }
}
 
void ODBCConnection::destroy()
{
    delete this;
}
 
bool ODBCConnection::__open(const char* _cons, size_t _conslen)
{
    SQLRETURN rc = SQL_SUCCESS;
    if (!__henv) {
        rc = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &__henv);
        if (rc != SQL_SUCCESS) {
            __SET_ERROR_MSG(
                ByteString::format("Unable to allocate an environment handle [%d]",
                rc));
            return false;
        }
 
        rc = SQLSetEnvAttr(__henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, 0);
        if (rc != SQL_SUCCESS) {
            __SET_ERROR_HANDLE(rc, SQL_HANDLE_ENV, __henv);
            return false;
        }
    }
 
    __DCL_ASSERT_HANDLE(__hdbc == NULL);
    rc = SQLAllocHandle(SQL_HANDLE_DBC, __henv, &__hdbc);
    if (rc != SQL_SUCCESS) {
        __SET_ERROR_HANDLE(rc, SQL_HANDLE_ENV, __henv);
        return false;
    }
 
    for ( ; ; ) {
        SQLSMALLINT length2 = 0;
        rc = SQLDriverConnectA(__hdbc, NULL,
                (SQLCHAR*)_cons, (SQLSMALLINT)_conslen,
                NULL, 0, &length2, SQL_DRIVER_NOPROMPT
            );
        if (!SQL_SUCCEEDED(rc)) {
            __SET_ERROR_HANDLE(rc, SQL_HANDLE_DBC, __hdbc);
            break;
        }
        __SET_INFO_HANDLE(rc, SQL_HANDLE_DBC, __hdbc);
 
#if defined(__WINNT__) && !defined(strncasecmp)
#define strncasecmp(s1,s2,n) _strnicmp(s1,s2,n)
#endif
        char buf[128];
        SQLSMALLINT len = sizeof(buf);
        rc = SQLGetInfoA(__hdbc, SQL_DBMS_NAME, buf, len, &len);
        if (rc != SQL_SUCCESS) {
            __SET_ERROR_HANDLE(rc, SQL_HANDLE_DBC, __hdbc);
            return false;
        }
        __IS_MS_SS = strncasecmp(buf, "Microsoft SQL Server", __MIN(9, len)) == 0;
        __DCL_TRACE3_N(L"[%hs][%d] [%d]\n", buf, len, __IS_MS_SS);
 
        rc = SQLSetConnectAttrA(__hdbc, SQL_ATTR_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF, 0);
        if (rc != SQL_SUCCESS) {
            __SET_ERROR_HANDLE(rc, SQL_HANDLE_DBC, __hdbc);
            break;
        }
 
    #if __TRACE_THIS
        SQLUINTEGER GetDataSupport = 0;
        SQLSMALLINT length;
 
        rc = SQLGetInfoA(__hdbc, SQL_GETDATA_EXTENSIONS,
            &GetDataSupport, sizeof(GetDataSupport), &length);
        __DCL_TRACE3_N(L"[%04x] AC[%04x] AO[%04x]\n",
            GetDataSupport,
            GetDataSupport & SQL_GD_ANY_COLUMN,
            GetDataSupport & SQL_GD_ANY_ORDER
            );
        __DCL_TRACE3_N(L"BL[%04x] BO[%04x] OP[%04x]\n",
            GetDataSupport & SQL_GD_BLOCK,
            GetDataSupport & SQL_GD_BOUND,
            GetDataSupport & SQL_GD_OUTPUT_PARAMS
        );
    #endif
        return true;
    }
 
    // Connect Failed
    SQLRETURN rc_ = SQLFreeHandle(SQL_HANDLE_DBC, __hdbc);
    if (rc_ != SQL_SUCCESS) {
        __DCL_TRACE1_N(L"SQLFreeHandle(DBC) Fail! [%d]\n", rc_);
    }
    __hdbc = NULL;
    return false;
}
 
bool ODBCConnection::__close()
{
    if (!__hdbc) {
        __SET_ERROR(SQL::eNotConnected);
        return false;
    }
 
    SQLRETURN rc = SQL_SUCCESS;
    rc = SQLDisconnect(__hdbc);
    if (rc != SQL_SUCCESS) {
        __SET_ERROR_HANDLE(rc, SQL_HANDLE_DBC, __hdbc);
    }
 
    SQLRETURN rc_ = SQLFreeHandle(SQL_HANDLE_DBC, __hdbc);
    if (rc_ != SQL_SUCCESS) {
        __DCL_TRACE1_N(L"SQLFreeHandle(DBC) Fail! [%d]\n", rc_);
    }
    __hdbc = NULL;
 
    return rc == SQL_SUCCESS;
}
 
bool ODBCConnection::__execute(const char* _sql, size_t _sqllen)
{
    SQLHSTMT hstmt = NULL;
    SQLRETURN rc = SQLAllocHandle(SQL_HANDLE_STMT, __hdbc, &hstmt);
    if (rc != SQL_SUCCESS) {
        __SET_ERROR_HANDLE(rc, SQL_HANDLE_DBC, __hdbc);
        return false;
    }
 
    rc = SQLExecDirectA(hstmt, (SQLCHAR*) _sql, (SQLINTEGER)_sqllen);
    if (!SQL_SUCCEEDED(rc)) {
        __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, hstmt);
    }
    __SET_INFO_HANDLE(rc, SQL_HANDLE_STMT, hstmt);
 
    SQLRETURN rc_ = SQLFreeStmt(hstmt, SQL_CLOSE);
    if (rc_ != SQL_SUCCESS) {
        __DCL_TRACE1_N(L"SQLFreeStmt(STMT) Fail! [%d]\n", rc_);
    }
 
    rc_ = SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
    if (rc_ != SQL_SUCCESS) {
        __DCL_TRACE1_N(L"SQLFreeHandle(STMT) Fail! [%d]\n", rc_);
    }
    hstmt = NULL;
 
    return rc == SQL_SUCCESS;
}
 
bool ODBCConnection::__startTrans()
{
    __SET_STATE(Connection::stInTransaction);
    return true;
}
 
bool ODBCConnection::__commitTrans()
{
    __UNSET_STATE(Connection::stInTransaction);
    SQLRETURN rc = SQLEndTran(SQL_HANDLE_DBC, __hdbc, SQL_COMMIT);
    if (rc != SQL_SUCCESS) {
        __SET_ERROR_HANDLE(rc, SQL_HANDLE_DBC, __hdbc);
        return false;
    }
 
    return true;
}
 
bool ODBCConnection::__rollbackTrans()
{   
    __UNSET_STATE(Connection::stInTransaction);
    SQLRETURN rc = SQLEndTran(SQL_HANDLE_DBC, __hdbc, SQL_ROLLBACK);
    if (rc != SQL_SUCCESS) {
        __SET_ERROR_HANDLE(rc, SQL_HANDLE_DBC, __hdbc);
        return false;
    }
 
    return true;
}
 
bool ODBCConnection::__createQueryInstance(SQL::Query** _ppQuery)
{
    __DCL_ASSERT(_ppQuery != NULL);
 
    ODBCQuery* pNewQuery = new ODBCQuery(this);
    if (!pNewQuery) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
 
    *_ppQuery = pNewQuery;
    return true;
}
 
bool ODBCConnection::__getErrorMessage(char* _buf, size_t* _buflen)
{
    if (__lastErrorMessage.length() < *_buflen) {
        *_buflen = __lastErrorMessage.length();
        *(_buf + *_buflen) = '\0';
    }
    strncpy(_buf, __lastErrorMessage.data(), *_buflen);
    __lastErrorMessage.clear();
    return true;
}
 
bool ODBCConnection::__getServerInfo(char* _buf, size_t* _buflen)
{
#if 0 && defined(__WINNT__)
    StringBuilder sb;
    WCHAR buf[1024];
    SQLSMALLINT length;
 
    SQLRETURN rc = SQLGetInfoW(__hdbc, SQL_DBMS_NAME, buf, __countof(buf, WCHAR) , &length);
    if (rc != SQL_SUCCESS) {
        __SET_ERROR_HANDLE(rc, SQL_HANDLE_DBC, __hdbc);
        return false;
    }
    sb.append(buf, length / sizeof(WCHAR));
 
    rc = SQLGetInfoW(__hdbc, SQL_DBMS_VER, buf, __countof(buf, WCHAR) , &length);
    if (rc != SQL_SUCCESS) {
        __SET_ERROR_HANDLE(rc, SQL_HANDLE_DBC, __hdbc);
        return false;
    }
    sb.append(L' ');
    sb.append(buf, length / sizeof(WCHAR));
 
    ByteString s = UTF8Encoder::encode(sb.toString());
    if (s.length() < *_buflen) {
        *_buflen = s.length();
    }
    strncpy(_buf, s.data(), *_buflen);
    return true;
#else
    SQLSMALLINT size = (SQLSMALLINT) __MIN(*_buflen, SHRT_MAX);
    SQLSMALLINT offset = 0;
    SQLSMALLINT length;
    SQLRETURN rc = SQL_SUCCESS;
 
    rc = SQLGetInfoA(__hdbc, SQL_DBMS_NAME,
        _buf + offset, size - offset, &length);
    if (rc != SQL_SUCCESS) {
        __SET_ERROR_HANDLE(rc, SQL_HANDLE_DBC, __hdbc);
        return false;
    }
 
    if ((offset + length) >= size) {
        *_buflen = size;
        return true;
    }
 
    offset += length;
    *(_buf + offset) = ' ';
    offset++;
 
    rc = SQLGetInfoA(__hdbc, SQL_DBMS_VER,
        _buf + offset, size - offset, &length);
    if (rc != SQL_SUCCESS) {
        __SET_ERROR_HANDLE(rc, SQL_HANDLE_DBC, __hdbc);
        return false;
    }
 
    if ((offset + length) >= size) {
        *_buflen = size;
        return true;
    }
 
    *_buflen = offset + length;
    return true;
#endif
}
 
void ODBCConnection::setErrorHandle(
    SQLRETURN       _rc,
    SQLSMALLINT     _htype,  
    SQLHANDLE       _handle,  
    const wchar_t*  _filename,
    int             _line
)
{
    Connection::setErrorStatus(SQL::eServerError, _filename, _line);
 
    if (_rc == SQL_SUCCESS_WITH_INFO || _rc == SQL_ERROR) {
        __DCL_ASSERT(
            _htype == SQL_HANDLE_ENV
            || _htype == SQL_HANDLE_DBC
            || _htype == SQL_HANDLE_STMT
            || _htype == SQL_HANDLE_DESC
            // || _htype == SQL_HANDLE_DBC_INFO_TOKEN
        );
        __DCL_ASSERT(_handle != NULL);
 
#if 0 && defined(__WINNT__)
        /*
         * sizeof(WCHAR) == 2 인 Windows에서만 사용할 수 있다.
         * Linux에서 WCHAR은 기본적으로 signed short로 wchar_t가 아니다.
         * 이 코드는 LANG=C.UTF-4 환경변수가 적용되지 않는 Windows에서만 적용한다.
         */
        StringBuilder sb;
        SQLSMALLINT RecNumber = 0;
        SQLINTEGER  NativeError;
        WCHAR       SQLState[SQL_SQLSTATE_SIZE + 1];
        WCHAR       MessageText[1024];
        SQLSMALLINT MessageTextLength;
        SQLRETURN   rc;
        while ((rc = SQLGetDiagRecW(
            _htype, _handle, ++RecNumber, SQLState, &NativeError,
            MessageText, __countof(MessageText, WCHAR), &MessageTextLength
        )) == SQL_SUCCESS) {
            if (sb.length() > 0) {
                sb.append('\n');
            }
            sb.format(L"[%d][%ls]", RecNumber, SQLState);
            sb.append(MessageText, (size_t) MessageTextLength);
        }
        //__DCL_TRACE1_N(L"rc[%d]\n", rc);
        String s = sb.toString();
    #if __TRACE_THIS
        if (_rc == SQL_SUCCESS_WITH_INFO) {
            __DCL_TRACE1_N(L"SQL_SUCCESS_WITH_INFO:\n  %ls\n",
                s.replace(L"\n", L"\n  ").data());
        }
    #endif
        try {
            __lastErrorMessage = UTF8Encoder::encode(s);
        }
        catch (CharsetConvertException* _e) {
            __DCL_TRACE1(L"Fatal!! [%ls]\n", _e->toString().data());
            _e->destroy();
        }
#else
        ByteStringBuilder sb;
        SQLSMALLINT RecNumber = 0;
        SQLINTEGER  NativeError;
        SQLCHAR     SQLState[SQL_SQLSTATE_SIZE + 1];
        SQLCHAR     ErrorMsg[1024];
        SQLSMALLINT ErrorMsgLen;
        SQLRETURN   rc;
        while ((rc = SQLGetDiagRecA(
            _htype, _handle, ++RecNumber, SQLState, &NativeError,
            ErrorMsg, __countof(ErrorMsg, SQLCHAR), &ErrorMsgLen
        )) == SQL_SUCCESS) {
            if (sb.length() > 0) {
                sb.append('\n');
            }
            sb.format("[%d][%hs]", RecNumber, SQLState);
            sb.append((const char*)ErrorMsg, (size_t)ErrorMsgLen);
        }
        __DCL_ASSERT(rc == SQL_NO_DATA);
        ByteString s;
#ifdef __WINNT__
        /*
         * Windows에서 LANG=C.UTF-4 환경변수가 적용되지 않으므로,
         * wchar_t로 변환 후 UTF-8로 다시 변환한다.
         */
        try {
            String ws = LocaleDecoder::decode(sb.toByteString());
            s = UTF8Encoder::encode(ws);
    #if __TRACE_THIS
            if (_rc == SQL_SUCCESS_WITH_INFO) {
                __DCL_TRACE1_N(L"SQL_SUCCESS_WITH_INFO:\n  %ls\n",
                    ws.replace(L"\n", L"\n  ").data());
            }
    #endif
        }
        catch (CharsetConvertException* _e) {
            __DCL_TRACE1(L"Fatal!! [%ls]\n", _e->toString().data());
            _e->destroy();
        }
#else
        s = sb.toByteString();
    #if __TRACE_THIS
        if (_rc == SQL_SUCCESS_WITH_INFO) {
            __DCL_TRACE1_N(L"SQL_SUCCESS_WITH_INFO:\n  %hs\n",
                s.replace("\n", "\n  ").data());
        }
    #endif
#endif
        __lastErrorMessage = s;
#endif
    }
    else {
        #define CASE_STR(rc) case rc: __lastErrorMessage = #rc; break;
        switch (_rc) {
            CASE_STR(SQL_SUCCESS)
            CASE_STR(SQL_SUCCESS_WITH_INFO)
            CASE_STR(SQL_ERROR)
            CASE_STR(SQL_NO_DATA)
            CASE_STR(SQL_INVALID_HANDLE)
            default:
                __DCL_ASSERT(false);
                __lastErrorMessage = ByteString::format("SQLRETURN[%d] mabe bug!!", _rc);
        }
    }
}
 
__DCL_END_NAMESPACE