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

**

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

#include <qcoreapplication.h>

#include <qvariant.h>

#include <qdatetime.h>

#include <qsqlerror.h>

#include <qsqlfield.h>

#include <qsqlindex.h>

#include <qsqlquery.h>

#include <qsqlrecord.h>

#include <qstringlist.h>

#include <qtextcodec.h>

#include <qvector.h>

#include <qdebug.h>

#ifdef Q_OS_WIN32

// comment the next line out if you want to use MySQL/embedded on Win32 systems.

// note that it will crash if you don't statically link to the mysql/e library!

# define Q_NO_MYSQL_EMBEDDED

#endif

Q_DECLARE_METATYPE(MYSQL_RES*)

Q_DECLARE_METATYPE(MYSQL*)

#if MYSQL_VERSION_ID >= 40108

Q_DECLARE_METATYPE(MYSQL_STMT*)

#endif

#if MYSQL_VERSION_ID >= 40100

#  define Q_CLIENT_MULTI_STATEMENTS CLIENT_MULTI_STATEMENTS

#else

#  define Q_CLIENT_MULTI_STATEMENTS 0

#endif

QT_BEGIN_NAMESPACE

class QMYSQLDriverPrivate

{

public:

    QMYSQLDriverPrivate() : mysql(0),

#ifndef QT_NO_TEXTCODEC

        tc(QTextCodec::codecForLocale()),

#else

        tc(0),

#endif

        preparedQuerysEnabled(false) {}

    MYSQL *mysql;

    QTextCodec *tc;

    bool preparedQuerysEnabled;

};

static inline QString toUnicode(QTextCodec *tc, const char *str)

{

#ifdef QT_NO_TEXTCODEC

    Q_UNUSED(tc);

    return QString::fromLatin1(str);

#else

    return tc->toUnicode(str);

#endif

}

static inline QString toUnicode(QTextCodec *tc, const char *str, int length)

{

#ifdef QT_NO_TEXTCODEC

    Q_UNUSED(tc);

    return QString::fromLatin1(str, length);

#else

    return tc->toUnicode(str, length);

#endif

}

static inline QByteArray fromUnicode(QTextCodec *tc, const QString &str)

{

#ifdef QT_NO_TEXTCODEC

    Q_UNUSED(tc);

    return str.toLatin1();

#else

    return tc->fromUnicode(str);

#endif

}

static inline QVariant qDateFromString(const QString &val)

{

#ifdef QT_NO_DATESTRING

    Q_UNUSED(val);

    return QVariant(val);

#else

    if (val.isEmpty())

        return QVariant(QDate());

    return QVariant(QDate::fromString(val, Qt::ISODate));

#endif

}

static inline QVariant qTimeFromString(const QString &val)

{

#ifdef QT_NO_DATESTRING

    Q_UNUSED(val);

    return QVariant(val);

#else

    if (val.isEmpty())

        return QVariant(QTime());

    return QVariant(QTime::fromString(val, Qt::ISODate));

#endif

}

static inline QVariant qDateTimeFromString(QString &val)

{

#ifdef QT_NO_DATESTRING

    Q_UNUSED(val);

    return QVariant(val);

#else

    if (val.isEmpty())

        return QVariant(QDateTime());

    if (val.length() == 14)

        // TIMESTAMPS have the format yyyyMMddhhmmss

        val.insert(4, QLatin1Char('-')).insert(7, QLatin1Char('-')).insert(10,

                    QLatin1Char('T')).insert(13, QLatin1Char(':')).insert(16, QLatin1Char(':'));

    return QVariant(QDateTime::fromString(val, Qt::ISODate));

#endif

}

class QMYSQLResultPrivate : public QObject

{

    Q_OBJECT

public:

    QMYSQLResultPrivate(const QMYSQLDriver* dp, const QMYSQLResult* d) : driver(dp), result(0), q(d), 

        rowsAffected(0), hasBlobs(false)

#if MYSQL_VERSION_ID >= 40108

        , stmt(0), meta(0), inBinds(0), outBinds(0)

#endif

        , preparedQuery(false)

        {

            connect(dp, SIGNAL(destroyed()), this, SLOT(driverDestroyed()));

        }

    const QMYSQLDriver* driver;

    MYSQL_RES *result;

    MYSQL_ROW row;

    const QMYSQLResult* q;

    int rowsAffected;

    bool bindInValues();

    void bindBlobs();

    bool hasBlobs;

    struct QMyField

    {

        QMyField()

            : outField(0), nullIndicator(false), bufLength(0ul),

              myField(0), type(QVariant::Invalid)

        {}

        char *outField;

        my_bool nullIndicator;

        ulong bufLength;

        MYSQL_FIELD *myField;

        QVariant::Type type;

    };

    QVector<QMyField> fields;

#if MYSQL_VERSION_ID >= 40108

    MYSQL_STMT* stmt;

    MYSQL_RES* meta;

    MYSQL_BIND *inBinds;

