/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtSql module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qsql_oci.h"

#include <qcoreapplication.h>

#include <qvariant.h>

#include <qdatetime.h>

#include <qmetatype.h>

#include <qregexp.h>

#include <qshareddata.h>

#include <qsqlerror.h>

#include <qsqlfield.h>

#include <qsqlindex.h>

#include <qsqlquery.h>

#include <qstringlist.h>

#include <qvarlengtharray.h>

#include <qvector.h>

#include <qdebug.h>

#include <oci.h>

#ifdef max

#undef max

#endif

#ifdef min

#undef min

#endif

#include <stdlib.h>

#define QOCI_DYNAMIC_CHUNK_SIZE 65535

#define QOCI_PREFETCH_MEM  10240

// setting this define will allow using a query from a different

// thread than its database connection.

// warning - this is not fully tested and can lead to race conditions

#define QOCI_THREADED

//#define QOCI_DEBUG

Q_DECLARE_METATYPE(OCIEnv*)

Q_DECLARE_METATYPE(OCIStmt*)

QT_BEGIN_NAMESPACE

#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN

enum { QOCIEncoding = 2002 }; // AL16UTF16LE

#else

enum { QOCIEncoding = 2000 }; // AL16UTF16

#endif

static const ub1 CSID_NCHAR = SQLCS_NCHAR;

static const ub2 qOraCharset = OCI_UCS2ID;

typedef QVarLengthArray<sb2, 32> IndicatorArray;

typedef QVarLengthArray<ub2, 32> SizeArray;

static QByteArray qMakeOraDate(const QDateTime& dt);

static QDateTime qMakeDate(const char* oraDate);

static QString qOraWarn(OCIError *err, int *errorCode = 0);

#ifndef Q_CC_SUN

static // for some reason, Sun CC can't use qOraWarning when it's declared static

#endif

void qOraWarning(const char* msg, OCIError *err);

static QSqlError qMakeError(const QString& errString, QSqlError::ErrorType type, OCIError *err);

class QOCIRowId: public QSharedData

{

public:

    QOCIRowId(OCIEnv *env);

    ~QOCIRowId();

    OCIRowid *id;

private:

    QOCIRowId(const QOCIRowId &other): QSharedData(other) { Q_ASSERT(false); }

};

QOCIRowId::QOCIRowId(OCIEnv *env)

    : id(0)

{

    OCIDescriptorAlloc (env, reinterpret_cast<dvoid **>(&id),

                        OCI_DTYPE_ROWID, 0, 0);

}

QOCIRowId::~QOCIRowId()

{

    if (id)

        OCIDescriptorFree(id, OCI_DTYPE_ROWID);

}

typedef QSharedDataPointer<QOCIRowId> QOCIRowIdPointer;

QT_BEGIN_INCLUDE_NAMESPACE

Q_DECLARE_METATYPE(QOCIRowIdPointer)

QT_END_INCLUDE_NAMESPACE

class QOCICols;

struct QOCIResultPrivate

{

    QOCIResultPrivate(QOCIResult *result, const QOCIDriverPrivate *driver);

    ~QOCIResultPrivate();

    QOCICols *cols;

    QOCIResult *q;

    OCIEnv *env;

    OCIError *err;

    OCISvcCtx *&svc;

    OCIStmt *sql;

    bool transaction;

    int serverVersion;

    int prefetchRows, prefetchMem;

    void setCharset(OCIBind* hbnd);

    void setStatementAttributes();

    int bindValue(OCIStmt *sql, OCIBind **hbnd, OCIError *err, int pos,

                  const QVariant &val, dvoid *indPtr, ub2 *tmpSize, QList<QByteArray> &tmpStorage);

    int bindValues(QVector<QVariant> &values, IndicatorArray &indicators, SizeArray &tmpSizes,

                   QList<QByteArray> &tmpStorage);

    void outValues(QVector<QVariant> &values, IndicatorArray &indicators,

                   QList<QByteArray> &tmpStorage);

    inline bool isOutValue(int i) const

    { return q->bindValueType(i) & QSql::Out; }

    inline bool isBinaryValue(int i) const

