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

**

** 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_ibase.h"

#include <qcoreapplication.h>

#include <qdatetime.h>

#include <qvariant.h>

#include <qsqlerror.h>

#include <qsqlfield.h>

#include <qsqlindex.h>

#include <qsqlquery.h>

#include <qlist.h>

#include <qvector.h>

#include <qtextcodec.h>

#include <qmutex.h>

#include <stdlib.h>

#include <limits.h>

#include <math.h>

#include <qdebug.h>

#include <QVarLengthArray>

QT_BEGIN_NAMESPACE

#define FBVERSION SQL_DIALECT_V6

#ifndef SQLDA_CURRENT_VERSION

#define SQLDA_CURRENT_VERSION SQLDA_VERSION1

#endif

enum { QIBaseChunkSize = SHRT_MAX / 2 };

#if defined(FB_API_VER) && FB_API_VER >= 20

static bool getIBaseError(QString& msg, const ISC_STATUS* status, ISC_LONG &sqlcode, QTextCodec *tc)

#else

static bool getIBaseError(QString& msg, ISC_STATUS* status, ISC_LONG &sqlcode, QTextCodec *tc)

#endif

{

    if (status[0] != 1 || status[1] <= 0)

        return false;

    msg.clear();

    sqlcode = isc_sqlcode(status);

    char buf[512];

#if defined(FB_API_VER) && FB_API_VER >= 20

    while(fb_interpret(buf, 512, &status)) {

#else

    while(isc_interprete(buf, &status)) {

#endif

        if(!msg.isEmpty())

            msg += QLatin1String(" - ");

        if (tc)

            msg += tc->toUnicode(buf);

        else

            msg += QString::fromUtf8(buf);

    }

    return true;

}

static void createDA(XSQLDA *&sqlda)

{

    sqlda = (XSQLDA *) malloc(XSQLDA_LENGTH(1));

    if (sqlda == (XSQLDA*)0) return;

    sqlda->sqln = 1;

    sqlda->sqld = 0;

    sqlda->version = SQLDA_CURRENT_VERSION;

    sqlda->sqlvar[0].sqlind = 0;

    sqlda->sqlvar[0].sqldata = 0;

}

static void enlargeDA(XSQLDA *&sqlda, int n)

{

    if (sqlda != (XSQLDA*)0)

        free(sqlda);

    sqlda = (XSQLDA *) malloc(XSQLDA_LENGTH(n));

    if (sqlda == (XSQLDA*)0) return;

    sqlda->sqln = n;

    sqlda->version = SQLDA_CURRENT_VERSION;

}

static void initDA(XSQLDA *sqlda)

{

    for (int i = 0; i < sqlda->sqld; ++i) {

        switch (sqlda->sqlvar[i].sqltype & ~1) {

        case SQL_INT64:

        case SQL_LONG:

        case SQL_SHORT:

        case SQL_FLOAT:

        case SQL_DOUBLE:

        case SQL_TIMESTAMP:

        case SQL_TYPE_TIME:

        case SQL_TYPE_DATE:

        case SQL_TEXT:

        case SQL_BLOB:

            sqlda->sqlvar[i].sqldata = new char[sqlda->sqlvar[i].sqllen];

            break;

        case SQL_ARRAY:

            sqlda->sqlvar[i].sqldata = new char[sizeof(ISC_QUAD)];

            memset(sqlda->sqlvar[i].sqldata, 0, sizeof(ISC_QUAD));

            break;

        case SQL_VARYING:

            sqlda->sqlvar[i].sqldata = new char[sqlda->sqlvar[i].sqllen + sizeof(short)];

            break;

        default:

            // not supported - do not bind.

            sqlda->sqlvar[i].sqldata = 0;

            break;

        }

        if (sqlda->sqlvar[i].sqltype & 1) {

            sqlda->sqlvar[i].sqlind = new short[1];

            *(sqlda->sqlvar[i].sqlind) = 0;

        } else {

            sqlda->sqlvar[i].sqlind = 0;

        }

    }

}

static void delDA(XSQLDA *&sqlda)

{

    if (!sqlda)

        return;

    for (int i = 0; i < sqlda->sqld; ++i) {

        delete [] sqlda->sqlvar[i].sqlind;

        delete [] sqlda->sqlvar[i].sqldata;

    }

    free(sqlda);

    sqlda = 0;

}

static QVariant::Type qIBaseTypeName(int iType, bool hasScale)

{

    switch (iType) {

    case blr_varying:

    case blr_varying2:

    case blr_text:

    case blr_cstring:

    case blr_cstring2:

        return QVariant::String;

    case blr_sql_time:

        return QVariant::Time;

    case blr_sql_date:

        return QVariant::Date;

    case blr_timestamp:

        return QVariant::DateTime;

    case blr_blob:

        return QVariant::ByteArray;

    case blr_quad:

    case blr_short:

    case blr_long:

        return (hasScale ? QVariant::Double : QVariant::Int);

    case blr_int64:

        return (hasScale ? QVariant::Double : QVariant::LongLong);

    case blr_float:

    case blr_d_float:

    case blr_double:

        return QVariant::Double;

    }

    qWarning("qIBaseTypeName: unknown datatype: %d", iType);

    return QVariant::Invalid;

}

static QVariant::Type qIBaseTypeName2(int iType, bool hasScale)

{

    switch(iType & ~1) {

    case SQL_VARYING:

    case SQL_TEXT:

        return QVariant::String;

    case SQL_LONG:

    case SQL_SHORT:

        return (hasScale ? QVariant::Double : QVariant::Int);

    case SQL_INT64:

        return (hasScale ? QVariant::Double : QVariant::LongLong);

    case SQL_FLOAT:

    case SQL_DOUBLE:

        return QVariant::Double;

    case SQL_TIMESTAMP:

        return QVariant::DateTime;

    case SQL_TYPE_TIME:

        return QVariant::Time;

    case SQL_TYPE_DATE:

        return QVariant::Date;

    case SQL_ARRAY:

        return QVariant::List;

    case SQL_BLOB:

        return QVariant::ByteArray;

    default:

        return QVariant::Invalid;

    }

}

static ISC_TIMESTAMP toTimeStamp(const QDateTime &dt)

{

    static const QTime midnight(0, 0, 0, 0);

    static const QDate basedate(1858, 11, 17);

    ISC_TIMESTAMP ts;

    ts.timestamp_time = midnight.msecsTo(dt.time()) * 10;

    ts.timestamp_date = basedate.daysTo(dt.date());

    return ts;

}

static QDateTime fromTimeStamp(char *buffer)

{

    static const QDate bd(1858, 11, 17);

    QTime t;

    QDate d;

    // have to demangle the structure ourselves because isc_decode_time

    // strips the msecs

    t = t.addMSecs(int(((ISC_TIMESTAMP*)buffer)->timestamp_time / 10));

    d = bd.addDays(int(((ISC_TIMESTAMP*)buffer)->timestamp_date));

    return QDateTime(d, t);

}

static ISC_TIME toTime(const QTime &t)

{

    static const QTime midnight(0, 0, 0, 0);

    return (ISC_TIME)midnight.msecsTo(t) * 10;

}

static QTime fromTime(char *buffer)

{

    QTime t;

    // have to demangle the structure ourselves because isc_decode_time

    // strips the msecs

    t = t.addMSecs(int((*(ISC_TIME*)buffer) / 10));

    return t;

}

static ISC_DATE toDate(const QDate &t)

{

    static const QDate basedate(1858, 11, 17);

    ISC_DATE date;

    date = basedate.daysTo(t);

    return date;

}

static QDate fromDate(char *buffer)

{

    static const QDate bd(1858, 11, 17);

    QDate d;

    // have to demangle the structure ourselves because isc_decode_time

    // strips the msecs

    d = bd.addDays(int(((ISC_TIMESTAMP*)buffer)->timestamp_date));

    return d;

}

static QByteArray encodeString(QTextCodec *tc, const QString &str)

{

    if (tc)

        return tc->fromUnicode(str);

    return str.toUtf8();

}

struct QIBaseEventBuffer {

#if defined(FB_API_VER) && FB_API_VER >= 20

    ISC_UCHAR *eventBuffer;

    ISC_UCHAR *resultBuffer;

#else

    char *eventBuffer;

    char *resultBuffer;

#endif

    ISC_LONG bufferLength;

    ISC_LONG eventId;

    enum QIBaseSubscriptionState { Starting, Subscribed, Finished };

    QIBaseSubscriptionState subscriptionState;

};

class QIBaseDriverPrivate

{

public:

    QIBaseDriverPrivate(QIBaseDriver *d) : q(d), ibase(0), trans(0), tc(0) {}

    bool isError(const char *msg, QSqlError::ErrorType typ = QSqlError::UnknownError)

    {

        QString imsg;

        ISC_LONG sqlcode;

        if (!getIBaseError(imsg, status, sqlcode, tc))

            return false;

        q->setLastError(QSqlError(QCoreApplication::translate("QIBaseDriver", msg),

                        imsg, typ, int(sqlcode)));

        return true;

    }

public:

    QIBaseDriver* q;

    isc_db_handle ibase;

    isc_tr_handle trans;

    QTextCodec *tc;

    ISC_STATUS status[20];

    QMap<QString, QIBaseEventBuffer*> eventBuffers;

};

typedef QMap<void *, QIBaseDriver *> QIBaseBufferDriverMap;

Q_GLOBAL_STATIC(QIBaseBufferDriverMap, qBufferDriverMap)

Q_GLOBAL_STATIC(QMutex, qMutex);

static void qFreeEventBuffer(QIBaseEventBuffer* eBuffer)

{

    qMutex()->lock();

    qBufferDriverMap()->remove(reinterpret_cast<void *>(eBuffer->resultBuffer));

    qMutex()->unlock();

    delete eBuffer;

}

class QIBaseResultPrivate

{

public:

    QIBaseResultPrivate(QIBaseResult *d, const QIBaseDriver *ddb);

    ~QIBaseResultPrivate() { cleanup(); }

    void cleanup();

    bool isError(const char *msg, QSqlError::ErrorType typ = QSqlError::UnknownError)

    {

        QString imsg;

        ISC_LONG sqlcode;

        if (!getIBaseError(imsg, status, sqlcode, tc))

            return false;

        q->setLastError(QSqlError(QCoreApplication::translate("QIBaseResult", msg),

                        imsg, typ, int(sqlcode)));

        return true;

    }

    bool transaction();

    bool commit();

    bool isSelect();

    QVariant fetchBlob(ISC_QUAD *bId);

    bool writeBlob(int i, const QByteArray &ba);

    QVariant fetchArray(int pos, ISC_QUAD *arr);

    bool writeArray(int i, const QList<QVariant> &list);

public:

    QIBaseResult *q;

    const QIBaseDriver *db;

    ISC_STATUS status[20];

    isc_tr_handle trans;

    //indicator whether we have a local transaction or a transaction on driver level

    bool localTransaction;

    isc_stmt_handle stmt;

    isc_db_handle ibase;

    XSQLDA *sqlda; // output sqlda

    XSQLDA *inda; // input parameters

    int queryType;

    QTextCodec *tc;

};

QIBaseResultPrivate::QIBaseResultPrivate(QIBaseResult *d, const QIBaseDriver *ddb):

    q(d), db(ddb), trans(0), stmt(0), ibase(ddb->d->ibase), sqlda(0), inda(0), queryType(-1), tc(ddb->d->tc)

{

    localTransaction = (ddb->d->ibase == 0);

}

void QIBaseResultPrivate::cleanup()

{

    commit();

    if (!localTransaction)

        trans = 0;

    if (stmt) {

        isc_dsql_free_statement(status, &stmt, DSQL_drop);

        stmt = 0;

    }

    delDA(sqlda);

    delDA(inda);

    queryType = -1;

    q->cleanup();

}

bool QIBaseResultPrivate::writeBlob(int i, const QByteArray &ba)

{

    isc_blob_handle handle = 0;

    ISC_QUAD *bId = (ISC_QUAD*)inda->sqlvar[i].sqldata;

    isc_create_blob2(status, &ibase, &trans, &handle, bId, 0, 0);

    if (!isError(QT_TRANSLATE_NOOP("QIBaseResult", "Unable to create BLOB"),

                 QSqlError::StatementError)) {

        int i = 0;

        while (i < ba.size()) {

            isc_put_segment(status, &handle, qMin(ba.size() - i, int(QIBaseChunkSize)),

                            const_cast<char*>(ba.data()) + i);

            if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Unable to write BLOB")))

                return false;

            i += qMin(ba.size() - i, int(QIBaseChunkSize));

        }

    }

    isc_close_blob(status, &handle);

    return true;

}

QVariant QIBaseResultPrivate::fetchBlob(ISC_QUAD *bId)

{

    isc_blob_handle handle = 0;

    isc_open_blob2(status, &ibase, &trans, &handle, bId, 0, 0);

    if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Unable to open BLOB"),

                QSqlError::StatementError))

        return QVariant();

    unsigned short len = 0;

    QByteArray ba;

    int chunkSize = QIBaseChunkSize;

    ba.resize(chunkSize);

    int read = 0;

    while (isc_get_segment(status, &handle, &len, chunkSize, ba.data() + read) == 0 || status[1] == isc_segment) {

        read += len;

        ba.resize(read + chunkSize);

    }

    ba.resize(read);

    bool isErr = (status[1] == isc_segstr_eof ? false :

                    isError(QT_TRANSLATE_NOOP("QIBaseResult",

                                                "Unable to read BLOB"),

                                                QSqlError::StatementError));

    isc_close_blob(status, &handle);

    if (isErr)

        return QVariant();

    ba.resize(read);

    return ba;

}

