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

**

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

#include <qcoreapplication.h>

#include <qvariant.h>

#include <qsqlerror.h>

#include <qsqlfield.h>

#include <qsqlindex.h>

#include <qsqlquery.h>

#include <qstringlist.h>

#include <qvector.h>

#include <qdebug.h>

#if defined Q_OS_WIN

# include <qt_windows.h>

#else

# include <unistd.h>

#endif

#include <sqlite3.h>

Q_DECLARE_METATYPE(sqlite3*)

Q_DECLARE_METATYPE(sqlite3_stmt*)

QT_BEGIN_NAMESPACE

static QString _q_escapeIdentifier(const QString &identifier) 

{

    QString res = identifier;

    if(!identifier.isEmpty() && identifier.left(1) != QString(QLatin1Char('"')) && identifier.right(1) != QString(QLatin1Char('"')) ) {

        res.replace(QLatin1Char('"'), QLatin1String("\"\""));

        res.prepend(QLatin1Char('"')).append(QLatin1Char('"'));

        res.replace(QLatin1Char('.'), QLatin1String("\".\""));

    }

    return res;

}

static QVariant::Type qGetColumnType(const QString &tpName)

{

    const QString typeName = tpName.toLower();

    if (typeName == QLatin1String("integer")

        || typeName == QLatin1String("int"))

        return QVariant::Int;

    if (typeName == QLatin1String("double")

        || typeName == QLatin1String("float")

        || typeName.startsWith(QLatin1String("numeric")))

        return QVariant::Double;

    if (typeName == QLatin1String("blob"))

        return QVariant::ByteArray;

    return QVariant::String;

}

static QSqlError qMakeError(sqlite3 *access, const QString &descr, QSqlError::ErrorType type,

                            int errorCode = -1)

{

    return QSqlError(descr,

                     QString::fromUtf16(static_cast<const ushort *>(sqlite3_errmsg16(access))),

                     type, errorCode);

}

class QSQLiteDriverPrivate

{

public:

    inline QSQLiteDriverPrivate() : access(0) {}

    sqlite3 *access;

};

class QSQLiteResultPrivate

{

public:

    QSQLiteResultPrivate(QSQLiteResult *res);

    void cleanup();

    bool fetchNext(QSqlCachedResult::ValueCache &values, int idx, bool initialFetch);

    // initializes the recordInfo and the cache

    void initColumns(bool emptyResultset);

    void finalize();

    QSQLiteResult* q;

    sqlite3 *access;

    sqlite3_stmt *stmt;

    bool skippedStatus; // the status of the fetchNext() that's skipped

    bool skipRow; // skip the next fetchNext()?

    QSqlRecord rInf;

    QVector<QVariant> firstRow;

};

QSQLiteResultPrivate::QSQLiteResultPrivate(QSQLiteResult* res) : q(res), access(0),

    stmt(0), skippedStatus(false), skipRow(false)

{

}

void QSQLiteResultPrivate::cleanup()

{

    finalize();

    rInf.clear();

    skippedStatus = false;

    skipRow = false;

    q->setAt(QSql::BeforeFirstRow);

    q->setActive(false);

    q->cleanup();

}

void QSQLiteResultPrivate::finalize()

{

    if (!stmt)

        return;

    sqlite3_finalize(stmt);

    stmt = 0;

}

void QSQLiteResultPrivate::initColumns(bool emptyResultset)

{

    int nCols = sqlite3_column_count(stmt);

    if (nCols <= 0)

        return;

    q->init(nCols);

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

        QString colName = QString::fromUtf16(

                    static_cast<const ushort *>(sqlite3_column_name16(stmt, i))

                    ).remove(QLatin1Char('"'));

        // must use typeName for resolving the type to match QSqliteDriver::record

        QString typeName = QString::fromUtf16(

                    static_cast<const ushort *>(sqlite3_column_decltype16(stmt, i)));

        int dotIdx = colName.lastIndexOf(QLatin1Char('.'));

        QSqlField fld(colName.mid(dotIdx == -1 ? 0 : dotIdx + 1), qGetColumnType(typeName));

        // sqlite3_column_type is documented to have undefined behavior if the result set is empty

        int stp = emptyResultset ? -1 : sqlite3_column_type(stmt, i);

        fld.setSqlType(stp);

        rInf.append(fld);

    }

}

bool QSQLiteResultPrivate::fetchNext(QSqlCachedResult::ValueCache &values, int idx, bool initialFetch)

