SQLException.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
#include <windows.h>
#endif
 
#include <dcl/Object.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/Charset.h>
#include <dcl/Thread.h>
#include <dcl/SQL.h>
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/SQLException.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(SQLException, Exception)
 
String SQLException::getServerMessage(SQL::Connection* _connHandle)
{
    StringBuilder r;
#ifdef __DCL_DEBUG
    if (_connHandle->errorFileName()) {
        r = _connHandle->errorFileName();
        r += __T(":");
        r += Int32::toString(_connHandle->errorLine(), 10) + __T(": ");
    }
#endif
 
    if (_connHandle->errorCode() == SQL::eServerError) {
        r += _connHandle->serverTitle();
        r += __T(": ");
 
        ByteString s;
        size_t n = 1024;
        ByteBuffer* buf = ByteBuffer::create(n);
        bool b = _connHandle->getErrorMessage(buf->data(), &n);
        if (b) {
            buf->__dataLength = n;
            s = buf;
        }
        buf->release();
 
        if (s.length() > 0) {
            try {
                r += UTF8Decoder::decode(s);
            }
            catch (CharsetConvertException* _e) {
                __DCL_TRACE1(L"Warning!! getServerMessage [%ls]\n", _e->toString().data());
                _e->destroy();
            }
        }
        else {
            r += __T("The Server Error Message is unavailable!!");
        }
    }
    else {
        r += __T("DCL: ");
        size_t n = 256;
        CharBuffer* buf = CharBuffer::create_e(n);
        if (!SQL::getErrorMessage(buf->data(), &n, _connHandle->errorCode())) {
            if (buf->__allocLength < n) {
                CharBuffer::extend(buf, n);
            }
            SQL::getErrorMessage(buf->data(), &n, _connHandle->errorCode());
        }
        r.append(buf->data(), n);
        buf->release();
    }
    return r;
}
 
SQLException::SQLException(SQLConnection* _conn, Exception* _cause)
    : Exception(NULL)
{
    __DCL_ASSERT(_conn && _conn->handle());
    __message = _cause ? _cause->toString() :
        getServerMessage(_conn->handle());
}
 
SQLException::SQLException(SQLConnection* _conn, const String& _message)
    : Exception(NULL)
{
    __DCL_ASSERT(_conn && _conn->handle());
    __message = getServerMessage(_conn->handle()) +  __T(": ");
    __message = __message + _message;
}
 
SQLException::SQLException(SQLQuery* _query, Exception* _cause)
    : Exception(_cause)
{
    __DCL_ASSERT(_query && _query->handle()->connection());
    __message = _cause ? _cause->toString()
        : getServerMessage(_query->connection()->handle());
 
}
 
SQLException::SQLException(SQLQuery* _query, const String& _message)
    : Exception(NULL)
{
    __DCL_ASSERT(_query && _query->handle()->connection());
    __message = getServerMessage(_query->connection()->handle()) + __T(": ");
    __message = __message + _message;
}
 
SQLException::SQLException(SQLField* _field, Exception* _cause)
    : Exception(_cause)
{
    __DCL_ASSERT(_field && _field->handle()->connection());
    StringBuilder sb;
    sb += _cause ? _cause->toString()
        : getServerMessage(_field->handle()->connection());
    sb += __T(": ");
    sb += _field->name();
    sb += __T("(");
    sb += _field->dataTypeName();
    sb += __T(",");
    sb += _field->handle()->serverDataTypeName();
    sb += __T(")");
    __message = sb.toString();
}
 
SQLException::SQLException(
    SQLField* _field,
    const wchar_t* _cast,
    Exception* _cause
) : Exception(_cause)
{
    StringBuilder sb = __T("SQLData access type error: ");
    sb += _field->name();
    sb += __T("(");
    sb += _field->dataTypeName();
    sb += __T("), access: ");
    sb += _cast;
    __message = sb.toString();
}
 
SQLException::SQLException(
    SQLField* _field,
    const wchar_t* _cast,
    AsErrorCode _errorCode
) : Exception(NULL)
{
    StringBuilder sb = __T("SQLData access type error: ");
    sb += _field->name();
    sb += __T("(");
    sb += _field->dataTypeName();
    sb += __T("), access: ");
    sb += _cast;
    switch(_errorCode) {
        case eInvalidCast: {
            sb += __T(": Data convert impossible");
            break;
        }
        case eOutOfRange: {
            sb += __T(": Numeric convert out of range");
            break;
        }
        default: {
            __DCL_ASSERT(false);
        }
    }
    __message = sb.toString();
}
 
String SQLException::toString() const
{
    return __message;
}
 
__DCL_END_NAMESPACE