src/QOpenOCCI.h

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.
**
****************************************************************************/


#ifndef QOPENOCCI_H
#define QOPENOCCI_H

#include <QtSql/QtSql>

#include <iostream>
#include <memory>
#include "ocilib/ocilib.h"

using namespace std;

//Default amount of memory/rows to use for prefetching ... 1Mb/100rows
#define DEFAULT_MEMORY_PREFETCH 1048576
#define DEFAULT_ROWS_PREFETCH   100

class QOpenOCCIResult;
class QOpenOCCIDriver;

#define QOPEN_OCCI_EXCEPTION(str) (QOpenOCCIException("Error %s[%d]: %s", __FILE__, __LINE__, str))
#define MAX_ERROR_LEN 1024

class QOpenOCCIException : public std::exception {
public:
    QOpenOCCIException(char * format, ...) : std::exception() {
        va_list args;
        va_start(args, format);
        vsnprintf(error_msg, MAX_ERROR_LEN, format, args);
        va_end(args);
    }

    virtual const char * what() const throw() {return error_msg;}
    virtual ~QOpenOCCIException() throw() {};
private:
    char error_msg[MAX_ERROR_LEN];
};

//May need to just get rid of this class and use a vector inside of the Result Class...
class QOpenOCCICache
{
public:
    QOpenOCCICache(){};
    
    bool isRowCached(int row_id) { return row_id < mCache.size(); }
    void clear() { mCache.clear(); }
    
    unsigned int size() { return mCache.size(); }
    
    QVector<QVariant>&  getLastRow() { return mCache.back(); }
    QVector<QVariant>&  getRow(unsigned int row_id) { return mCache[row_id]; }
    QVector<QVariant>&  addRow() { 
        mCache.append(QVector<QVariant>()); 
        return mCache.back();
    }
    
private:
    QVector< QVector< QVariant > > mCache;
};

class QOpenOCCIBindElement {
public:
    virtual void free() = 0;
    virtual void* ptrValue() = 0;
    virtual QVariant toQVariant() const = 0;
    virtual ~QOpenOCCIBindElement() {};
    
    static char* QStringToChar(const QString& str) {
        int size = (str.isNull()) ? 4000
                                  : str.size()+1;
        char * ret = new char[size];
        memcpy(ret, str.toAscii().constData(), str.size()+1);
        return ret;
    }
    static OCI_Date* QDateToOCIDate( OCI_Connection* c, const QDate& date ){
        OCI_Date* ret = OCI_DateCreate(c);
        OCI_DateSetDate(ret, date.year(), date.month(), date.day());
        return ret;
    } 
    
    static OCI_Date* QDateToOCIDateTime( OCI_Connection* c, const QDateTime& date ){
        OCI_Date* ret = OCI_DateCreate(c);
        OCI_DateSetDate(ret, date.date().year(), date.date().month(), date.date().day());
        OCI_DateSetTime(ret, date.time().hour(), date.time().minute(), date.time().second());
        return ret;
    }
    
    static OCI_Date* QDateToOCITime( OCI_Connection* c, const QTime& time ){
        OCI_Date* ret = OCI_DateCreate(c);
        OCI_DateSetTime(ret, time.hour(), time.minute(), time.second());
        return ret;
    }
    
    static OCI_Lob* QByteArrayToBLOB( OCI_Connection* c, const QByteArray& buf ) {
        OCI_Lob* ret = OCI_LobCreate(c, OCI_BLOB);
        OCI_LobWrite(ret, (void*)buf.data(), buf.size());
        return ret;
    }
};

template <class C>
class QOpenOCCIBindElementI : public QOpenOCCIBindElement{
public:
    QOpenOCCIBindElementI(C* data);
    ~QOpenOCCIBindElementI();

    void free();
    void* ptrValue();
    QVariant toQVariant() const;

private:
    C* mData;
};

class QOpenOCCIBindData {
public:
    void add(const QString& key, QOpenOCCIBindElement* val) {
        if (mMap.contains(key)) mMap[key]->free();
        mMap[key] = val;
    }
    
