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

**

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

#include <qcoreapplication.h>

#include <qdatetime.h>

#include <qsqlfield.h>

#include <qsqlerror.h>

#include <qsqlindex.h>

#include <qsqlrecord.h>

#include <qstringlist.h>

#include <qvarlengtharray.h>

#include <qvector.h>

#include <QDebug>

#if defined(Q_CC_BOR)

// DB2's sqlsystm.h (included through sqlcli1.h) defines the SQL_BIGINT_TYPE

// and SQL_BIGUINT_TYPE to wrong the types for Borland; so do the defines to

// the right type before including the header

#define SQL_BIGINT_TYPE qint64

#define SQL_BIGUINT_TYPE quint64

#endif

#define UNICODE

#include <sqlcli1.h>

#include <string.h>

QT_BEGIN_NAMESPACE

static const int COLNAMESIZE = 255;

static const SQLSMALLINT qParamType[4] = { SQL_PARAM_INPUT, SQL_PARAM_INPUT, SQL_PARAM_OUTPUT, SQL_PARAM_INPUT_OUTPUT };

class QDB2DriverPrivate

{

public:

    QDB2DriverPrivate(): hEnv(0), hDbc(0) {}

    SQLHANDLE hEnv;

    SQLHANDLE hDbc;

    QString user;

};

class QDB2ResultPrivate

{

public:

    QDB2ResultPrivate(const QDB2DriverPrivate* d): dp(d), hStmt(0)

    {}

    ~QDB2ResultPrivate()

    {

        emptyValueCache();

    }

    void clearValueCache()

    {

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

            delete valueCache[i];

            valueCache[i] = NULL;

        }

    }

    void emptyValueCache()

    {

        clearValueCache();

        valueCache.clear();

    }

    const QDB2DriverPrivate* dp;

    SQLHANDLE hStmt;

    QSqlRecord recInf;

    QVector<QVariant*> valueCache;

};

static QString qFromTChar(SQLTCHAR* str)

{

    return QString::fromUtf16(str);

}

// dangerous!! (but fast). Don't use in functions that

// require out parameters!

static SQLTCHAR* qToTChar(const QString& str)

{

    return (SQLTCHAR*)str.utf16();

}

static QString qWarnDB2Handle(int handleType, SQLHANDLE handle)

{

    SQLINTEGER nativeCode;

    SQLSMALLINT msgLen;

    SQLRETURN r = SQL_ERROR;

    SQLTCHAR state[SQL_SQLSTATE_SIZE + 1];

    SQLTCHAR description[SQL_MAX_MESSAGE_LENGTH];

    r = SQLGetDiagRec(handleType,

                       handle,

                       1,

                       (SQLTCHAR*) state,

                       &nativeCode,

                       (SQLTCHAR*) description,

                       SQL_MAX_MESSAGE_LENGTH - 1, /* in bytes, not in characters */

                       &msgLen);

    if (r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO)

        return QString(qFromTChar(description));

    return QString();

}

static QString qDB2Warn(const QDB2DriverPrivate* d)

{

    return (qWarnDB2Handle(SQL_HANDLE_ENV, d->hEnv) + QLatin1Char(' ')

             + qWarnDB2Handle(SQL_HANDLE_DBC, d->hDbc));

}

static QString qDB2Warn(const QDB2ResultPrivate* d)

{

    return (qWarnDB2Handle(SQL_HANDLE_ENV, d->dp->hEnv) + QLatin1Char(' ')

             + qWarnDB2Handle(SQL_HANDLE_DBC, d->dp->hDbc)

             + qWarnDB2Handle(SQL_HANDLE_STMT, d->hStmt));

}

static void qSqlWarning(const QString& message, const QDB2DriverPrivate* d)

{

    qWarning("%s\tError: %s", message.toLocal8Bit().constData(),

                              qDB2Warn(d).toLocal8Bit().constData());

}

static void qSqlWarning(const QString& message, const QDB2ResultPrivate* d)

{

    qWarning("%s\tError: %s", message.toLocal8Bit().constData(),

                              qDB2Warn(d).toLocal8Bit().constData());

}