{

    int res;

    int i;

    if (skipRow) {

        // already fetched

        Q_ASSERT(!initialFetch);

        skipRow = false;

        for(int i=0;i<firstRow.count();i++)

            values[i]=firstRow[i];

        return skippedStatus;

    }

    skipRow = initialFetch;

    if(initialFetch) {

        firstRow.clear();

        firstRow.resize(sqlite3_column_count(stmt));

    }

    if (!stmt) {

        q->setLastError(QSqlError(QCoreApplication::translate("QSQLiteResult", "Unable to fetch row"),

                                  QCoreApplication::translate("QSQLiteResult", "No query"), QSqlError::ConnectionError));

        q->setAt(QSql::AfterLastRow);

        return false;

    }

    res = sqlite3_step(stmt);

    switch(res) {

    case SQLITE_ROW:

        // check to see if should fill out columns

        if (rInf.isEmpty())

            // must be first call.

            initColumns(false);

        if (idx < 0 && !initialFetch)

            return true;

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

            switch (sqlite3_column_type(stmt, i)) {

            case SQLITE_BLOB:

                values[i + idx] = QByteArray(static_cast<const char *>(

                            sqlite3_column_blob(stmt, i)),

                            sqlite3_column_bytes(stmt, i));

                break;

            case SQLITE_INTEGER:

                values[i + idx] = sqlite3_column_int64(stmt, i);

                break;

            case SQLITE_FLOAT:

                switch(q->numericalPrecisionPolicy()) {

                    case QSql::LowPrecisionInt32:

                        values[i + idx] = sqlite3_column_int(stmt, i);

                        break;

                    case QSql::LowPrecisionInt64:

                        values[i + idx] = sqlite3_column_int64(stmt, i);

                        break;

                    case QSql::LowPrecisionDouble:

                    case QSql::HighPrecision:

                    default:

                        values[i + idx] = sqlite3_column_double(stmt, i);

                        break;

                };

                break;

            case SQLITE_NULL:

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

                break;

            default:

                values[i + idx] = QString(reinterpret_cast<const QChar *>(

                            sqlite3_column_text16(stmt, i)),

                            sqlite3_column_bytes16(stmt, i) / sizeof(QChar));

                break;

            }

        }

        return true;

    case SQLITE_DONE:

        if (rInf.isEmpty())

            // must be first call.

            initColumns(true);

        q->setAt(QSql::AfterLastRow);

        sqlite3_reset(stmt);

        return false;

    case SQLITE_ERROR:

        // SQLITE_ERROR is a generic error code and we must call sqlite3_reset()

        // to get the specific error message.

        res = sqlite3_reset(stmt);

        q->setLastError(qMakeError(access, QCoreApplication::translate("QSQLiteResult",

                        "Unable to fetch row"), QSqlError::ConnectionError, res));

        q->setAt(QSql::AfterLastRow);

        return false;

    case SQLITE_MISUSE:

    case SQLITE_BUSY:

    default:

        // something wrong, don't get col info, but still return false

        q->setLastError(qMakeError(access, QCoreApplication::translate("QSQLiteResult",

                        "Unable to fetch row"), QSqlError::ConnectionError, res));

        sqlite3_reset(stmt);

        q->setAt(QSql::AfterLastRow);

        return false;

    }

    return false;

}

QSQLiteResult::QSQLiteResult(const QSQLiteDriver* db)

    : QSqlCachedResult(db)

{

    d = new QSQLiteResultPrivate(this);

    d->access = db->d->access;

}

QSQLiteResult::~QSQLiteResult()

{

    d->cleanup();

    delete d;

}

void QSQLiteResult::virtual_hook(int id, void *data)

{

    switch (id) {

    case QSqlResult::DetachFromResultSet:

        if (d->stmt)

            sqlite3_reset(d->stmt);

        break;

    default:

        QSqlCachedResult::virtual_hook(id, data);

    }

}

bool QSQLiteResult::reset(const QString &query)

{

    if (!prepare(query))

        return false;

    return exec();

}

bool QSQLiteResult::prepare(const QString &query)

{

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

        return false;

    d->cleanup();

    setSelect(false);

#if (SQLITE_VERSION_NUMBER >= 3003011)

    int res = sqlite3_prepare16_v2(d->access, query.constData(), (query.size() + 1) * sizeof(QChar),

                                   &d->stmt, 0);

#else

    int res = sqlite3_prepare16(d->access, query.constData(), (query.size() + 1) * sizeof(QChar),

                                &d->stmt, 0);

#endif

    if (res != SQLITE_OK) {

        setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult",

                     "Unable to execute statement"), QSqlError::StatementError, res));

        d->finalize();

        return false;

    }

    return true;

}

bool QSQLiteResult::exec()

