SQLDriver.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
    #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_HAVE_THIS_FILE__
#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 +=
#ifdef __WINNT__
        __T(".dll")
#elif defined(__APPLE__)
        __T(".dylib")
#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* entryPoint = NULL;
        try {
            entryPoint = (SQL::DRIVER_MODULE*)getAddress(
                DCL_DSO_ENTRY_POINT_STRING);
        }
        catch (Exception* _cause) {
            throw new SQLDriverException(_name, _cause);
        }
 
        if (entryPoint->uSize != sizeof(SQL::DRIVER_MODULE)) {
            throw new SQLDriverException(_name,
                SQLDriverException::eInvalidDriverModule);
        }
 
        if (__VERSION_MAJOR_MINOR(entryPoint->uVersion)
                < __VERSION_MAJOR_MINOR(DCL_SQL_VERSION)) {
            throw new SQLDriverException(_name,
                SQLDriverException::eInvalidVersion);
        }
 
        if (entryPoint->pfnInitialize == NULL
            || entryPoint->pfnCleanup == NULL
            || entryPoint->pfnCreateConnectionInstance == NULL) {
            throw new SQLDriverException(_name,
                SQLDriverException::eInvalidDriverModule);
        }
 
        if (!entryPoint->pfnInitialize()) {
            throw new SQLDriverException(_name,
                SQLDriverException::eInitializeFail
            );
        }
 
        __pModuleEntryPoint = entryPoint;
        __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(", DCLCVersion:"); 
    r.format(L"%u.%u", 
        __VERSION_MAJOR(__pModuleEntryPoint->uDCLVersion),
        __VERSION_MINOR(__pModuleEntryPoint->uDCLVersion)
    );
 
    r += __T(", SQLVersion:");
    r.format(L"%u.%u",
        __VERSION_MAJOR(__pModuleEntryPoint->uVersion),
        __VERSION_MINOR(__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", Description:";
        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* driver = NULL;
    // find previous loaded module
    for (PointerArray::Iterator it = __drivers.begin();
        it != __drivers.end(); it++) {
        if (!((SQLDriver*)(*it))->driverName().compareNoCase(name)) {
            driver = (SQLDriver*)(*it);
            break;
        }
    }
 
    if (!driver) {
        // not found. load new driver
        __DCL_TRACE2(
            __T("Open New SQLDriver: %ls, Prev-Count: %d\n"),
            name.data(),
            __drivers.size()
            );
 
        driver = new SQLDriver(_name);
        __drivers.add(driver);
    }
 
    return driver;
}
 
void SQLDriverPool::clearAll()
{
    // unload all drivers
    SQLDriver* driver = NULL;
    for(PointerArray::Iterator it = __drivers.begin();
        it != __drivers.end(); it++) {      
        driver = (SQLDriver*)(*it);
        __DCL_ASSERT(driver->refCount() == 0);
 
        try {
            driver->close();
            __DCL_TRACE3(__T("Close SQLDriver:%p, %ls (%ls)\n"),
                driver,
                driver->driverName().data(),
                driver->fileName().data()
            );
        }
        catch (Exception* e) {
            __DCL_TRACE2(__T("Wrining!! SQLDriver Close Fail! :%p, %ls\n"),
                driver,
                e->toString().data()
            );
            e->destroy();
        }
 
        delete driver;
    }
 
    __drivers.clear();
}
 
void SQLDriverPool::clear(SQLDriver* driver)
    __DCL_THROWS1(SQLDriverException*)
{
    PointerArray::Iterator it = __drivers.find(driver);
    __DCL_ASSERT(__drivers.end() != it);
    __drivers.erase(it);
 
    Exception* e = NULL;
    try {
        driver->close();
        __DCL_TRACE3(__T("Close SQLDriver:%p, %ls (%ls)\n"),
            driver,
            driver->driverName().data(),
            driver->fileName().data()
        );
    }
    catch (Exception* _e) {
        e = _e;
    }
 
    delete driver;
 
    if (e != NULL) {
        throw e;
    }
}
 
// SQLDriver's static members
extern LibState*        __LibState__;
static SQLDriverPool*  __DriverPool__ = NULL;
 
static void cleanupDriverContext()
{
    if (__DriverPool__ == NULL)
        return;
 
    __LibState__->lockSQLDriverPool.lock();
 
    __DriverPool__->clearAll();
    delete __DriverPool__;
    __DriverPool__ = NULL;  
 
    __LibState__->lockSQLDriverPool.unlock();
}
 
SQLDriver* SQLDriver::getDriver(const String& _name)
    __DCL_THROWS1(SQLDriverException*)
{
    SQLDriver* r = NULL;
    Exception* e = NULL;
 
    __LibState__->lockSQLDriverPool.lock();
    try {
        if (__DriverPool__ == NULL) {
            __DriverPool__ = new SQLDriverPool();
            __LibState__->pfnSQLCleanup = cleanupDriverContext;
        }
        __DCL_ASSERT(__DriverPool__ != NULL);
 
        r = __DriverPool__->getDriver(_name);
    }
    catch (Exception* _e) {
        e = _e;
    }   
    __LibState__->lockSQLDriverPool.unlock();
 
    if (e != NULL) {
        throw e;
    }
 
    return r;
}
 
void SQLDriver::closeDriver(SQLDriver* _driver)
    __DCL_THROWS1(SQLDriverException*)
{
    __DCL_ASSERT(_driver);
    __DCL_ASSERT(_driver->refCount() == 0);
    __DCL_ASSERT(__DriverPool__ != NULL);
 
    Exception* e = NULL;
 
    __LibState__->lockSQLDriverPool.lock();
    try {
        __DriverPool__->clear(_driver);
    }
    catch (Exception* _e) {
        e = _e;
    }
    __LibState__->lockSQLDriverPool.unlock();
 
    if (e != NULL) {
        throw e;
    }
}
 
__DCL_END_NAMESPACE