src/QOpenOCCIDriver.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2008 Andrew White. All rights reserved.
**
** This file is part of the QOpenOCCI library.
**
** This file may be used under the terms of the GNU General Public
** License version 2.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the 
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/

#include "QOpenOCCI.h"

const char* QOpenOCCIDriver::CONNECTION_FAILED       = "QOpenOCCI: Connection Failed";
const char* QOpenOCCIDriver::CONNECTION_ALREADY_OPEN = "QOpenOCCI: Connection already open";
const char* QOpenOCCIDriver::COMMIT_FAILED           = "QOpenOCCI: Commit Failed";
const char* QOpenOCCIDriver::ROLLBACK_FAILED         = "QOpenOCCI: Rollback Failed";
const char* QOpenOCCIDriver::RESULT_FAILED           = "QOpenOCCI: Result create failed";
const char* QOpenOCCIDriver::PREFETCH_MEM_KEY        = "Prefetch_Memory";
const char* QOpenOCCIDriver::PREFETCH_ROWS_KEY       = "Prefetch_Rows";

int QOpenOCCIDriver::driverCount = 0;

QOpenOCCIDriver::QOpenOCCIDriver() : 
    QSqlDriver(),
    mConnection(NULL)
{
    if (QOpenOCCIDriver::driverCount == 0) {
        if (!OCI_Initialize(QOpenOCCIDriver::ErrHandle, NULL, OCI_ENV_DEFAULT))
            throw QOPEN_OCCI_EXCEPTION("Error: failed to initialize OCI Environment");
    }
    QOpenOCCIDriver::driverCount++;
}

QOpenOCCIDriver::~QOpenOCCIDriver()
{
    if (--QOpenOCCIDriver::driverCount == 0)
        OCI_Cleanup();
} 
void QOpenOCCIDriver::ErrHandle(OCI_Error *err)
{
    throw QOpenOCCIException("Error %s[%d]: (%05i) %s", __FILE__, 
                                                        __LINE__, 
                                                        OCI_ErrorGetOCICode(err),
                                                        OCI_ErrorGetString(err));
}
void QOpenOCCIDriver::closeConnection()
{
    if (mConnection){
        OCI_FreeConnection(mConnection);
        mConnection = NULL;
    }
}

bool QOpenOCCIDriver::open( 
    const QString& db,
    const QString& user, 
    const QString& password, 
    const QString& host, 
    int            port, 
    const QString& options) 
{
    if (isOpen() == TRUE) {
        closeConnection();
    }

    // setup our connection options... form is "key1=value1,key2=value2..."
    QStringList           optionsList( options.split(';') );        
    QString               keyValueStr;
    
    mOptionMap.clear();
    foreach (keyValueStr, optionsList) {
        QStringList keyValuePair( keyValueStr.split('=') );
        
        if (keyValuePair.size() == 2) 
            mOptionMap[keyValuePair[0]] = keyValuePair[1];
    }
    
    try {
        QString db_str = (!host.size()) ? db 
                                        : host + ':' 
                                          +  ((!port) ? "1521" 
                                                      : QString::number(port)) 
                                          + '/' + db;
        
        mConnection = OCI_CreateConnection( db_str.toAscii().data(),
                                            user.toAscii().data(), 
                                            password.toAscii().data(), 
                                            OCI_SESSION_DEFAULT );
        if (mConnection == NULL) throw QOPEN_OCCI_EXCEPTION("NULL Connection");
        
        // get the version number (this is due to a possible bug in OCILIB)
        // if this is not called the connection version number is never setup
        // and newer oracle features are disabled :(
        OCI_GetVersionServer(mConnection);
    } 
    catch (exception& e) {
        setLastError(QSqlError(CONNECTION_FAILED, e.what(), QSqlError::ConnectionError));
        setOpen(FALSE);
        setOpenError(TRUE);
        return FALSE;
    }
    
    setOpen(TRUE);
    setOpenError(FALSE);
    return TRUE;

    return FALSE; 
}

QSqlQuery QOpenOCCIDriver::createQuery() const
{
    return QSqlQuery( createResult() );
}

QSqlResult* QOpenOCCIDriver::createResult() const
{
    try {
        if (isOpen() == FALSE) throw QOPEN_OCCI_EXCEPTION("Database not opened!");
            
        unsigned int prefetch_memory = (mOptionMap.contains(PREFETCH_MEM_KEY)) 
                                     ? mOptionMap[PREFETCH_MEM_KEY].toInt()
                                     : DEFAULT_MEMORY_PREFETCH;
                                    
        unsigned int prefetch_rows   = (mOptionMap.contains(PREFETCH_ROWS_KEY)) 
                                     ? mOptionMap[PREFETCH_ROWS_KEY].toInt()
                                     : DEFAULT_ROWS_PREFETCH;    
        
        return ( new QOpenOCCIResult(this, mConnection, prefetch_memory, prefetch_rows) );
    }
    catch (exception& e) {
        return NULL;
    }
}

bool QOpenOCCIDriver::hasFeature(DriverFeature feature) const
{
    switch (feature) 
    {
        case QSqlDriver::Transactions: 
        case QSqlDriver::BLOB:
        case QSqlDriver::PreparedQueries:
        //case QSqlDriver::PositionalPlaceholders:
            return TRUE; break;
        default: return FALSE;
    }
    return FALSE;
}

bool QOpenOCCIDriver::beginTransaction()
{
    if (isOpen() == TRUE) return TRUE;
    return FALSE;
}

bool QOpenOCCIDriver::commitTransaction()
{
    try {
        if (mConnection) 
        return OCI_Commit(mConnection);
    } 
    catch (exception& e) {
        setLastError(QSqlError(COMMIT_FAILED, e.what(), QSqlError::TransactionError));
        return FALSE;
    }
    return FALSE;  
}

bool QOpenOCCIDriver::rollbackTransaction()
{
    try {
        if (mConnection) 
        return OCI_Rollback(mConnection);
    } 
    catch (exception& e) {
        setLastError(QSqlError(ROLLBACK_FAILED, e.what(), QSqlError::TransactionError));
        return FALSE;
    }
    return FALSE;  
}

---