static QSqlError qMakeError(const QString& err, QSqlError::ErrorType type,

                            const QDB2DriverPrivate* p)

{

    return QSqlError(QLatin1String("QDB2: ") + err, qDB2Warn(p), type);

}

static QSqlError qMakeError(const QString& err, QSqlError::ErrorType type,

                            const QDB2ResultPrivate* p)

{

    return QSqlError(QLatin1String("QDB2: ") + err, qDB2Warn(p), type);

}

static QVariant::Type qDecodeDB2Type(SQLSMALLINT sqltype)

{

    QVariant::Type type = QVariant::Invalid;

    switch (sqltype) {

    case SQL_REAL:

    case SQL_FLOAT:

    case SQL_DOUBLE:

    case SQL_DECIMAL:

    case SQL_NUMERIC:

        type = QVariant::Double;

        break;

    case SQL_SMALLINT:

    case SQL_INTEGER:

    case SQL_BIT:

    case SQL_TINYINT:

        type = QVariant::Int;

        break;

    case SQL_BIGINT:

        type = QVariant::LongLong;

        break;

    case SQL_BLOB:

    case SQL_BINARY:

    case SQL_VARBINARY:

    case SQL_LONGVARBINARY:

    case SQL_CLOB:

    case SQL_DBCLOB:

        type = QVariant::ByteArray;

        break;

    case SQL_DATE:

    case SQL_TYPE_DATE:

        type = QVariant::Date;

        break;

    case SQL_TIME:

    case SQL_TYPE_TIME:

        type = QVariant::Time;

        break;

    case SQL_TIMESTAMP:

    case SQL_TYPE_TIMESTAMP:

        type = QVariant::DateTime;

        break;

    case SQL_WCHAR:

    case SQL_WVARCHAR:

    case SQL_WLONGVARCHAR:

    case SQL_CHAR:

    case SQL_VARCHAR:

    case SQL_LONGVARCHAR:

        type = QVariant::String;

        break;

    default:

        type = QVariant::ByteArray;

        break;

    }

    return type;

}

static QSqlField qMakeFieldInfo(const QDB2ResultPrivate* d, int i)

{

    SQLSMALLINT colNameLen;

    SQLSMALLINT colType;

    SQLUINTEGER colSize;

    SQLSMALLINT colScale;

    SQLSMALLINT nullable;

    SQLRETURN r = SQL_ERROR;

    SQLTCHAR colName[COLNAMESIZE];

    r = SQLDescribeCol(d->hStmt,

                        i+1,

                        colName,

                        (SQLSMALLINT) COLNAMESIZE,

                        &colNameLen,

                        &colType,

                        &colSize,

                        &colScale,

                        &nullable);

    if (r != SQL_SUCCESS) {

        qSqlWarning(QString::fromLatin1("qMakeFieldInfo: Unable to describe column %1").arg(i), d);

        return QSqlField();

    }

    QSqlField f(qFromTChar(colName), qDecodeDB2Type(colType));

    // nullable can be SQL_NO_NULLS, SQL_NULLABLE or SQL_NULLABLE_UNKNOWN

    if (nullable == SQL_NO_NULLS)

        f.setRequired(true);

    else if (nullable == SQL_NULLABLE)

        f.setRequired(false);

    // else required is unknown

    f.setLength(colSize == 0 ? -1 : int(colSize));

    f.setPrecision(colScale == 0 ? -1 : int(colScale));

    f.setSqlType(int(colType));

    return f;

}

static int qGetIntData(SQLHANDLE hStmt, int column, bool& isNull)

{

    SQLINTEGER intbuf;

    isNull = false;

    SQLINTEGER lengthIndicator = 0;

    SQLRETURN r = SQLGetData(hStmt,

                              column + 1,

                              SQL_C_SLONG,

                              (SQLPOINTER) &intbuf,

                              0,

                              &lengthIndicator);

    if ((r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) || lengthIndicator == SQL_NULL_DATA) {

        isNull = true;

        return 0;

    }

    return int(intbuf);

}

