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

**

** Copyright (C) 2009 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_odbc.h"

#include <qsqlrecord.h>

#if defined (Q_OS_WIN32)

#include <qt_windows.h>

#endif

#include <qcoreapplication.h>

#include <qvariant.h>

#include <qdatetime.h>

#include <qsqlerror.h>

#include <qsqlfield.h>

#include <qsqlindex.h>

#include <qstringlist.h>

#include <qvarlengtharray.h>

#include <qvector.h>

#include <QDebug>

#include <QSqlQuery>

QT_BEGIN_NAMESPACE

// undefine this to prevent initial check of the ODBC driver

#define ODBC_CHECK_DRIVER

#if defined(Q_ODBC_VERSION_2)

//crude hack to get non-unicode capable driver managers to work

# undef UNICODE

# define SQLTCHAR SQLCHAR

# define SQL_C_WCHAR SQL_C_CHAR

#endif

// newer platform SDKs use SQLLEN instead of SQLINTEGER

#if defined(WIN32) && (_MSC_VER < 1300)

# define QSQLLEN SQLINTEGER

# define QSQLULEN SQLUINTEGER

#else

# define QSQLLEN SQLLEN

# define QSQLULEN SQLULEN

#endif

static const int COLNAMESIZE = 256;

//Map Qt parameter types to ODBC types

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

class QODBCDriverPrivate

{

public:

    enum DefaultCase{Lower, Mixed, Upper, Sensitive};

    QODBCDriverPrivate()

    : hEnv(0), hDbc(0), useSchema(false), disconnectCount(0), isMySqlServer(false),

           isMSSqlServer(false), hasSQLFetchScroll(true), hasMultiResultSets(false),

           isQuoteInitialized(false), quote(QLatin1Char('"'))

    {

        unicode = false;

    }

    SQLHANDLE hEnv;

    SQLHANDLE hDbc;

    uint unicode :1;

    uint useSchema :1;

    int disconnectCount;

    bool isMySqlServer;

    bool isMSSqlServer;

    bool hasSQLFetchScroll;

    bool hasMultiResultSets;

    bool checkDriver() const;

    void checkUnicode();

    void checkSqlServer();

    void checkHasSQLFetchScroll();

    void checkHasMultiResults();

    void checkSchemaUsage();

    bool setConnectionOptions(const QString& connOpts);

    void splitTableQualifier(const QString &qualifier, QString &catalog,

                             QString &schema, QString &table);

    DefaultCase defaultCase() const;

    QString adjustCase(const QString&) const;

    QChar quoteChar();

private:

    bool isQuoteInitialized;

    QChar quote;

};

class QODBCPrivate

{

public:

    QODBCPrivate(QODBCDriverPrivate *dpp)

    : hStmt(0), useSchema(false), hasSQLFetchScroll(true), driverPrivate(dpp), userForwardOnly(false)

    {

        unicode = false;

    }

    inline void clearValues()

    { fieldCache.fill(QVariant()); fieldCacheIdx = 0; }

    SQLHANDLE dpEnv() const { return driverPrivate ? driverPrivate->hEnv : 0;}

    SQLHANDLE dpDbc() const { return driverPrivate ? driverPrivate->hDbc : 0;}

    SQLHANDLE hStmt;

    uint unicode :1;

    uint useSchema :1;

    QSqlRecord rInf;

    QVector<QVariant> fieldCache;

    int fieldCacheIdx;

    int disconnectCount;

    bool hasSQLFetchScroll;

    QODBCDriverPrivate *driverPrivate;

    bool userForwardOnly;

    bool isStmtHandleValid(const QSqlDriver *driver);

    void updateStmtHandleState(const QSqlDriver *driver);

};

bool QODBCPrivate::isStmtHandleValid(const QSqlDriver *driver)

{

    const QODBCDriver *odbcdriver = static_cast<const QODBCDriver*> (driver);

    return disconnectCount == odbcdriver->d->disconnectCount;

}

void QODBCPrivate::updateStmtHandleState(const QSqlDriver *driver)

{

    const QODBCDriver *odbcdriver = static_cast<const QODBCDriver*> (driver);

    disconnectCount = odbcdriver->d->disconnectCount;

}

static QString qWarnODBCHandle(int handleType, SQLHANDLE handle, int *nativeCode = 0)

{

    SQLINTEGER nativeCode_ = 0;

    SQLSMALLINT msgLen = 0;

    SQLRETURN r = SQL_NO_DATA;

    SQLTCHAR state_[SQL_SQLSTATE_SIZE+1];

    SQLTCHAR description_[SQL_MAX_MESSAGE_LENGTH];

    QString result;

    int i = 1;

    description_[0] = 0;

    do {

        r = SQLGetDiagRec(handleType,

                            handle,

                            i,

                            (SQLTCHAR*)state_,

                            &nativeCode_,

                            (SQLTCHAR*)description_,

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

                            &msgLen);

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

            if (nativeCode)

                *nativeCode = nativeCode_;

            QString tmpstore;

#ifdef UNICODE

            tmpstore = QString((const QChar*)description_, msgLen);

#else

            tmpstore = QString::fromLocal8Bit((const char*)description_, msgLen);

#endif

            if(result != tmpstore) {

                if(!result.isEmpty())

                    result += QLatin1Char(' ');

                result += tmpstore;

            }

        } else if (r == SQL_ERROR || r == SQL_INVALID_HANDLE) {

            return result;

        }

        ++i;

    } while (r != SQL_NO_DATA);

    return result;

}

