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

**

** 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 <qglobal.h>

#ifdef Q_OS_WIN32    // We assume that MS SQL Server is used. Set Q_USE_SYBASE to force Sybase.

// Conflicting declarations of LPCBYTE in sqlfront.h and winscard.h

#define _WINSCARD_H_

#include <windows.h>

#else

#define Q_USE_SYBASE

#endif

#include "qsql_tds.h"

#include <qvariant.h>

#include <qdatetime.h>

#include <qhash.h>

#include <qregexp.h>

#include <qsqlerror.h>

#include <qsqlfield.h>

#include <qsqlindex.h>

#include <qsqlquery.h>

#include <qstringlist.h>

#include <qvector.h>

#include <stdlib.h>

QT_BEGIN_NAMESPACE

#ifdef DBNTWIN32

#define QMSGHANDLE DBMSGHANDLE_PROC

#define QERRHANDLE DBERRHANDLE_PROC

#define QTDSCHAR SQLCHAR

#define QTDSDATETIME4 SQLDATETIM4

#define QTDSDATETIME SQLDATETIME

#define QTDSDATETIME_N SQLDATETIMN

#define QTDSDECIMAL SQLDECIMAL

#define QTDSFLT4 SQLFLT4

#define QTDSFLT8 SQLFLT8

#define QTDSFLT8_N SQLFLTN

#define QTDSINT1 SQLINT1

#define QTDSINT2 SQLINT2

#define QTDSINT4 SQLINT4

#define QTDSINT4_N SQLINTN

#define QTDSMONEY4 SQLMONEY4

#define QTDSMONEY SQLMONEY

#define QTDSMONEY_N SQLMONEYN

#define QTDSNUMERIC SQLNUMERIC

#define QTDSTEXT SQLTEXT

#define QTDSVARCHAR SQLVARCHAR

#define QTDSBIT SQLBIT

#define QTDSBINARY SQLBINARY

#define QTDSVARBINARY SQLVARBINARY

#define QTDSIMAGE SQLIMAGE

#else

#define QMSGHANDLE MHANDLEFUNC

#define QERRHANDLE EHANDLEFUNC

#define QTDSCHAR SYBCHAR

#define QTDSDATETIME4 SYBDATETIME4

#define QTDSDATETIME SYBDATETIME

#define QTDSDATETIME_N SYBDATETIMN

#define QTDSDECIMAL SYBDECIMAL

#define QTDSFLT8 SYBFLT8

#define QTDSFLT8_N SYBFLTN

#define QTDSFLT4 SYBREAL

#define QTDSINT1 SYBINT1

#define QTDSINT2 SYBINT2

#define QTDSINT4 SYBINT4

#define QTDSINT4_N SYBINTN

#define QTDSMONEY4 SYBMONEY4

#define QTDSMONEY SYBMONEY

#define QTDSMONEY_N SYBMONEYN

#define QTDSNUMERIC SYBNUMERIC

#define QTDSTEXT SYBTEXT

#define QTDSVARCHAR SYBVARCHAR

#define QTDSBIT SYBBIT

#define QTDSBINARY SYBBINARY

#define QTDSVARBINARY SYBVARBINARY

#define QTDSIMAGE SYBIMAGE

// magic numbers not defined anywhere in Sybase headers

#define QTDSDECIMAL_2 55

#define QTDSNUMERIC_2 63

#endif  //DBNTWIN32

#define TDS_CURSOR_SIZE 50

// workaround for FreeTDS

#ifndef CS_PUBLIC

#define CS_PUBLIC

#endif

QSqlError qMakeError(const QString& err, QSqlError::ErrorType type, int errNo = -1)

{

    return QSqlError(QLatin1String("QTDS: ") + err, QString(), type, errNo);

}

class QTDSDriverPrivate

{

public:

    QTDSDriverPrivate(): login(0) {}

    LOGINREC* login;  // login information

    QString hostName;

    QString db;

};

class QTDSResultPrivate

