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

**

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

// newer platform SDKs use SQLLEN instead of SQLINTEGER

# 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 };

inline static QString fromSQLTCHAR(const QVarLengthArray<SQLTCHAR>& input, int size=-1)

{

    QString result;

    int realsize = qMin(size, input.size());

    if(realsize > 0 && input[realsize-1] == 0)

        realsize--;

    switch(sizeof(SQLTCHAR)) {

        case 1:

            result=QString::fromUtf8((const char *)input.constData(), realsize);

            break;

        case 2:

            result=QString::fromUtf16((const ushort *)input.constData(), realsize);

            break;

        case 4:

            result=QString::fromUcs4((const uint *)input.constData(), realsize);

            break;

        default:

            qCritical() << "sizeof(SQLTCHAR) is " << sizeof(SQLTCHAR) << "Don't know how to handle this";

    }

    return result;

}

inline static QVarLengthArray<SQLTCHAR> toSQLTCHAR(const QString &input)

{

    QVarLengthArray<SQLTCHAR> result;

    result.resize(input.size());

    switch(sizeof(SQLTCHAR)) {

        case 1:

            memcpy(result.data(), input.toUtf8().data(), input.size());

            break;

        case 2:

            memcpy(result.data(), input.unicode(), input.size() * 2);

            break;

        case 4:

            memcpy(result.data(), input.toUcs4().data(), input.size() * 4);

            break;

        default:

            qCritical() << "sizeof(SQLTCHAR) is " << sizeof(SQLTCHAR) << "Don't know how to handle this";

    }

    result.append(0); // make sure it's null terminated, doesn't matter if it already is, it does if it isn't.

    return result;

}

class QODBCDriverPrivate

{

public:

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

    QODBCDriverPrivate()

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

           isMSSqlServer(false), isFreeTDSDriver(false), hasSQLFetchScroll(true),

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

    {

    }

    SQLHANDLE hEnv;

    SQLHANDLE hDbc;

    bool unicode;

    bool useSchema;

    int disconnectCount;

    bool isMySqlServer;

    bool isMSSqlServer;

    bool isFreeTDSDriver;

    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 = dpp->unicode;

        useSchema = dpp->useSchema;

        disconnectCount = dpp->disconnectCount;

        hasSQLFetchScroll = dpp->hasSQLFetchScroll;

    }

    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;

    bool unicode;

    bool useSchema;

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

                          0,

                          NULL,

                          &msgLen);

        if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && msgLen > 0)

            description_.resize(msgLen+1);

        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

            tmpstore = fromSQLTCHAR(description_, msgLen);

#else

            tmpstore = QString::fromUtf8((const char*)description_.constData(), 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)).simplified();

}

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

{

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

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

}

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;

    case SQL_WCHAR:

    case SQL_WVARCHAR:

    case SQL_WLONGVARCHAR:

        type = QVariant::String;

        break;

    case SQL_CHAR:

    case SQL_VARCHAR:

#if (ODBCVER >= 0x0350)

    case SQL_GUID:

#endif

    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) {

        r = SQLGetData(hStmt,

                        column+1,

                        SQL_C_TCHAR,

                        NULL,

                        0,

                        &lengthIndicator);

        if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && lengthIndicator > 0)

            colSize = lengthIndicator/sizeof(SQLTCHAR) + 1;

        QVarLengthArray<SQLTCHAR> buf(colSize);

        memset(buf.data(), 0, colSize*sizeof(SQLTCHAR));

        while (true) {

            r = SQLGetData(hStmt,

                            column+1,

                            SQL_C_TCHAR,

                            (SQLPOINTER)buf.data(),

                            colSize*sizeof(SQLTCHAR),

                            &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) ? colSize : lengthIndicator/sizeof(SQLTCHAR);

                    fieldVal += fromSQLTCHAR(buf, rSize);

                if (lengthIndicator < (unsigned int)colSize*sizeof(SQLTCHAR)) {

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

            }

        }

    } else {

        r = SQLGetData(hStmt,

                        column+1,

                        SQL_C_CHAR,

                        NULL,

                        0,

                        &lengthIndicator);

        if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && lengthIndicator > 0)

            colSize = lengthIndicator + 1;

        QVarLengthArray<SQLCHAR> buf(colSize);

        while (true) {

            r = SQLGetData(hStmt,

                            column+1,

                            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) ? colSize : lengthIndicator;

                    fieldVal += QString::fromUtf8((const char *)buf.constData(), rSize);

                if (lengthIndicator < (unsigned int)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;

    QVarLengthArray<SQLTCHAR> colName(COLNAMESIZE);

    r = SQLDescribeCol(hStmt,

                       column + 1,

                       colName.data(),

                       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;

}