    { return q->bindValueType(i) & QSql::Binary; }

};

void QOCIResultPrivate::setStatementAttributes()

{

    Q_ASSERT(sql);

    int r = 0;

    if (prefetchRows >= 0) {

        r = OCIAttrSet(sql,

                       OCI_HTYPE_STMT,

                       &prefetchRows,

                       0,

                       OCI_ATTR_PREFETCH_ROWS,

                       err);

        if (r != 0)

            qOraWarning("QOCIResultPrivate::setStatementAttributes:"

                        " Couldn't set OCI_ATTR_PREFETCH_ROWS: ", err);

    }

    if (prefetchMem >= 0) {

        r = OCIAttrSet(sql,

                       OCI_HTYPE_STMT,

                       &prefetchMem,

                       0,

                       OCI_ATTR_PREFETCH_MEMORY,

                       err);

        if (r != 0)

            qOraWarning("QOCIResultPrivate::setStatementAttributes:"

                        " Couldn't set OCI_ATTR_PREFETCH_MEMORY: ", err);

    }

}

void QOCIResultPrivate::setCharset(OCIBind* hbnd)

{

    int r = 0;

    Q_ASSERT(hbnd);

    r = OCIAttrSet(hbnd,

                   OCI_HTYPE_BIND,

                   // this const cast is safe since OCI doesn't touch

                   // the charset.

                   const_cast<void *>(static_cast<const void *>(&qOraCharset)),

                   0,

                   OCI_ATTR_CHARSET_ID,

                   err);

    if (r != 0)

        qOraWarning("QOCIResultPrivate::setCharset: Couldn't set OCI_ATTR_CHARSET_ID: ", err);

}

int QOCIResultPrivate::bindValue(OCIStmt *sql, OCIBind **hbnd, OCIError *err, int pos,

                   const QVariant &val, dvoid *indPtr, ub2 *tmpSize, QList<QByteArray> &tmpStorage)