{

public:

    QTDSResultPrivate():login(0), dbproc(0) {}

    LOGINREC* login;  // login information

    DBPROCESS* dbproc; // connection from app to server

    QSqlError lastError;

    void addErrorMsg(QString& errMsg) { errorMsgs.append(errMsg); }

    QString getErrorMsgs() { return errorMsgs.join(QLatin1String("\n")); }

    void clearErrorMsgs() { errorMsgs.clear(); }

    QVector<void *> buffer;

    QSqlRecord rec;

private:

    QStringList errorMsgs;

};

typedef QHash<DBPROCESS *, QTDSResultPrivate *> QTDSErrorHash;

Q_GLOBAL_STATIC(QTDSErrorHash, errs)

extern "C" {

static int CS_PUBLIC qTdsMsgHandler (DBPROCESS* dbproc,

                            int msgstate,

                            int severity,

                            char* msgtext,

                            char* /*procname*/,

{

    QTDSResultPrivate* p = errs()->value(dbproc);

    if (!p) {

//        ### umm... temporary disabled since this throws a lot of warnings...

//        qWarning("QTDSDriver warning (%d): [%s] from server [%s]", msgstate, msgtext, srvname);

        return INT_CANCEL;

    }

    if (severity > 0) {

        p->addErrorMsg(errMsg);

    }

    return INT_CANCEL;

}

static int CS_PUBLIC qTdsErrHandler(DBPROCESS* dbproc,

                                int /*severity*/,

                                int dberr,

                                int /*oserr*/,

                                char* dberrstr,

                                char* oserrstr)

{

    QTDSResultPrivate* p = errs()->value(dbproc);

    if (!p) {

        qWarning("QTDSDriver error (%d): [%s] [%s]", dberr, dberrstr, oserrstr);

        return INT_CANCEL;

    }

    /*

     * If the process is dead or NULL and

     * we are not in the middle of logging in...

     */

    if((dbproc == NULL || DBDEAD(dbproc))) {

        qWarning("QTDSDriver error (%d): [%s] [%s]", dberr, dberrstr, oserrstr);

        return INT_CANCEL;

    }

    QString errMsg = QString::fromLatin1("%1 %2\n").arg(QLatin1String(dberrstr)).arg(

                                QLatin1String(oserrstr));

    errMsg += p->getErrorMsgs();

    p->lastError = qMakeError(errMsg, QSqlError::UnknownError, dberr);

    p->clearErrorMsgs();

    return INT_CANCEL ;

}

} //extern "C"

QVariant::Type qDecodeTDSType(int type)

{

    QVariant::Type t = QVariant::Invalid;

    switch (type) {

    case QTDSCHAR:

    case QTDSTEXT:

    case QTDSVARCHAR:

        t = QVariant::String;

        break;

    case QTDSINT1:

    case QTDSINT2:

    case QTDSINT4:

    case QTDSINT4_N:

    case QTDSBIT:

        t = QVariant::Int;

        break;

    case QTDSFLT4:

    case QTDSFLT8:

    case QTDSFLT8_N:

    case QTDSMONEY4:

    case QTDSMONEY:

    case QTDSDECIMAL:

    case QTDSNUMERIC:

#ifdef QTDSNUMERIC_2

    case QTDSNUMERIC_2:

#endif

#ifdef QTDSDECIMAL_2

    case QTDSDECIMAL_2:

#endif

    case QTDSMONEY_N:

        t = QVariant::Double;

        break;

    case QTDSDATETIME4:

    case QTDSDATETIME:

    case QTDSDATETIME_N:

        t = QVariant::DateTime;

        break;

    case QTDSBINARY:

    case QTDSVARBINARY:

    case QTDSIMAGE:

        t = QVariant::ByteArray;

        break;

    default:

        t = QVariant::Invalid;

        break;

    }

    return t;

}

QVariant::Type qFieldType(QTDSResultPrivate* d, int i)

{

    QVariant::Type type = qDecodeTDSType(dbcoltype(d->dbproc, i+1));

    return type;

}

QTDSResult::QTDSResult(const QTDSDriver* db)

    : QSqlCachedResult(db)

{

    d = new QTDSResultPrivate();

    d->login = db->d->login;

    d->dbproc = dbopen(d->login, const_cast<char*>(db->d->hostName.toLatin1().constData()));

    if (!d->dbproc)

        return;

    if (dbuse(d->dbproc, const_cast<char*>(db->d->db.toLatin1().constData())) == FAIL)

        return;

    // insert d in error handler dict

    errs()->insert(d->dbproc, d);

    dbcmd(d->dbproc, "set quoted_identifier on");

    dbsqlexec(d->dbproc);

}

QTDSResult::~QTDSResult()

{

    cleanup();

    if (d->dbproc)

        dbclose(d->dbproc);

    errs()->remove(d->dbproc);

    delete d;

}

void QTDSResult::cleanup()

{

    d->clearErrorMsgs();

    d->rec.clear();

    for (int i = 0; i < d->buffer.size() / 2; ++i)

        free(d->buffer.at(i * 2));

    d->buffer.clear();

    // "can" stands for "cancel"... very clever.

    dbcanquery(d->dbproc);

    dbfreebuf(d->dbproc);

    QSqlCachedResult::cleanup();

}

QVariant QTDSResult::handle() const

{

    return QVariant(qRegisterMetaType<DBPROCESS *>("DBPROCESS*"), &d->dbproc);

}

static inline bool qIsNull(const void *ind)

{

    return *reinterpret_cast<const DBINT *>(&ind) == -1;

}

bool QTDSResult::gotoNext(QSqlCachedResult::ValueCache &values, int index)

{

    STATUS stat = dbnextrow(d->dbproc);

    if (stat == NO_MORE_ROWS) {

        setAt(QSql::AfterLastRow);

        return false;

    }

    if ((stat == FAIL) || (stat == BUF_FULL)) {

        setLastError(d->lastError);

        return false;

    }

    if (index < 0)

        return true;

    for (int i = 0; i < d->rec.count(); ++i) {

        int idx = index + i;

        switch (d->rec.field(i).type()) {

            case QVariant::DateTime:

                if (qIsNull(d->buffer.at(i * 2 + 1))) {

                    values[idx] = QVariant(QVariant::DateTime);

                } else {

                    DBDATETIME *bdt = (DBDATETIME*) d->buffer.at(i * 2);

                    QDate date = QDate::fromString(QLatin1String("1900-01-01"), Qt::ISODate);

                    QTime time = QTime::fromString(QLatin1String("00:00:00"), Qt::ISODate);

                    values[idx] = QDateTime(date.addDays(bdt->dtdays), time.addMSecs(int(bdt->dttime / 0.3)));

                }

                break;

            case QVariant::Int:

                if (qIsNull(d->buffer.at(i * 2 + 1)))

                    values[idx] = QVariant(QVariant::Int);

                else

                    values[idx] = *((int*)d->buffer.at(i * 2));

                break;

            case QVariant::Double:

            case QVariant::String:

                if (qIsNull(d->buffer.at(i * 2 + 1)))

                    values[idx] = QVariant(QVariant::String);

                else

                    values[idx] = QString::fromLocal8Bit((const char*)d->buffer.at(i * 2)).trimmed();

                break;

            case QVariant::ByteArray: {

                if (qIsNull(d->buffer.at(i * 2 + 1)))

                    values[idx] = QVariant(QVariant::ByteArray);

                else

                    values[idx] = QByteArray((const char*)d->buffer.at(i * 2));

                break;

            }

            default:

                // should never happen, and we already fired

                // a warning while binding.

                values[idx] = QVariant();

                break;

        }

    }

    return true;

}

bool QTDSResult::reset (const QString& query)

{

    cleanup();

    if (!driver() || !driver()-> isOpen() || driver()->isOpenError())

        return false;

    setActive(false);

    setAt(QSql::BeforeFirstRow);

    if (dbcmd(d->dbproc, const_cast<char*>(query.toLocal8Bit().constData())) == FAIL) {

        setLastError(d->lastError);

        return false;

    }

    if (dbsqlexec(d->dbproc) == FAIL) {

        setLastError(d->lastError);

        dbfreebuf(d->dbproc);

        return false;

    }

    if (dbresults(d->dbproc) != SUCCEED) {

        setLastError(d->lastError);

        dbfreebuf(d->dbproc);

        return false;

    }

    setSelect((DBCMDROW(d->dbproc) == SUCCEED)); // decide whether or not we are dealing with a SELECT query

    int numCols = dbnumcols(d->dbproc);

    if (numCols > 0) {

        d->buffer.resize(numCols * 2);

        init(numCols);

    }

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

        int dbType = dbcoltype(d->dbproc, i+1);

        QVariant::Type vType = qDecodeTDSType(dbType);

        QSqlField f(QString::fromAscii(dbcolname(d->dbproc, i+1)), vType);

        f.setSqlType(dbType);

        f.setLength(dbcollen(d->dbproc, i+1));

        d->rec.append(f);

        RETCODE ret = -1;

        void* p = 0;

        switch (vType) {

        case QVariant::Int:

            p = malloc(4);

            ret = dbbind(d->dbproc, i+1, INTBIND, (DBINT) 4, (unsigned char *)p);

            break;

        case QVariant::Double:

            // use string binding to prevent loss of precision

            p = malloc(50);

            ret = dbbind(d->dbproc, i+1, STRINGBIND, 50, (unsigned char *)p);

            break;

        case QVariant::String:

            p = malloc(dbcollen(d->dbproc, i+1) + 1);

            ret = dbbind(d->dbproc, i+1, STRINGBIND, DBINT(dbcollen(d->dbproc, i+1) + 1), (unsigned char *)p);

            break;

        case QVariant::DateTime:

            p = malloc(8);

            ret = dbbind(d->dbproc, i+1, DATETIMEBIND, (DBINT) 8, (unsigned char *)p);

            break;

        case QVariant::ByteArray:

            p = malloc(dbcollen(d->dbproc, i+1) + 1);

            ret = dbbind(d->dbproc, i+1, BINARYBIND, DBINT(dbcollen(d->dbproc, i+1) + 1), (unsigned char *)p);

            break;

        default: //don't bind the field since we do not support it

            qWarning("QTDSResult::reset: Unsupported type for field \"%s\"", dbcolname(d->dbproc, i+1));

            break;

        }

        if (ret == SUCCEED) {

            d->buffer[i * 2] = p;

            ret = dbnullbind(d->dbproc, i+1, (DBINT*)(&d->buffer[i * 2 + 1]));

        } else {

            d->buffer[i * 2] = 0;

            d->buffer[i * 2 + 1] = 0;

            free(p);

        }

        if ((ret != SUCCEED) && (ret != -1)) {

            setLastError(d->lastError);

            return false;

        }

    }

    setActive(true);

    return true;

}

int QTDSResult::size()

{

    return -1;

}

int QTDSResult::numRowsAffected()

{

#ifdef DBNTWIN32

    if (dbiscount(d->dbproc)) {

        return DBCOUNT(d->dbproc);

    }

    return -1;

#else

    return DBCOUNT(d->dbproc);

#endif

}

QSqlRecord QTDSResult::record() const

{

    return d->rec;

}

///////////////////////////////////////////////////////////////////

QTDSDriver::QTDSDriver(QObject* parent)

    : QSqlDriver(parent)

{

    init();

}

QTDSDriver::QTDSDriver(LOGINREC* rec, const QString& host, const QString &db, QObject* parent)

    : QSqlDriver(parent)

{

    init();

    d->login = rec;

    d->hostName = host;

    d->db = db;

    if (rec) {

        setOpen(true);

        setOpenError(false);

    }