    MYSQL_BIND *outBinds;

#endif

    bool preparedQuery;

private Q_SLOTS:

    void driverDestroyed() { driver = NULL; }

};

#ifndef QT_NO_TEXTCODEC

static QTextCodec* codec(MYSQL* mysql)

{

#if MYSQL_VERSION_ID >= 32321

    QTextCodec* heuristicCodec = QTextCodec::codecForName(mysql_character_set_name(mysql));

    if (heuristicCodec)

        return heuristicCodec;

#endif

    return QTextCodec::codecForLocale();

}

#endif // QT_NO_TEXTCODEC

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

                            const QMYSQLDriverPrivate* p)

{

    const char *cerr = p->mysql ? mysql_error(p->mysql) : 0;

    return QSqlError(QLatin1String("QMYSQL: ") + err,

                     p->tc ? toUnicode(p->tc, cerr) : QString::fromLatin1(cerr),

                     type, mysql_errno(p->mysql));

}

static QVariant::Type qDecodeMYSQLType(int mysqltype, uint flags)

{

    QVariant::Type type;

    switch (mysqltype) {

    case FIELD_TYPE_TINY :

    case FIELD_TYPE_SHORT :

    case FIELD_TYPE_LONG :

    case FIELD_TYPE_INT24 :

        type = (flags & UNSIGNED_FLAG) ? QVariant::UInt : QVariant::Int;

        break;

    case FIELD_TYPE_YEAR :

        type = QVariant::Int;

        break;

    case FIELD_TYPE_LONGLONG :

        type = (flags & UNSIGNED_FLAG) ? QVariant::ULongLong : QVariant::LongLong;

        break;

    case FIELD_TYPE_FLOAT :

    case FIELD_TYPE_DOUBLE :

    case FIELD_TYPE_DECIMAL :

#if defined(FIELD_TYPE_NEWDECIMAL)

    case FIELD_TYPE_NEWDECIMAL:

#endif

        type = QVariant::Double;

        break;

    case FIELD_TYPE_DATE :

        type = QVariant::Date;

        break;

    case FIELD_TYPE_TIME :

        type = QVariant::Time;

        break;

    case FIELD_TYPE_DATETIME :

    case FIELD_TYPE_TIMESTAMP :

        type = QVariant::DateTime;

        break;

    case FIELD_TYPE_STRING :

    case FIELD_TYPE_VAR_STRING :

    case FIELD_TYPE_BLOB :

    case FIELD_TYPE_TINY_BLOB :

    case FIELD_TYPE_MEDIUM_BLOB :

    case FIELD_TYPE_LONG_BLOB :

        type = (flags & BINARY_FLAG) ? QVariant::ByteArray : QVariant::String;

        break;

    default:

    case FIELD_TYPE_ENUM :

    case FIELD_TYPE_SET :

        type = QVariant::String;

        break;

    }

    return type;

}

static QSqlField qToField(MYSQL_FIELD *field, QTextCodec *tc)

{

    QSqlField f(toUnicode(tc, field->name),

                qDecodeMYSQLType(int(field->type), field->flags));

    f.setRequired(IS_NOT_NULL(field->flags));

    f.setLength(field->length);

    f.setPrecision(field->decimals);

    f.setSqlType(field->type);

    f.setAutoValue(field->flags & AUTO_INCREMENT_FLAG);

    return f;

}

#if MYSQL_VERSION_ID >= 40108

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

                            MYSQL_STMT* stmt)

{

    const char *cerr = mysql_stmt_error(stmt);

    return QSqlError(QLatin1String("QMYSQL3: ") + err,

                     QString::fromLatin1(cerr),

                     type, mysql_stmt_errno(stmt));

}

static bool qIsBlob(int t)

{

    return t == MYSQL_TYPE_TINY_BLOB

           || t == MYSQL_TYPE_BLOB

           || t == MYSQL_TYPE_MEDIUM_BLOB

           || t == MYSQL_TYPE_LONG_BLOB;

}

static bool qIsInteger(int t)

{

    return t == MYSQL_TYPE_TINY

           || t == MYSQL_TYPE_SHORT

           || t == MYSQL_TYPE_LONG

           || t == MYSQL_TYPE_LONGLONG

           || t == MYSQL_TYPE_INT24;

}

void QMYSQLResultPrivate::bindBlobs()

{

    int i;

    MYSQL_FIELD *fieldInfo;

    MYSQL_BIND *bind;

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

        fieldInfo = fields.at(i).myField;

        if (qIsBlob(inBinds[i].buffer_type) && meta && fieldInfo) {

            bind = &inBinds[i];

            bind->buffer_length = fieldInfo->max_length;

            delete[] static_cast<char*>(bind->buffer);

            bind->buffer = new char[fieldInfo->max_length];

            fields[i].outField = static_cast<char*>(bind->buffer);

        }

    }

}

bool QMYSQLResultPrivate::bindInValues()

