SQLDriver.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#if __DCL_WINDOWS
    #include <windows.h>
#else
    #include <dlfcn.h>
#endif
 
#include <dcl/_stdlib.h>   // getenv
 
#include <dcl/Object.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/String.h>
#include <dcl/Array.h>
#include <dcl/Thread.h>
#include <dcl/SQLCore.h>
#include <dcl/SQLDriver.h>
 
#include "LibState.h"
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/SQLDriver.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE

IMPLEMENT_CLASSINFO(SQLDriverException, DllException)
 
SQLDriverException::SQLDriverException(const String& _name, Exception* _cause)
    : Exception(_cause), __name(_name)
{
}
 
SQLDriverException::SQLDriverException(const String& _name, ErrorCode _errorCode)
    : __name(_name), __errorCode(_errorCode)
{
}
 
SQLDriverException::SQLDriverException(const String& _name, ErrorCode _errorCode,
                const String& _driverSummary)
    : __name(_name), __errorCode(_errorCode), __driverSummary(_driverSummary)
{
}
 
String SQLDriverException::toString() const
{
    StringBuilder r = __name;
 
    r += __T(": ");
 
    if (Exception::cause() != NULL) {
        r += Exception::toString();
    }
    else {
        switch (__errorCode) {
            case eInvalidDriverModule:
                r += __T("Invalid Driver Module");
                break;
            case eInvalidVersion:
                r += __T("Invalid DCL_SQL_VERSION");
                break;
            case eInitializeFail:
                r += __T("Initialize callback fail!");
                break;
            case eCleanupFail:
                r += __T("cleanup callback falil");
                break;
            default:
                __DCL_ASSERT(false);
        }
 
        if (!__driverSummary.isEmpty())
            r += __T(" :") + __driverSummary;
    }
 
    return r;
}

IMPLEMENT_CLASSINFO(SQLDriver, Dll)
long SQLDriver::addRef()
{
    long n = Thread::incrementAndGet(__refCount);
    return n;
}
 
long SQLDriver::release()
{
    __DCL_ASSERT(__refCount > 0);   // __DCL_ASSERT_VALID(this);
    long n = Thread::decrementAndGet(__refCount);
    return n;
}
 
SQLDriver::SQLDriver(const String& _name)
        __DCL_THROWS1(SQLDriverException*)
{
    __refCount = 0;
    __pModuleEntryPoint = NULL;
    open(_name);
}
 
SQLDriver::~SQLDriver()
{
    if (__pModuleEntryPoint) {
        try {
            close();
        }
        catch (SQLDriverException* e) {
            __DCL_TRACE1(L"Warning SQLDriver::close fail! %ls\n",
                e->toString().data());
            e->destroy();
        }
    }
}
 
void SQLDriver::open(const String& _name)
        __DCL_THROWS1(SQLDriverException*)
{
    __DCL_ASSERT(__pModuleEntryPoint == NULL);
 
    StringBuilder filename = _name
#ifdef __DCL_DEBUG
        + __T("d")
#elif defined(_DEBUG)
        + __T("dd")
#endif
        ;
        
    filename +=
#if __DCL_WINDOWS
        __T(".dll")
#else
        __T(".so")
#endif
        ;
 
    int flags = Dll::DEFAULT
 #ifdef RTLD_LAZY
        | RTLD_LAZY
 #endif
        ;
 
    try {
        Dll::open(filename.toString(), flags);
    }
    catch (Exception* cause) {
        throw new SQLDriverException(_name, cause);
    }
 
    try {
        SQL::DRIVER_MODULE* pEntryPoint = NULL;
        try {
            pEntryPoint = (SQL::DRIVER_MODULE*)getAddress(
                DCL_DSO_ENTRY_POINT_STRING);
        }
        catch (Exception* cause) {
            throw new SQLDriverException(_name, cause);
        }
 
        if (pEntryPoint->uSize != sizeof(SQL::DRIVER_MODULE)) {
            throw new SQLDriverException(_name,
                SQLDriverException::eInvalidDriverModule);
        }
 
        if (pEntryPoint->uDCLVersion != DCL_VERSION
            || pEntryPoint->uBuildFlag != DCL_BUILD_FLAG) {
            throw new SQLDriverException(_name,
                SQLDriverException::eInvalidDriverModule);
        }
 
        if (pEntryPoint->uVersion != DCL_SQL_VERSION) {
            throw new SQLDriverException(_name,
                SQLDriverException::eInvalidVersion);
        }
 
        if (pEntryPoint->pfnInitialize == NULL
            || pEntryPoint->pfnCleanup == NULL
            || pEntryPoint->pfnCreateConnectionInstance == NULL) {
            throw new SQLDriverException(_name,
                SQLDriverException::eInvalidDriverModule);
        }
 
        if (!pEntryPoint->pfnInitialize()) {
            throw new SQLDriverException(_name,
                SQLDriverException::eInitializeFail
            );
        }
 
        __pModuleEntryPoint = pEntryPoint;
        __driverName = _name;
 
        __DCL_TRACE3(__T("Open SQLDriver: %ls (%ls, %ls)\n"),
            _name.data(),
            filename.data(),
            getDriverSummary().data()
        );
    }
    catch (Exception* e) {
        try {
            Dll::close();
        }
        catch (Exception* _nt) {
            _nt->destroy();
        }
        throw e;
    }
}
 