{

    const QVector<QVariant> values = boundValues();

    d->skippedStatus = false;

    d->skipRow = false;

    d->rInf.clear();

    clearValues();

    setLastError(QSqlError());

    int res = sqlite3_reset(d->stmt);

    if (res != SQLITE_OK) {

        setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult",

                     "Unable to reset statement"), QSqlError::StatementError, res));

        d->finalize();

        return false;

    }

    int paramCount = sqlite3_bind_parameter_count(d->stmt);

    if (paramCount == values.count()) {

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

            res = SQLITE_OK;

            const QVariant value = values.at(i);

            if (value.isNull()) {

                res = sqlite3_bind_null(d->stmt, i + 1);

            } else {

                switch (value.type()) {

                case QVariant::ByteArray: {

                    const QByteArray *ba = static_cast<const QByteArray*>(value.constData());

                    res = sqlite3_bind_blob(d->stmt, i + 1, ba->constData(),

                                            ba->size(), SQLITE_STATIC);

                    break; }

                case QVariant::Int:

                    res = sqlite3_bind_int(d->stmt, i + 1, value.toInt());

                    break;

                case QVariant::Double:

                    res = sqlite3_bind_double(d->stmt, i + 1, value.toDouble());

                    break;

                case QVariant::UInt:

                case QVariant::LongLong:

                    res = sqlite3_bind_int64(d->stmt, i + 1, value.toLongLong());

                    break;

                case QVariant::String: {

                    // lifetime of string == lifetime of its qvariant

                    const QString *str = static_cast<const QString*>(value.constData());

                    res = sqlite3_bind_text16(d->stmt, i + 1, str->utf16(),

                                              (str->size()) * sizeof(QChar), SQLITE_STATIC);

                    break; }

                default: {

                    QString str = value.toString();

                    // SQLITE_TRANSIENT makes sure that sqlite buffers the data

                    res = sqlite3_bind_text16(d->stmt, i + 1, str.utf16(),

                                              (str.size()) * sizeof(QChar), SQLITE_TRANSIENT);

                    break; }

                }

            }

            if (res != SQLITE_OK) {

                setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult",

                             "Unable to bind parameters"), QSqlError::StatementError, res));

                d->finalize();

                return false;

            }

        }

    } else {

        setLastError(QSqlError(QCoreApplication::translate("QSQLiteResult",

                        "Parameter count mismatch"), QString(), QSqlError::StatementError));

        return false;

    }

    d->skippedStatus = d->fetchNext(d->firstRow, 0, true);

    if (lastError().isValid()) {

        setSelect(false);

        setActive(false);

        return false;

    }

    setSelect(!d->rInf.isEmpty());

    setActive(true);

    return true;

}

bool QSQLiteResult::gotoNext(QSqlCachedResult::ValueCache& row, int idx)

{

    return d->fetchNext(row, idx, false);

}

int QSQLiteResult::size()

{

    return -1;

}

int QSQLiteResult::numRowsAffected()

{

    return sqlite3_changes(d->access);

}

QVariant QSQLiteResult::lastInsertId() const

{

    if (isActive()) {

        qint64 id = sqlite3_last_insert_rowid(d->access);

        if (id)

            return id;

    }

    return QVariant();

}

QSqlRecord QSQLiteResult::record() const

{

    if (!isActive() || !isSelect())

        return QSqlRecord();

    return d->rInf;

}

QVariant QSQLiteResult::handle() const

{

    return qVariantFromValue(d->stmt);

}

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

QSQLiteDriver::QSQLiteDriver(QObject * parent)

    : QSqlDriver(parent)

{

    d = new QSQLiteDriverPrivate();

}

QSQLiteDriver::QSQLiteDriver(sqlite3 *connection, QObject *parent)

    : QSqlDriver(parent)

{

    d = new QSQLiteDriverPrivate();

    d->access = connection;

    setOpen(true);

    setOpenError(false);

}

QSQLiteDriver::~QSQLiteDriver()

{

    delete d;

}

bool QSQLiteDriver::hasFeature(DriverFeature f) const

{

    switch (f) {

    case BLOB:

    case Transactions:

    case Unicode:

    case LastInsertId:

    case PreparedQueries:

    case PositionalPlaceholders:

    case SimpleLocking:

    case FinishQuery:

    case LowPrecisionNumbers:

        return true;

    case QuerySize:

    case NamedPlaceholders:

    case BatchOperations:

    case EventNotifications:

    case MultipleResultSets:

        return false;

    }

    return false;

}

/*

   SQLite dbs have no user name, passwords, hosts or ports.

   just file names.

*/

bool QSQLiteDriver::open(const QString & db, const QString &, const QString &, const QString &, int, const QString &conOpts)

{

    if (isOpen())

        close();

    if (db.isEmpty())

        return false;

    bool sharedCache = false;

    int openMode = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, timeOut=5000;

    QStringList opts=QString(conOpts).remove(QLatin1Char(' ')).split(QLatin1Char(';'));

    foreach(const QString &option, opts) {

        if (option.startsWith(QLatin1String("QSQLITE_BUSY_TIMEOUT="))) {

            bool ok;

            int nt = option.mid(21).toInt(&ok);

            if (ok)

                timeOut = nt;

        }

        if (option == QLatin1String("QSQLITE_OPEN_READONLY"))

            openMode = SQLITE_OPEN_READONLY;