{

    MYSQL_BIND *bind;

    char *field;

    int i = 0;

    if (!meta)

        meta = mysql_stmt_result_metadata(stmt);

    if (!meta)

        return false;

    fields.resize(mysql_num_fields(meta));

    inBinds = new MYSQL_BIND[fields.size()];

    memset(inBinds, 0, fields.size() * sizeof(MYSQL_BIND));

    MYSQL_FIELD *fieldInfo;

    while((fieldInfo = mysql_fetch_field(meta))) {

        QMyField &f = fields[i];

        f.myField = fieldInfo;

        f.type = qDecodeMYSQLType(fieldInfo->type, fieldInfo->flags);

        if (qIsBlob(fieldInfo->type)) {

            // the size of a blob-field is available as soon as we call

            // mysql_stmt_store_result()

            // after mysql_stmt_exec() in QMYSQLResult::exec()

            fieldInfo->length = 0;

            hasBlobs = true;

        } else {

            // fieldInfo->length specifies the display width, which may be too

            // small to hold valid integer values (see

            // http://dev.mysql.com/doc/refman/5.0/en/numeric-types.html ), so

            // always use the MAX_BIGINT_WIDTH for integer types

            if (qIsInteger(fieldInfo->type)) {

                fieldInfo->length = MAX_BIGINT_WIDTH;

            }

            fieldInfo->type = MYSQL_TYPE_STRING;

        }

        bind = &inBinds[i];

        field = new char[fieldInfo->length + 1];

        memset(field, 0, fieldInfo->length + 1);

        bind->buffer_type = fieldInfo->type;

        bind->buffer = field;

        bind->buffer_length = f.bufLength = fieldInfo->length + 1;

        bind->is_null = &f.nullIndicator;

        bind->length = &f.bufLength;

        f.outField=field;

        ++i;

    }

    return true;

}

#endif

QMYSQLResult::QMYSQLResult(const QMYSQLDriver* db)

: QSqlResult(db)

{

    d = new QMYSQLResultPrivate(db, this);

}

QMYSQLResult::~QMYSQLResult()

{

    cleanup();

    delete d;

}

QVariant QMYSQLResult::handle() const

{

#if MYSQL_VERSION_ID >= 40108

    if(d->preparedQuery)

        return d->meta ? qVariantFromValue(d->meta) : qVariantFromValue(d->stmt);

    else

#endif

        return qVariantFromValue(d->result);

}

void QMYSQLResult::cleanup()

{

    if (d->result)

        mysql_free_result(d->result);

// must iterate trough leftover result sets from multi-selects or stored procedures

// if this isn't done subsequent queries will fail with "Commands out of sync"

#if MYSQL_VERSION_ID >= 40100

    while (d->driver && d->driver->d->mysql && mysql_next_result(d->driver->d->mysql) == 0) {

        MYSQL_RES *res = mysql_store_result(d->driver->d->mysql);

        if (res)

            mysql_free_result(res);

    }

#endif

#if MYSQL_VERSION_ID >= 40108

    if (d->stmt) {

        if (mysql_stmt_close(d->stmt))

            qWarning("QMYSQLResult::cleanup: unable to free statement handle");

        d->stmt = 0;

    }

    if (d->meta) {

        mysql_free_result(d->meta);

        d->meta = 0;

    }

    int i;

    for (i = 0; i < d->fields.count(); ++i)

        delete[] d->fields[i].outField;

    if (d->outBinds) {

        delete[] d->outBinds;

        d->outBinds = 0;

    }

    if (d->inBinds) {

        delete[] d->inBinds;

        d->inBinds = 0;

    }

#endif

    d->hasBlobs = false;

    d->fields.clear();

    d->result = NULL;

    d->row = NULL;

    setAt(-1);

    setActive(false);

}

bool QMYSQLResult::fetch(int i)

{

    if(!d->driver)

        return false;

    if (isForwardOnly()) { // fake a forward seek

        if (at() < i) {

            int x = i - at();

            while (--x && fetchNext()) {};

            return fetchNext();

        } else {

            return false;

        }

    }

    if (at() == i)

        return true;

    if (d->preparedQuery) {

#if MYSQL_VERSION_ID >= 40108

        mysql_stmt_data_seek(d->stmt, i);

        int nRC = mysql_stmt_fetch(d->stmt);

        if (nRC) {

#ifdef MYSQL_DATA_TRUNCATED

            if (nRC == 1 || nRC == MYSQL_DATA_TRUNCATED)

#else

            if (nRC == 1)

#endif

                setLastError(qMakeStmtError(QCoreApplication::translate("QMYSQLResult",

                         "Unable to fetch data"), QSqlError::StatementError, d->stmt));

            return false;

        }

#else

        return false;

#endif

    } else {

        mysql_data_seek(d->result, i);

        d->row = mysql_fetch_row(d->result);

        if (!d->row)

            return false;

    }

    setAt(i);

    return true;

}

bool QMYSQLResult::fetchNext()

{

    if(!d->driver)

        return false;

    if (d->preparedQuery) {