void SQLDriver::close()
    __DCL_THROWS1(SQLDriverException*)
{
    Exception* e = NULL;
    try {
        __DCL_ASSERT(refCount() == 0);
        __DCL_ASSERT(__pModuleEntryPoint != NULL);
 
        SQL::DRIVER_MODULE* pEntryPoint = __pModuleEntryPoint;
        __pModuleEntryPoint = NULL;
 
        if (!pEntryPoint->pfnCleanup()) {
            throw new SQLDriverException(__driverName,
                SQLDriverException::eCleanupFail,
                getDriverSummary()
            );
        }
    }
    catch (Exception* _e) {
        e = _e;
    }
 
    try {
        Dll::close();
    }
    catch (Exception* _e) {
        if (e != NULL) {
            __DCL_TRACE1(L"%ls", _e->toString().data());
            throw e;
        }
        else {
            throw new SQLDriverException(__driverName, _e);
        }
    }
}
 
SQL::Connection* SQLDriver::createConnection() 
{
    __DCL_ASSERT(__pModuleEntryPoint != NULL);
    SQL::Connection* pNewConnection = 
        __pModuleEntryPoint->pfnCreateConnectionInstance();
    addRef();
    return pNewConnection;
}
 
void SQLDriver::destroyConnection(SQL::Connection* pConnection)
{
    pConnection->destroy();
    release();
}
 
String SQLDriver::getDriverSummary() const
{
    __DCL_ASSERT(__pModuleEntryPoint != NULL);
 
    StringBuilder r = __T("DriverName:") + __driverName;
    r += __T(", FileName:") + Dll::__filename;
 
    r += __T(", DCLVersion:"); 
    r.format(L"%u.%u", 
                    DCL_MAJOR_VERSION(__pModuleEntryPoint->uDCLVersion),
                    DCL_MINOR_VERSION(__pModuleEntryPoint->uDCLVersion)
                    );
 
    r += __T(", InterfaceVersion:");
    r.format(L"%u.%u",
                    DCL_MAJOR_VERSION(__pModuleEntryPoint->uVersion),
                    DCL_MINOR_VERSION(__pModuleEntryPoint->uVersion)
                    );
 
    r += L", Build:";
    r += __pModuleEntryPoint->uBuildFlag ? L"Debug" : L"Release";
    if (__pModuleEntryPoint->pszBuildTimeStamp) {
        r += L" ";
        r += __pModuleEntryPoint->pszBuildTimeStamp;
    }
 
    if (__pModuleEntryPoint->pfnInitialize == NULL)
        r += L", pfnInitialize: (null)";
    if (__pModuleEntryPoint->pfnInitialize == NULL)
        r += L", pfnCleanup: (null)";
    if (__pModuleEntryPoint->pfnCreateConnectionInstance == NULL)
        r += L", pfnCreateConnectionInstance: (null)";
 
    if (__pModuleEntryPoint->pszFileVersion) {
        r += L", FileVersion:";
        r += __pModuleEntryPoint->pszFileVersion;
    }
 
    if (__pModuleEntryPoint->pszServerTitle) {
        r += L", ServerTitle:";
        r += __pModuleEntryPoint->pszServerTitle;
    }
 
    if (__pModuleEntryPoint->pszDescription) {
        r += L", Desc:";
        r += __pModuleEntryPoint->pszDescription;
    }
    return r;
}
 
class DCLCAPI SQLDriverPool : public Object
{
    DECLARE_CLASSINFO(SQLDriverPool)
protected:
    PointerArray    __drivers;
public:
    SQLDriver* getDriver(const String& _name)
        __DCL_THROWS1(SQLDriverException*);
 
    void clearAll();
    void clear(SQLDriver* pDriver)
        __DCL_THROWS1(SQLDriverException*);
 
    bool isEmpty() const { return __drivers.isEmpty(); }
};
 