static QString qODBCWarn(const QODBCPrivate* odbc, int *nativeCode = 0)

{

    return (qWarnODBCHandle(SQL_HANDLE_ENV, odbc->dpEnv()) + QLatin1Char(' ')

             + qWarnODBCHandle(SQL_HANDLE_DBC, odbc->dpDbc()) + QLatin1Char(' ')

             + qWarnODBCHandle(SQL_HANDLE_STMT, odbc->hStmt, nativeCode));

}

static QString qODBCWarn(const QODBCDriverPrivate* odbc, int *nativeCode = 0)

{

    return (qWarnODBCHandle(SQL_HANDLE_ENV, odbc->hEnv) + QLatin1Char(' ')

             + qWarnODBCHandle(SQL_HANDLE_DBC, odbc->hDbc, nativeCode));

}

static void qSqlWarning(const QString& message, const QODBCPrivate* odbc)

{

    qWarning() << message << "\tError:" << qODBCWarn(odbc);

}

static void qSqlWarning(const QString &message, const QODBCDriverPrivate *odbc)

{

    qWarning() << message << "\tError:" << qODBCWarn(odbc);

}

static QSqlError qMakeError(const QString& err, QSqlError::ErrorType type, const QODBCPrivate* p)

{

    int nativeCode = -1;

    QString message = qODBCWarn(p, &nativeCode);

    return QSqlError(QLatin1String("QODBC3: ") + err, message, type, nativeCode);

}

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

                            const QODBCDriverPrivate* p)

{

    int nativeCode = -1;

    QString message = qODBCWarn(p, &nativeCode);

    return QSqlError(QLatin1String("QODBC3: ") + err, qODBCWarn(p), type, nativeCode);

}

template<class T>

static QVariant::Type qDecodeODBCType(SQLSMALLINT sqltype, const T* p, bool isSigned = true)

{

    Q_UNUSED(p);

    QVariant::Type type = QVariant::Invalid;

    switch (sqltype) {

    case SQL_DECIMAL:

    case SQL_NUMERIC:

    case SQL_REAL:

    case SQL_FLOAT:

    case SQL_DOUBLE:

        type = QVariant::Double;

        break;

    case SQL_SMALLINT:

    case SQL_INTEGER:

    case SQL_BIT:

        type = isSigned ? QVariant::Int : QVariant::UInt;

        break;

    case SQL_TINYINT:

        type = QVariant::UInt;

        break;

    case SQL_BIGINT:

        type = isSigned ? QVariant::LongLong : QVariant::ULongLong;

        break;

    case SQL_BINARY:

    case SQL_VARBINARY:

    case SQL_LONGVARBINARY:

        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;

#ifndef Q_ODBC_VERSION_2

    case SQL_WCHAR:

    case SQL_WVARCHAR:

    case SQL_WLONGVARCHAR:

        type = QVariant::String;

        break;

#endif

    case SQL_CHAR:

    case SQL_VARCHAR:

    case SQL_GUID:

    case SQL_LONGVARCHAR:

        type = QVariant::String;

        break;

    default:

        type = QVariant::ByteArray;

        break;

    }

    return type;

}

static QString qGetStringData(SQLHANDLE hStmt, int column, int colSize, bool unicode = false)

{

    QString fieldVal;

    SQLRETURN r = SQL_ERROR;

    QSQLLEN lengthIndicator = 0;

    // NB! colSize must be a multiple of 2 for unicode enabled DBs

    if (colSize <= 0) {

        colSize = 256;

    } 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

        if (unicode) {

            colSize *= 2; // a tiny bit faster, since it saves a SQLGetData() call

        }

    }

    QVarLengthArray<char> buf(colSize);

    while (true) {

        r = SQLGetData(hStmt,

                        column+1,

                        unicode ? SQL_C_WCHAR : SQL_C_CHAR,

                        (SQLPOINTER)buf.data(),

                        colSize,

                        &lengthIndicator);

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

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

                fieldVal.clear();

                break;

            }

            // if SQL_SUCCESS_WITH_INFO is returned, indicating that

            // more data can be fetched, the length indicator does NOT

            // contain the number of bytes returned - it contains the

            // total number of bytes that CAN be fetched

            // colSize-1: remove 0 termination when there is more data to fetch

            int rSize = (r == SQL_SUCCESS_WITH_INFO) ? (unicode ? colSize-2 : colSize-1) : lengthIndicator;

            if (unicode) {

                fieldVal += QString((const QChar*) buf.constData(), rSize / 2);

            } else {

                fieldVal += QString::fromAscii(buf.constData(), rSize);

            }

            memset(buf.data(), 0, colSize);

            if (lengthIndicator < colSize) {

                // workaround for Drivermanagers that don't return SQL_NO_DATA

                break;

            }

        } else if (r == SQL_NO_DATA) {

            break;

        } else {

            qWarning() << "qGetStringData: Error while fetching data (" << qWarnODBCHandle(SQL_HANDLE_STMT, hStmt) << ')';

            fieldVal.clear();

            break;

        }

    }

    return fieldVal;

}