template<typename T>

static QList<QVariant> toList(char** buf, int count, T* = 0)

{

    QList<QVariant> res;

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

        res.append(*(T*)(*buf));

        *buf += sizeof(T);

    }

    return res;

}

/* char** ? seems like bad influence from oracle ... */

template<>

QList<QVariant> toList<long>(char** buf, int count, long*)

{

    QList<QVariant> res;

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

        if (sizeof(int) == sizeof(long))

            res.append(int((*(long*)(*buf))));

        else

            res.append((qint64)(*(long*)(*buf)));

        *buf += sizeof(long);

    }

    return res;

}

static char* readArrayBuffer(QList<QVariant>& list, char *buffer, short curDim,

                             short* numElements, ISC_ARRAY_DESC *arrayDesc,

                             QTextCodec *tc)

{

    const short dim = arrayDesc->array_desc_dimensions - 1;

    const unsigned char dataType = arrayDesc->array_desc_dtype;

    QList<QVariant> valList;

    unsigned short strLen = arrayDesc->array_desc_length;

    if (curDim != dim) {

        for(int i = 0; i < numElements[curDim]; ++i)

            buffer = readArrayBuffer(list, buffer, curDim + 1, numElements,

                                     arrayDesc, tc);

    } else {

        switch(dataType) {

            case blr_varying:

            case blr_varying2:

                 strLen += 2; // for the two terminating null values

            case blr_text:

            case blr_text2: {

                int o;

                for (int i = 0; i < numElements[dim]; ++i) {

                    for(o = 0; o < strLen && buffer[o]!=0; ++o )

                        ;

                    if (tc)

                        valList.append(tc->toUnicode(buffer, o));

                    else

                        valList.append(QString::fromUtf8(buffer, o));

                    buffer += strLen;

                }

                break; }