static double qGetDoubleData(SQLHANDLE hStmt, int column, bool& isNull)

{

    SQLDOUBLE dblbuf;

    isNull = false;

    SQLINTEGER lengthIndicator = 0;

    SQLRETURN r = SQLGetData(hStmt,

                              column+1,

                              SQL_C_DOUBLE,

                              (SQLPOINTER) &dblbuf,

                              0,

                              &lengthIndicator);

    if ((r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) || lengthIndicator == SQL_NULL_DATA) {

        isNull = true;

        return 0.0;

    }

    return (double) dblbuf;

}

static SQLBIGINT qGetBigIntData(SQLHANDLE hStmt, int column, bool& isNull)

{

    SQLBIGINT lngbuf = Q_INT64_C(0);

    isNull = false;

    SQLINTEGER lengthIndicator = 0;

    SQLRETURN r = SQLGetData(hStmt,

                              column+1,

                              SQL_C_SBIGINT,

                              (SQLPOINTER) &lngbuf,

                              0,

                              &lengthIndicator);

    if ((r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) || lengthIndicator == SQL_NULL_DATA)

        isNull = true;

    return lngbuf;

}

static QString qGetStringData(SQLHANDLE hStmt, int column, int colSize, bool& isNull)

{

    QString     fieldVal;

    SQLRETURN   r = SQL_ERROR;

    SQLINTEGER  lengthIndicator = 0;

    if (colSize <= 0)

        colSize = 255;

    else if (colSize > 65536) // limit buffer size to 64 KB

        colSize = 65536;

    else

        colSize++; // make sure there is room for more than the 0 termination

    SQLTCHAR* buf = new SQLTCHAR[colSize];

    while (true) {

        r = SQLGetData(hStmt,

                        column + 1,

                        SQL_C_WCHAR,

                        (SQLPOINTER)buf,

                        colSize * sizeof(SQLTCHAR),

                        &lengthIndicator);

        if (r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) {

            if (lengthIndicator == SQL_NULL_DATA || lengthIndicator == SQL_NO_TOTAL) {

                fieldVal.clear();

                isNull = true;

                break;

            }

            fieldVal += qFromTChar(buf);

        } else if (r == SQL_NO_DATA) {

            break;

        } else {

            qWarning("qGetStringData: Error while fetching data (%d)", r);

            fieldVal.clear();

            break;

        }

    }

    delete[] buf;

    return fieldVal;

}

static QByteArray qGetBinaryData(SQLHANDLE hStmt, int column, SQLINTEGER& lengthIndicator, bool& isNull)

{

    QByteArray fieldVal;

    SQLSMALLINT colNameLen;

    SQLSMALLINT colType;

    SQLUINTEGER colSize;

    SQLSMALLINT colScale;

    SQLSMALLINT nullable;

    SQLRETURN r = SQL_ERROR;

    SQLTCHAR colName[COLNAMESIZE];

    r = SQLDescribeCol(hStmt,

                        column+1,

                        colName,

                        COLNAMESIZE,

                        &colNameLen,

                        &colType,

                        &colSize,

                        &colScale,

                        &nullable);

    if (r != SQL_SUCCESS)

        qWarning("qGetBinaryData: Unable to describe column %d", column);

    // SQLDescribeCol may return 0 if size cannot be determined

    if (!colSize)

        colSize = 255;

    else if (colSize > 65536) // read the field in 64 KB chunks

        colSize = 65536;

    char * buf = new char[colSize];

    while (true) {

        r = SQLGetData(hStmt,

                        column+1,

                        colType == SQL_DBCLOB ? SQL_C_CHAR : SQL_C_BINARY,

                        (SQLPOINTER) buf,

                        colSize,

                        &lengthIndicator);

        if (r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) {

            if (lengthIndicator == SQL_NULL_DATA) {

                isNull = true;

                break;

            } else {

                int rSize;

                r == SQL_SUCCESS ? rSize = lengthIndicator : rSize = colSize;

                if (lengthIndicator == SQL_NO_TOTAL) // size cannot be determined

                    rSize = colSize;

                fieldVal.append(QByteArray(buf, rSize));

                if (r == SQL_SUCCESS) // the whole field was read in one chunk

                    break;

            }

        } else {

            break;

        }

    }

    delete [] buf;

    return fieldVal;

}