static QVariant qGetBinaryData(SQLHANDLE hStmt, int column)

{

    QByteArray fieldVal;

    SQLSMALLINT colNameLen;

    SQLSMALLINT colType;

    QSQLULEN colSize;

    SQLSMALLINT colScale;

    SQLSMALLINT nullable;

    QSQLLEN lengthIndicator = 0;

    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" << 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;

    fieldVal.resize(colSize);

    ulong read = 0;

    while (true) {

        r = SQLGetData(hStmt,

                        column+1,

                        SQL_C_BINARY,

                        (SQLPOINTER)(fieldVal.constData() + read),

                        colSize,

                        &lengthIndicator);

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

            break;

        if (lengthIndicator == SQL_NULL_DATA)

            return QVariant(QVariant::ByteArray);

        if (lengthIndicator > QSQLLEN(colSize) || lengthIndicator == SQL_NO_TOTAL) {

            read += colSize;

            colSize = 65536;

        } else {

            read += lengthIndicator;

        }

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

            fieldVal.resize(read);

            break;

        }

        fieldVal.resize(fieldVal.size() + colSize);

    }

    return fieldVal;

}

static QVariant qGetIntData(SQLHANDLE hStmt, int column, bool isSigned = true)

{

    SQLINTEGER intbuf = 0;

    QSQLLEN lengthIndicator = 0;

    SQLRETURN r = SQLGetData(hStmt,

                              column+1,

                              isSigned ? SQL_C_SLONG : SQL_C_ULONG,

                              (SQLPOINTER)&intbuf,

                              sizeof(intbuf),

                              &lengthIndicator);

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

        return QVariant(QVariant::Invalid);

    if (lengthIndicator == SQL_NULL_DATA)

        return QVariant(QVariant::Int);

    if (isSigned)

        return int(intbuf);

    else

        return uint(intbuf);

}

static QVariant qGetDoubleData(SQLHANDLE hStmt, int column)

{

    SQLDOUBLE dblbuf;

    QSQLLEN lengthIndicator = 0;

    SQLRETURN r = SQLGetData(hStmt,

                              column+1,

                              SQL_C_DOUBLE,

                              (SQLPOINTER) &dblbuf,

                              0,

                              &lengthIndicator);

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

        return QVariant(QVariant::Invalid);

    }

    if(lengthIndicator == SQL_NULL_DATA)

        return QVariant(QVariant::Double);

    return (double) dblbuf;

}

static QVariant qGetBigIntData(SQLHANDLE hStmt, int column, bool isSigned = true)

{

    SQLBIGINT lngbuf = 0;

    QSQLLEN lengthIndicator = 0;

    SQLRETURN r = SQLGetData(hStmt,

                              column+1,

                              isSigned ? SQL_C_SBIGINT : SQL_C_UBIGINT,

                              (SQLPOINTER) &lngbuf,

                              sizeof(lngbuf),

                              &lengthIndicator);

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

        return QVariant(QVariant::Invalid);

    if (lengthIndicator == SQL_NULL_DATA)

        return QVariant(QVariant::LongLong);

    if (isSigned)

        return qint64(lngbuf);

    else

        return quint64(lngbuf);

}

// 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, const QODBCDriverPrivate* p)

{

    QString fname = qGetStringData(hStmt, 3, -1, p->unicode);

    int type = qGetIntData(hStmt, 4).toInt(); // column type

    QSqlField f(fname, qDecodeODBCType(type, p));

    int required = qGetIntData(hStmt, 10).toInt(); // 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

    QVariant var = qGetIntData(hStmt, 6);

    f.setLength(var.isNull() ? -1 : var.toInt()); // column size

    var = qGetIntData(hStmt, 8).toInt();

    f.setPrecision(var.isNull() ? -1 : var.toInt()); // precision

    f.setSqlType(type);

    return f;

}

static QSqlField qMakeFieldInfo(const QODBCPrivate* p, int i )

{

    SQLSMALLINT colNameLen;

    SQLSMALLINT colType;

    QSQLULEN colSize;

    SQLSMALLINT colScale;

    SQLSMALLINT nullable;

    SQLRETURN r = SQL_ERROR;

    SQLTCHAR colName[COLNAMESIZE];

    r = SQLDescribeCol(p->hStmt,

                        i+1,

                        colName,

                        (SQLSMALLINT)COLNAMESIZE,

                        &colNameLen,

                        &colType,

                        &colSize,

                        &colScale,

                        &nullable);

    if (r != SQL_SUCCESS) {

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

        return QSqlField();

    }