IMPLEMENT_CLASSINFO(SQLDriverPool, Object)
 
SQLDriver* SQLDriverPool::getDriver(const String& _name)
    __DCL_THROWS1(SQLDriverException*)
{
    String name = _name.trim();
 
    SQLDriver* pSQLDriver = NULL;
    // find previous loaded module
    for (PointerArray::Iterator it = __drivers.begin();
        it != __drivers.end(); it++) {
        if (!((SQLDriver*)(*it))->driverName().compareNoCase(name)) {
            pSQLDriver = (SQLDriver*)(*it);
            break;
        }
    }
 
    if (!pSQLDriver) {
        // not found. load new driver
        __DCL_TRACE2(
            __T("Open New SQLDriver: %ls, Prev-Count: %d\n"),
            name.data(),
            __drivers.size()
            );
 
        pSQLDriver = new SQLDriver(_name);
        __drivers.add(pSQLDriver);
    }
    
    return pSQLDriver;
}
 
void SQLDriverPool::clearAll()
{
    // unload all drivers
    SQLDriver* pSQLDriver = NULL;
    for(PointerArray::Iterator it = __drivers.begin();
        it != __drivers.end(); it++) {      
        pSQLDriver = (SQLDriver*)(*it);
        __DCL_ASSERT(pSQLDriver->refCount() == 0);
 
        try {
            pSQLDriver->close();
            __DCL_TRACE3(__T("Close SQLDriver:%p, %ls (%ls)\n"),
                pSQLDriver,
                pSQLDriver->driverName().data(),
                pSQLDriver->fileName().data()
            );
        }
        catch (Exception* e) {
            __DCL_TRACE2(__T("Wrining!! SQLDriver Close Fail! :%p, %ls\n"),
                pSQLDriver,
                e->toString().data()
            );
            e->destroy();
        }
 
        delete pSQLDriver;
    }
    
    __drivers.clear();
}
 
void SQLDriverPool::clear(SQLDriver* pSQLDriver)
        __DCL_THROWS1(SQLDriverException*)
{
    PointerArray::Iterator it = __drivers.find(pSQLDriver);
    __DCL_ASSERT(__drivers.end() != it);
    __drivers.erase(it);
 
    Exception* e = NULL;
    try {
        pSQLDriver->close();
        __DCL_TRACE3(__T("Close SQLDriver:%p, %ls (%ls)\n"),
            pSQLDriver,
            pSQLDriver->driverName().data(),
            pSQLDriver->fileName().data()
        );
    }
    catch (Exception* _e) {
        e = _e;
    }
 
    delete pSQLDriver;
 
    if (e != NULL) {
        throw e;
    }
}
 
// SQLDriver's static members
extern LibState*    __pLibState;
static SQLDriverPool* __pDriverPool = NULL;
 
static void cleanupDriverContext()
{
    if (__pDriverPool == NULL)
        return;
    
    __pLibState->lockSQLDriverPool.lock();
 
    __pDriverPool->clearAll();
    delete __pDriverPool;
    __pDriverPool = NULL;   
    
    __pLibState->lockSQLDriverPool.unlock();
}
 
SQLDriver* SQLDriver::getDriver(const String& _name)
        __DCL_THROWS1(SQLDriverException*)
{
    SQLDriver* r = NULL;
    Exception* e = NULL;
 
    __pLibState->lockSQLDriverPool.lock();
    try {
        if (__pDriverPool == NULL) {
            __pDriverPool = new SQLDriverPool();
            __pLibState->pfnSQLCleanup = cleanupDriverContext;
        }
        __DCL_ASSERT(__pDriverPool != NULL);
    
        r = __pDriverPool->getDriver(_name);
    }
    catch (Exception* _e) {
        e = _e;
    }   
    __pLibState->lockSQLDriverPool.unlock();
 
    if (e != NULL) {
        throw e;
    }
 
    return r;
}
 
void SQLDriver::closeDriver(SQLDriver* _pSQLDriver)
        __DCL_THROWS1(SQLDriverException*)
{
    __DCL_ASSERT(_pSQLDriver);
    __DCL_ASSERT(_pSQLDriver->refCount() == 0);
    __DCL_ASSERT(__pDriverPool != NULL);
 
    Exception* e = NULL;
 
    __pLibState->lockSQLDriverPool.lock();
    try {
        __pDriverPool->clear(_pSQLDriver);
    }
    catch (Exception* _e) {
        e = _e;
    }
    __pLibState->lockSQLDriverPool.unlock();
 
    if (e != NULL) {
        throw e;
    }
}
 
__DCL_END_NAMESPACE