{

    int r = OCI_SUCCESS;

    void *data = const_cast<void *>(val.constData());

    switch (val.type()) {

    case QVariant::ByteArray:

        r = OCIBindByPos(sql, hbnd, err,

                         pos + 1,

                         isOutValue(pos)

                            ?  const_cast<char *>(reinterpret_cast<QByteArray *>(data)->constData())

                            : reinterpret_cast<QByteArray *>(data)->data(),

                         reinterpret_cast<QByteArray *>(data)->size(),

                         SQLT_BIN, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

        break;

    case QVariant::Time:

    case QVariant::Date:

    case QVariant::DateTime: {

        QByteArray ba = qMakeOraDate(val.toDateTime());

        r = OCIBindByPos(sql, hbnd, err,

                         pos + 1,

                         ba.data(),

                         ba.size(),

                         SQLT_DAT, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

        tmpStorage.append(ba);

        break; }

    case QVariant::Int:

        r = OCIBindByPos(sql, hbnd, err,

                         pos + 1,

                         // if it's an out value, the data is already detached

                         // so the const cast is safe.

                         const_cast<void *>(data),

                         sizeof(int),

                         SQLT_INT, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

        break;

    case QVariant::UInt:

        r = OCIBindByPos(sql, hbnd, err,

                         pos + 1,

                         // if it's an out value, the data is already detached

                         // so the const cast is safe.

                         const_cast<void *>(data),

                         sizeof(uint),

                         SQLT_UIN, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

        break;

    case QVariant::Double:

        r = OCIBindByPos(sql, hbnd, err,

                         pos + 1,

                         // if it's an out value, the data is already detached

                         // so the const cast is safe.

                         const_cast<void *>(data),

                         sizeof(double),

                         SQLT_FLT, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

        break;

    case QVariant::UserType:

        if (qVariantCanConvert<QOCIRowIdPointer>(val) && !isOutValue(pos)) {

            // use a const pointer to prevent a detach

            const QOCIRowIdPointer rptr = qVariantValue<QOCIRowIdPointer>(val);

            r = OCIBindByPos(sql, hbnd, err,

                             pos + 1,

                             // it's an IN value, so const_cast is ok

                             const_cast<OCIRowid **>(&rptr->id),

                             -1,

                             SQLT_RDD, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

        } else {

            qWarning("Unknown bind variable");

            r = OCI_ERROR;

        }

        break;

    case QVariant::String: {

        const QString s = val.toString();

        if (isBinaryValue(pos)) {

            r = OCIBindByPos(sql, hbnd, err,

                             pos + 1,

                             const_cast<ushort *>(s.utf16()),

                             s.length() * sizeof(QChar),

                             SQLT_LNG, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

            break;

        } else if (!isOutValue(pos)) {

            // don't detach the string

            r = OCIBindByPos(sql, hbnd, err,

                             pos + 1,

                             // safe since oracle doesn't touch OUT values

                             const_cast<ushort *>(s.utf16()),

                             (s.length() + 1) * sizeof(QChar),

                             SQLT_STR, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

            if (r == OCI_SUCCESS)

                setCharset(*hbnd);

            break;

        }

    } // fall through for OUT values

    default: {

        const QString s = val.toString();

        // create a deep-copy

        QByteArray ba(reinterpret_cast<const char *>(s.utf16()), (s.length() + 1) * sizeof(QChar));

        if (isOutValue(pos)) {

            ba.reserve((s.capacity() + 1) * sizeof(QChar));

            *tmpSize = ba.size();

            r = OCIBindByPos(sql, hbnd, err,

                             pos + 1,

                             ba.data(),

                             ba.capacity(),

                             SQLT_STR, indPtr, tmpSize, 0, 0, 0, OCI_DEFAULT);

        } else {

            r = OCIBindByPos(sql, hbnd, err,

                             pos + 1,

                             ba.data(),

                             ba.size(),

                             SQLT_STR, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

        }

        if (r == OCI_SUCCESS)

            setCharset(*hbnd);

        tmpStorage.append(ba);

        break;

    } // default case

    } // switch

    if (r != OCI_SUCCESS)

        qOraWarning("QOCIResultPrivate::bindValue:", err);

    return r;

}

int QOCIResultPrivate::bindValues(QVector<QVariant> &values, IndicatorArray &indicators,

                            SizeArray &tmpSizes, QList<QByteArray> &tmpStorage)

{

    int r = OCI_SUCCESS;

    for (int i = 0; i < values.count(); ++i) {

        if (isOutValue(i))

            values[i].detach();

        const QVariant &val = values.at(i);

        OCIBind * hbnd = 0; // Oracle handles these automatically

        sb2 *indPtr = &indicators[i];

        *indPtr = val.isNull() ? -1 : 0;

        bindValue(sql, &hbnd, err, i, val, indPtr, &tmpSizes[i], tmpStorage);

    }

    return r;

}

// will assign out value and remove its temp storage.

static void qOraOutValue(QVariant &value, QList<QByteArray> &storage)

{

    switch (value.type()) {

    case QVariant::Time:

        value = qMakeDate(storage.takeFirst()).time();

        break;

    case QVariant::Date:

        value = qMakeDate(storage.takeFirst()).date();

        break;

    case QVariant::DateTime:

        value = qMakeDate(storage.takeFirst());

        break;

    case QVariant::String:

        value = QString::fromUtf16(

                reinterpret_cast<const ushort *>(storage.takeFirst().constData()));

        break;

    default:

        break; //nothing

    }

}

void QOCIResultPrivate::outValues(QVector<QVariant> &values, IndicatorArray &indicators,

                            QList<QByteArray> &tmpStorage)

{

    for (int i = 0; i < values.count(); ++i) {

        if (!isOutValue(i))

            continue;

        qOraOutValue(values[i], tmpStorage);

        QVariant::Type typ = values.at(i).type();

        if (indicators[i] == -1) // NULL

            values[i] = QVariant(typ);

        else

            values[i] = QVariant(typ, values.at(i).constData());

    }

}

struct QOCIDriverPrivate

{

    QOCIDriverPrivate();

    OCIEnv *env;

    OCISvcCtx *svc;

    OCIServer *srvhp;

    OCISession *authp;

    OCIError *err;

    bool transaction;

    int serverVersion;

    ub4 prefetchRows;

    ub2 prefetchMem;

    QString user;

    void allocErrorHandle();

};

QOCIDriverPrivate::QOCIDriverPrivate()

    : env(0), svc(0), srvhp(0), authp(0), err(0), transaction(false), serverVersion(-1),

      prefetchRows(-1), prefetchMem(QOCI_PREFETCH_MEM)

{

}

void QOCIDriverPrivate::allocErrorHandle()

{

    int r = OCIHandleAlloc(env,

                           reinterpret_cast<void **>(&err),

                           OCI_HTYPE_ERROR,

                           0,

                           0);

    if (r != 0)

        qWarning("QOCIDriver: unable to allocate error handle");

}

struct OraFieldInfo

{

    QString name;

    QVariant::Type type;

    ub1 oraIsNull;

    ub4 oraType;

    sb1 oraScale;

    ub4 oraLength; // size in bytes

    ub4 oraFieldLength; // amount of characters

    sb2 oraPrecision;

};

QString qOraWarn(OCIError *err, int *errorCode)

{

    sb4 errcode;

    text errbuf[1024];

    errbuf[0] = 0;

    errbuf[1] = 0;

    OCIErrorGet(err,

                1,

                0,

                &errcode,

                errbuf,

                sizeof(errbuf),

                OCI_HTYPE_ERROR);

    if (errorCode)

        *errorCode = errcode;

    return QString::fromUtf16(reinterpret_cast<const ushort *>(errbuf));

}

void qOraWarning(const char* msg, OCIError *err)

{

#ifdef QOCI_DEBUG

    qWarning("%s %s", msg, qPrintable(qOraWarn(err)));

#else

    Q_UNUSED(msg);

    Q_UNUSED(err);

#endif

}

static int qOraErrorNumber(OCIError *err)

{

    sb4 errcode;

    OCIErrorGet(err,

                1,

                0,

                &errcode,

                0,

                0,

                OCI_HTYPE_ERROR);

    return errcode;

}

QSqlError qMakeError(const QString& errString, QSqlError::ErrorType type, OCIError *err)

{

    int errorCode = 0;

    const QString oraErrorString = qOraWarn(err, &errorCode);

    return QSqlError(errString, oraErrorString, type, errorCode);

}

QVariant::Type qDecodeOCIType(const QString& ocitype, QSql::NumericalPrecisionPolicy precisionPolicy)

{

    QVariant::Type type = QVariant::Invalid;

    if (ocitype == QLatin1String("VARCHAR2") || ocitype == QLatin1String("VARCHAR")

         || ocitype.startsWith(QLatin1String("INTERVAL"))

         || ocitype == QLatin1String("CHAR") || ocitype == QLatin1String("NVARCHAR2")

         || ocitype == QLatin1String("NCHAR"))

        type = QVariant::String;

    else if (ocitype == QLatin1String("NUMBER")

             || ocitype == QLatin1String("FLOAT")

             || ocitype == QLatin1String("BINARY_FLOAT")

             || ocitype == QLatin1String("BINARY_DOUBLE")) {

        switch(precisionPolicy) {

            case QSql::LowPrecisionInt32:

                type = QVariant::Int;

                break;

            case QSql::LowPrecisionInt64:

                type = QVariant::LongLong;

                break;

            case QSql::LowPrecisionDouble:

                type = QVariant::Double;

                break;

            case QSql::HighPrecision:

            default:

                type = QVariant::String;

                break;

        }

    }

    else if (ocitype == QLatin1String("LONG") || ocitype == QLatin1String("NCLOB")

             || ocitype == QLatin1String("CLOB"))

    else if (ocitype == QLatin1String("RAW") || ocitype == QLatin1String("LONG RAW")

             || ocitype == QLatin1String("ROWID") || ocitype == QLatin1String("BLOB")

             || ocitype == QLatin1String("CFILE") || ocitype == QLatin1String("BFILE"))

        type = QVariant::ByteArray;

    else if (ocitype == QLatin1String("DATE") ||  ocitype.startsWith(QLatin1String("TIME")))

        type = QVariant::DateTime;

    else if (ocitype == QLatin1String("UNDEFINED"))

        type = QVariant::Invalid;