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

**

** 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_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

#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()

    {

    }

    SQLHANDLE hEnv;

    SQLHANDLE hDbc;

    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)

    {

    }

    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;

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

    QVarLengthArray<SQLTCHAR> description_(SQL_MAX_MESSAGE_LENGTH);

    QString result;

    int i = 1;

    description_[0] = 0;

    do {

        r = SQLGetDiagRec(handleType,

                            handle,

                            i,

                            state_,

                            &nativeCode_,

                            description_.data(),

                            description_.size(),

                            &msgLen);

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

            if (nativeCode)

                *nativeCode = nativeCode_;

            QString tmpstore;

#ifdef UNICODE

#else

#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(' ')

}

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

{

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

}

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

    }

        r = SQLGetData(hStmt,

                        column+1,

                        &lengthIndicator);

                fieldVal.clear();

                break;

            }

            } else {

                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;

    r = SQLDescribeCol(hStmt,

                       column + 1,

                       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;