SQLConnection.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
#include <windows.h>
#endif
// 2005.01.26
 
#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>     // SQLConnectionPool::Thread::Mutex
#include <dcl/SQL.h>
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/SQLConnection.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE

IMPLEMENT_CLASSINFO(SQLConnection, Object)
 
void SQLConnection::initialize(SQLDriver* _driver)
{
    __DCL_ASSERT_PARAM(_driver != NULL);
 
    __handle = NULL;
    __driver = NULL;
    __connected = false;
 
    SQL::Connection* _connHandle = _driver->createConnection();
    __DCL_ASSERT(_connHandle != NULL);
 
    __handle = _connHandle;
    __driver = _driver;
}
 
SQLConnection::SQLConnection(SQLDriver* _driver)
{
    __DCL_ASSERT_PARAM(_driver != NULL);
    initialize(_driver);
}
 
SQLConnection::SQLConnection(const String& _driverName)
    __DCL_THROWS1(SQLDriverException*)
{
    __DCL_ASSERT_PARAM(!_driverName.isEmpty());
 
    SQLDriver* _driver = SQLDriver::getDriver(_driverName);
    initialize(_driver);
}
 
SQLConnection::~SQLConnection()
{
    __DCL_ASSERT(__handle->refCount() == 0);
    if (__connected) {
        try {
            //__DCL_TRACE0(__T("close()\n"));
            close();
        }
        catch (SQLException* e) {
            __DCL_TRACE1(__T("Warning! %ls\n"), e->toString().data());
            e->destroy();
        }
    }
 
    __driver->destroyConnection(__handle);
    //__handle = NULL;
    //__driver = NULL;
}
 
// Operations
void SQLConnection::open(const String& _connstr) __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(__handle != NULL);
    __DCL_ASSERT(__connected == false);
 
    ByteString mbs;
    try {
        mbs = UTF8Encoder::encode(_connstr);
    }
    catch (CharsetConvertException* _cause) {
        throw new SQLException(this, _cause);
    }
 
    if (!__handle->open(mbs, mbs.length())) {
#ifdef __DCL_DEBUG
        throw new SQLException(this, _connstr);
#else
        throw new SQLException(this, NULL);
#endif
    }
 
    __connected = true;
}
 
void SQLConnection::close() __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(__handle != NULL);
 
    if (__connected) {
        if (inTransaction())
            rollbackTrans();
 
        if (!__handle->close()) {
            throw new SQLException(this, NULL);
        }
 
        __connected = false;
    }
}
 
void SQLConnection::execute(const String& _sql) __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(__handle != NULL);
    __DCL_ASSERT(__connected);
 
    ByteString mbs;
    try {
        mbs = UTF8Encoder::encode(_sql);
    }
    catch (CharsetConvertException* _cause) {
        throw new SQLException(this, _cause);
    }
 
    if (!__handle->execute(mbs, mbs.length())) {
#ifdef __DCL_DEBUG
        throw new SQLException(this, _sql);
#else
        throw new SQLException(this, NULL);
#endif
    }
}
 
void SQLConnection::startTrans() __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(__handle != NULL);
    __DCL_ASSERT(__connected);
//  __DCL_ASSERT(!inTransaction());
 
    if (!__handle->startTrans()) {
        throw new SQLException(this, NULL);
    }
}
 
void SQLConnection::commitTrans() __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(__handle != NULL);
    __DCL_ASSERT(__connected);
//  __DCL_ASSERT(inTransaction());
 
    if (!__handle->commitTrans()) {
        throw new SQLException(this, NULL);
    }
}
 
void SQLConnection::rollbackTrans() __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(__handle != NULL);
    __DCL_ASSERT(__connected);
//  __DCL_ASSERT(inTransaction());
 
    if (!__handle->rollbackTrans()) {
        throw new SQLException(this, NULL);
    }
}
 
bool SQLConnection::inTransaction() const
{
    __DCL_ASSERT(__handle != NULL);
 
    if (__connected) {
        return __handle->inState(SQL::Connection::stInTransaction);
    }
    return false;
}
 
String SQLConnection::getServerInfo() __DCL_THROWS1(SQLException*)
{
    __DCL_ASSERT(__handle != NULL);
    __DCL_ASSERT(__connected);
 
    size_t len = 1024;
    ByteBuffer* buf = ByteBuffer::create(len);
    if (!__handle->getServerInfo(buf->data(), &len)) {
        buf->release();
        throw new SQLException(this, NULL);
    }
    buf->__dataLength = len;
    ByteString r = buf;
    buf->release();
 
    try {
        return UTF8Decoder::decode(r);
    }
    catch (CharsetConvertException* _cause) {
        throw new SQLException(this, _cause);
    }
}
 