static void qSplitTableQualifier(const QString & qualifier, QString * catalog,

                                  QString * schema, QString * table)

{

    if (!catalog || !schema || !table)

        return;

    QStringList l = qualifier.split(QLatin1Char('.'));

    if (l.count() > 3)

        return; // can't possibly be a valid table qualifier

    int i = 0, n = l.count();

    if (n == 1) {

        *table = qualifier;

    } else {

        for (QStringList::Iterator it = l.begin(); it != l.end(); ++it) {

            if (n == 3) {

                if (i == 0)

                    *catalog = *it;

                else if (i == 1)

                    *schema = *it;

                else if (i == 2)

                    *table = *it;

            } else if (n == 2) {

                if (i == 0)

                    *schema = *it;

                else if (i == 1)

                    *table = *it;

            }

            i++;

        }

    }

}

// creates a QSqlField from a valid hStmt generated

// by SQLColumns. The hStmt has to point to a valid position.

static QSqlField qMakeFieldInfo(const SQLHANDLE hStmt)

{

    bool isNull;

    int type = qGetIntData(hStmt, 4, isNull);

    QSqlField f(qGetStringData(hStmt, 3, -1, isNull), qDecodeDB2Type(type));

    int required = qGetIntData(hStmt, 10, isNull); // nullable-flag

    // required can be SQL_NO_NULLS, SQL_NULLABLE or SQL_NULLABLE_UNKNOWN

    if (required == SQL_NO_NULLS)

        f.setRequired(true);

    else if (required == SQL_NULLABLE)

        f.setRequired(false);

    // else we don't know.

    f.setLength(qGetIntData(hStmt, 6, isNull)); // column size

    f.setPrecision(qGetIntData(hStmt, 8, isNull)); // precision

    f.setSqlType(type);

    return f;

}

static bool qMakeStatement(QDB2ResultPrivate* d, bool forwardOnly, bool setForwardOnly = true)

{

    SQLRETURN r;

    if (!d->hStmt) {

        r = SQLAllocHandle(SQL_HANDLE_STMT,

                            d->dp->hDbc,

                            &d->hStmt);

        if (r != SQL_SUCCESS) {

            qSqlWarning(QLatin1String("QDB2Result::reset: Unable to allocate statement handle"), d);

            return false;

        }

    } else {

        r = SQLFreeStmt(d->hStmt, SQL_CLOSE);

        if (r != SQL_SUCCESS) {

            qSqlWarning(QLatin1String("QDB2Result::reset: Unable to close statement handle"), d);

            return false;

        }

    }

    if (!setForwardOnly)

        return true;

    if (forwardOnly) {

        r = SQLSetStmtAttr(d->hStmt,

                            SQL_ATTR_CURSOR_TYPE,

                            (SQLPOINTER) SQL_CURSOR_FORWARD_ONLY,

                            SQL_IS_UINTEGER);

    } else {

        r = SQLSetStmtAttr(d->hStmt,

                            SQL_ATTR_CURSOR_TYPE,

                            (SQLPOINTER) SQL_CURSOR_STATIC,

                            SQL_IS_UINTEGER);

    }

    if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {

        qSqlWarning(QString::fromLatin1("QDB2Result::reset: Unable to set %1 attribute.").arg(

                     forwardOnly ? QLatin1String("SQL_CURSOR_FORWARD_ONLY")

                                 : QLatin1String("SQL_CURSOR_STATIC")), d);

        return false;

    }

    return true;

}

QVariant QDB2Result::handle() const

{

    return QVariant(qRegisterMetaType<SQLHANDLE>("SQLHANDLE"), &d->hStmt);

}

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

QDB2Result::QDB2Result(const QDB2Driver* dr, const QDB2DriverPrivate* dp)

    : QSqlResult(dr)

{

    d = new QDB2ResultPrivate(dp);

}

QDB2Result::~QDB2Result()

{

    if (d->hStmt) {