    void cleanup() {
        QMapIterator<QString, QOpenOCCIBindElement*> i(mMap);
        while (i.hasNext()) {
            i.next();
            i.value()->free();
            delete i.value();
        }
        mMap.clear();
    }
    
    QOpenOCCIBindElement* operator[](const QString& key) { return mMap[key]; }
private:
    QMap<QString, QOpenOCCIBindElement*> mMap;
};



class QOpenOCCIMetadata {
public:
    QOpenOCCIMetadata(){};
    QOpenOCCIMetadata(OCI_Resultset* resultSet);
     
    struct ColumnMetadata { 
        QString name;
        QString type;
        int typeCode;
        int size;
        int precision;
        int scale;
        bool nullable;
    };
        
    QVector< ColumnMetadata > mColMetadata;
};

class QOpenOCCIResult : public QSqlResult
{
public:
    QOpenOCCIResult(
        const QSqlDriver* d               = NULL,
        OCI_Connection*   c               = NULL, 
        unsigned int      prefetch_memory = DEFAULT_MEMORY_PREFETCH, 
        unsigned int      prefetch_rows   = DEFAULT_ROWS_PREFETCH
    );
    
    ~QOpenOCCIResult();
    
protected:
    QVariant    data( int );
    bool        exec();
    bool        isNull( int );
    bool        reset ( const QString& );
    bool        fetch( int );
    bool        fetchFirst();   //boundValue issue
    bool        fetchNext();
    bool        fetchPrevious();
    bool        fetchLast();
    QSqlRecord  record() const;
    int         size()  { return -1; }
    int         numRowsAffected();
    bool        prepare ( const QString & query );
    bool        savePrepare ( const QString & query );
    void        setQuery ( const QString & query );
    
    static const char* EXEC_FAILED;
    static const char* BIND_FAILED;
private:
    void addRowToCache();
    void bind(QString name, const QVariant& val, QSql::ParamType paramType);
    void updateBoundResults();
    void cleanup();
    void rebind(int bound_index, const QVariant & val, QSql::ParamType paramType);
    
    static QVariant::Type ocilib_to_qvariant_type(int occi_type);
    
    OCI_Connection * mConnection;  
    OCI_Statement  * mStatement;   
    OCI_Resultset  * mResultSet;   
    
    QOpenOCCIMetadata           mResultMetadata;
    QOpenOCCIBindData           mBindData;
    //vector<MetaData>          mResultMetadata; ///< Oracle's column metadata
    map<QString, int>           mBindNameIndex;  
    //QMap<int, QByteArray>     mBindLobs;       ///< ByteArrays to use for lob streams
    QOpenOCCICache              mCache;          

};

class QOpenOCCIDriver : public QSqlDriver
{
public:
    QOpenOCCIDriver();
    ~QOpenOCCIDriver();
    
    bool    hasFeature( DriverFeature ) const;
    
    bool    open( const QString& db, 
                  const QString& user, 
                  const QString& password, 
                  const QString& host, 
                  int            port    = 1521, 
                  const QString& options = "");
    void    close() {}
    QSqlQuery   createQuery() const;
    QSqlResult* createResult() const;
    
    bool beginTransaction ();
    bool commitTransaction ();
    bool rollbackTransaction();
    
    static const char* CONNECTION_FAILED;
    static const char* CONNECTION_ALREADY_OPEN;
    static const char* COMMIT_FAILED;
    static const char* ROLLBACK_FAILED;
    static const char* PREFETCH_MEM_KEY;
    static const char* PREFETCH_ROWS_KEY;
    static const char* RESULT_FAILED;
private:
    static void ErrHandle(OCI_Error *err);
    void closeConnection();
    
    static int    driverCount;
    //Environment * mEnv;         ///< Oracle Environment object
    OCI_Connection * mConnection;  
    
    QMap<QString, QString>    mOptionMap; 
};
#endif

---