bool SQLConnection::canTransact() const
{
    __DCL_ASSERT(__handle != NULL);
    __DCL_ASSERT(__connected);
    return __handle->canTransact();
}
 
IMPLEMENT_CLASSINFO(SQLConnectionPool, Object)
 
SQLConnectionPool::SQLConnectionPool(
    const String& _connString,
    const String& _driverName
) __DCL_THROWS1(SQLDriverException*)
// : __lock("SQLConnectionPoolLock")
{
    __DCL_ASSERT(!_connString.isEmpty());
    __DCL_ASSERT(!_driverName.isEmpty());
 
    __sqlDriver = SQLDriver::getDriver(_driverName);
    __connString = _connString;
    __idleMax = 0;
    __allMax = (size_t)-1;          // unlimited
}
 
SQLConnectionPool::~SQLConnectionPool()
{
    clear(4);
}
 
SQLConnection* SQLConnectionPool::getConnection()
    __DCL_THROWS1(SQLException*)
{
    SQLConnection* r = NULL;
    __lock.lock();
 
    try {
        if (__idleConns.isEmpty()) {
            // idle 콘넥션이 비어 있고
            // 최대 콘넥선 개수보다 작으면 새로운 콘넥션을 생성한다.
            if (__allConns.size() < __allMax) {
                r = new SQLConnection(__sqlDriver);
                try {
                    r->open(__connString);
                }
                catch(SQLException* e) {
                    delete r;
                    r = NULL;
                    throw e;
                }
                __allConns.add(r);
            }
        }
        else {
            r = (SQLConnection*)__idleConns.removeHead();
        }
    }
    catch (SQLException* e) {
        __lock.unlock();
        throw e;
    }
#ifdef __DCL_DEBUG
    catch (AssertError* e) {
        __lock.unlock();
        throw e;
    }
#endif
 
    __lock.unlock();
    return r;
}
 
void SQLConnectionPool::release(SQLConnection* _conn)
{
    __DCL_ASSERT_PARAM(_conn != NULL);
    __DCL_ASSERT(__allConns.find(_conn) != __allConns.end());
    Exception* e = NULL;
    __lock.lock();
 
    try {
        __idleConns.addTail(_conn);
        if (__idleMax < __idleConns.size()) {
            size_t nCloseCount = __idleConns.size() - __idleMax;
            while(nCloseCount--) {
                try {
                    _conn = (SQLConnection*)__idleConns.removeHead();
                    __allConns.erase(__allConns.find(_conn));
                    delete _conn;
                }
                catch(Exception* e) {
                    __DCL_TRACE1(
                        __T("SQLConnectionPool::clear(): %ls\n"),
                        e->toString().data()
                        );
                    e->destroy();
                }
            }
        }
    }
    catch (Exception* _e) {
        e = _e;
    }
 
    __lock.unlock();
    if (e != NULL) {
        throw e;
    }
}
 
bool SQLConnectionPool::setMaxCount(
    size_t _idleMax, size_t _allMax
)
{
    __DCL_ASSERT_PARAM(_idleMax >= 0 && _allMax >= 0);
 
    bool r = true;
 
    __lock.lock();
 
    __idleMax = _idleMax;
    __allMax = _allMax;
 
    __lock.unlock();
 
    return r;
}
 
void SQLConnectionPool::clear(unsigned _waitSeconds)
{
    __allMax = -1;  // set cleanup process
 
    // 콘넥션들이 release되기를 최대 _waitSeconds 초를 기다린다.
    // _waitSeconds초가 지나면 강제로 콘넥션을 제거한다.
    __lock.lock();
    while((__idleConns.size() < __allConns.size())
        && (_waitSeconds-- > 0))    {
        // 사용중인 콘넥션이 있다. 
        __lock.unlock();
        Thread::sleep(1000);   // 1초
        __lock.lock();
    }
 
    if (__idleConns.size() < __allConns.size())    {
        // 강제로 콘넥션들을 제거한다.
        __DCL_TRACE1(
                __T("Warning! SQLConnection 강제 삭제!!! count(%d)\n"),
                __allConns.size() - __idleConns.size()
                );
    }
    // else 모든 콘넥션이 idle 상태이다
 
    PointerArray::Iterator it = __allConns.begin();
    for(; it != __allConns.end(); it++)   {
        try {
            delete (SQLConnection*)((*it));
        }
        catch(Exception* e) {
            __DCL_TRACE1(
                __T("SQLConnectionPool::clear(): %ls\n"),
                e->toString().data()
                );
            e->destroy();
        }
    }
    __allConns.clear();
    __idleConns.clear();
    __lock.unlock();
}
 
__DCL_END_NAMESPACE