Import QSQLite from 4.8.1. Import Clementine's smain.cpp and

CMakeLists.txt (thanks, Clementine!). Do some name changing for sanity's
sake so we're sure of which plugin we're actually connected to.

src/libtomahawk/CMakeLists.txt

@@ -301,6 +301,8 @@ set( libSources
     thirdparty/kdsingleapplicationguard/kdsharedmemorylocker.cpp
     thirdparty/kdsingleapplicationguard/kdtoolsglobal.cpp
     thirdparty/kdsingleapplicationguard/kdlockedsharedmemorypointer.cpp
+
+    ${THIRDPARTY_DIR}/qsqlite-4.8.1/qsql_thsqlite.cpp
 )
 
 set( libUI ${libUI}
@@ -339,6 +341,7 @@ include_directories( . ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/.
 
     ${LIBPORTFWD_INCLUDE_DIR}
     ${THIRDPARTY_DIR}/qxt/qxtweb-standalone/qxtweb
+    ${THIRDPARTY_DIR}/qsqlite-4.8.1
     ${QuaZip_INCLUDE_DIR}
 )
 
@@ -434,6 +437,8 @@ TARGET_LINK_LIBRARIES( tomahawklib
     # Thirdparty shipped with tomahawk
     ${LIBPORTFWD_LIBRARIES}
 
+    sqlite3
+
     # External deps
     ${QJSON_LIBRARIES}
     ${PHONON_LIBS}

src/libtomahawk/database/DatabaseImpl.cpp

@@ -34,6 +34,8 @@
 #include "utils/TomahawkUtils.h"
 #include "utils/Logger.h"
 
+#include "qsql_thsqlite.h"
+
 /* !!!! You need to manually generate Schema.sql.h when the schema changes:
     cd src/libtomahawk/database
    ./gen_schema.h.sh ./Schema.sql tomahawk > Schema.sql.h
@@ -42,7 +44,6 @@
 
 #define CURRENT_SCHEMA_VERSION 28
 
-
 DatabaseImpl::DatabaseImpl( const QString& dbname, Database* parent )
     : QObject( parent )
     , m_parent( parent )
@@ -714,7 +715,8 @@ DatabaseImpl::openDatabase( const QString& dbname, bool checkSchema )
     bool schemaUpdated = false;
     int version = -1;
     {
-        QSqlDatabase db = QSqlDatabase::addDatabase( "QSQLITE", connName );
+        QTHSQLiteDriver* driver = new QTHSQLiteDriver();
+        QSqlDatabase db = QSqlDatabase::addDatabase( driver, connName );
         db.setDatabaseName( dbname );
         db.setConnectOptions( "QSQLITE_ENABLE_SHARED_CACHE=1" );
         if ( !db.open() )
@@ -753,7 +755,8 @@ DatabaseImpl::openDatabase( const QString& dbname, bool checkSchema )
 
         QFile::copy( dbname, newname );
         {
-            m_db = QSqlDatabase::addDatabase( "QSQLITE", connName );
+            QTHSQLiteDriver* driver = new QTHSQLiteDriver();
+            m_db = QSqlDatabase::addDatabase( driver, connName );
             m_db.setDatabaseName( dbname );
             if ( !m_db.open() )
                 throw "db moving failed";

thirdparty/qsqlite-4.8.1/CMakeLists.txt

@@ -0,0 +1,37 @@
+cmake_minimum_required(VERSION 2.6)
+
+FIND_PACKAGE( Qt4 4.8.1 COMPONENTS QtCore QtSql REQUIRED )
+set(QT_USE_QTSQL TRUE)
+include( ${QT_USE_FILE} )
+
+# Source files
+set(THSQLITE-SOURCES
+    qsql_thsqlite.cpp
+    smain.cpp
+)
+
+# Header files that have Q_OBJECT in
+set(THSQLITE-MOC-HEADERS
+    qsql_thsqlite.h
+)
+
+qt4_wrap_cpp(THSQLITE-SOURCES-MOC ${THSQLITE-MOC-HEADERS})
+
+include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR} ${QT_INCLUDES})
+
+add_library(tomahawk_qsqlite SHARED
+  ${THSQLITE-SOURCES}
+  ${THSQLITE-SOURCES-MOC}
+)
+target_link_libraries(tomahawk_qsqlite
+    sqlite3
+    ${QT_LIBRARIES}
+)
+
+INSTALL( TARGETS tomahawk_qsqlite
+    RUNTIME DESTINATION bin
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    BUNDLE DESTINATION library
+)
+

thirdparty/qsqlite-4.8.1/qsql_thsqlite.cpp

@@ -0,0 +1,750 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 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$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsql_thsqlite.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 == QLatin1String("real")
+        || 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(reinterpret_cast<const QChar *>(sqlite3_errmsg16(access))),
+                     type, errorCode);
+}
+
+class QTHSQLiteDriverPrivate
+{
+public:
+    inline QTHSQLiteDriverPrivate() : access(0) {}
+    sqlite3 *access;
+    QList <QTHSQLiteResult *> results;
+};
+
+
+class QTHSQLiteResultPrivate
+{
+public:
+    QTHSQLiteResultPrivate(QTHSQLiteResult *res);
+    void cleanup();
+    bool fetchNext(QSqlCachedResult::ValueCache &values, int idx, bool initialFetch);
+    // initializes the recordInfo and the cache
+    void initColumns(bool emptyResultset);
+    void finalize();
+
+    QTHSQLiteResult* 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;
+};
+
+QTHSQLiteResultPrivate::QTHSQLiteResultPrivate(QTHSQLiteResult* res) : q(res), access(0),
+    stmt(0), skippedStatus(false), skipRow(false)
+{
+}
+
+void QTHSQLiteResultPrivate::cleanup()
+{
+    finalize();
+    rInf.clear();
+    skippedStatus = false;
+    skipRow = false;
+    q->setAt(QSql::BeforeFirstRow);
+    q->setActive(false);
+    q->cleanup();
+}
+
+void QTHSQLiteResultPrivate::finalize()
+{
+    if (!stmt)
+        return;
+
+    sqlite3_finalize(stmt);
+    stmt = 0;
+}
+
+void QTHSQLiteResultPrivate::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(reinterpret_cast<const QChar *>(
+                    sqlite3_column_name16(stmt, i))
+                    ).remove(QLatin1Char('"'));
+
+        // must use typeName for resolving the type to match QSqliteDriver::record
+        QString typeName = QString(reinterpret_cast<const QChar *>(
+                    sqlite3_column_decltype16(stmt, i)));
+        // sqlite3_column_type is documented to have undefined behavior if the result set is empty
+        int stp = emptyResultset ? -1 : sqlite3_column_type(stmt, i);
+
+        QVariant::Type fieldType;
+
+        if (!typeName.isEmpty()) {
+            fieldType = qGetColumnType(typeName);
+        } else {
+            // Get the proper type for the field based on stp value
+            switch (stp) {
+            case SQLITE_INTEGER:
+                fieldType = QVariant::Int;
+                break;
+            case SQLITE_FLOAT:
+                fieldType = QVariant::Double;
+                break;
+            case SQLITE_BLOB:
+                fieldType = QVariant::ByteArray;
+                break;
+            case SQLITE_TEXT:
+                fieldType = QVariant::String;
+                break;
+            case SQLITE_NULL:
+            default:
+                fieldType = QVariant::Invalid;
+                break;
+            }
+        }
+
+        int dotIdx = colName.lastIndexOf(QLatin1Char('.'));
+        QSqlField fld(colName.mid(dotIdx == -1 ? 0 : dotIdx + 1), fieldType);
+        fld.setSqlType(stp);
+        rInf.append(fld);
+    }
+}
+
+bool QTHSQLiteResultPrivate::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("QTHSQLiteResult", "Unable to fetch row"),
+                                  QCoreApplication::translate("QTHSQLiteResult", "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_CONSTRAINT:
+    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("QTHSQLiteResult",
+                        "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("QTHSQLiteResult",
+                        "Unable to fetch row"), QSqlError::ConnectionError, res));
+        sqlite3_reset(stmt);
+        q->setAt(QSql::AfterLastRow);
+        return false;
+    }
+    return false;
+}
+
+QTHSQLiteResult::QTHSQLiteResult(const QTHSQLiteDriver* db)
+    : QSqlCachedResult(db)
+{
+    d = new QTHSQLiteResultPrivate(this);
+    d->access = db->d->access;
+    db->d->results.append(this);
+}
+
+QTHSQLiteResult::~QTHSQLiteResult()
+{
+    const QTHSQLiteDriver * sqlDriver = qobject_cast<const QTHSQLiteDriver *>(driver());
+    if (sqlDriver)
+        sqlDriver->d->results.removeOne(this);
+    d->cleanup();
+    delete d;
+}
+
+void QTHSQLiteResult::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 QTHSQLiteResult::reset(const QString &query)
+{
+    if (!prepare(query))
+        return false;
+    return exec();
+}
+
+bool QTHSQLiteResult::prepare(const QString &query)
+{
+    if (!driver() || !driver()->isOpen() || driver()->isOpenError())
+        return false;
+
+    d->cleanup();
+
+    setSelect(false);
+
+    const void *pzTail = NULL;
+
+#if (SQLITE_VERSION_NUMBER >= 3003011)
+    int res = sqlite3_prepare16_v2(d->access, query.constData(), (query.size() + 1) * sizeof(QChar),
+                                   &d->stmt, &pzTail);
+#else
+    int res = sqlite3_prepare16(d->access, query.constData(), (query.size() + 1) * sizeof(QChar),
+                                &d->stmt, &pzTail);
+#endif
+
+    if (res != SQLITE_OK) {
+        setLastError(qMakeError(d->access, QCoreApplication::translate("QTHSQLiteResult",
+                     "Unable to execute statement"), QSqlError::StatementError, res));
+        d->finalize();
+        return false;
+    } else if (pzTail && !QString(reinterpret_cast<const QChar *>(pzTail)).trimmed().isEmpty()) {
+        setLastError(qMakeError(d->access, QCoreApplication::translate("QTHSQLiteResult",
+            "Unable to execute multiple statements at a time"), QSqlError::StatementError, SQLITE_MISUSE));
+        d->finalize();
+        return false;
+    }
+    return true;
+}
+
+bool QTHSQLiteResult::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("QTHSQLiteResult",
+                     "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("QTHSQLiteResult",
+                             "Unable to bind parameters"), QSqlError::StatementError, res));
+                d->finalize();
+                return false;
+            }
+        }
+    } else {
+        setLastError(QSqlError(QCoreApplication::translate("QTHSQLiteResult",
+                        "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 QTHSQLiteResult::gotoNext(QSqlCachedResult::ValueCache& row, int idx)
+{
+    return d->fetchNext(row, idx, false);
+}
+
+int QTHSQLiteResult::size()
+{
+    return -1;
+}
+
+int QTHSQLiteResult::numRowsAffected()
+{
+    return sqlite3_changes(d->access);
+}
+
+QVariant QTHSQLiteResult::lastInsertId() const
+{
+    if (isActive()) {
+        qint64 id = sqlite3_last_insert_rowid(d->access);
+        if (id)
+            return id;
+    }
+    return QVariant();
+}
+
+QSqlRecord QTHSQLiteResult::record() const
+{
+    if (!isActive() || !isSelect())
+        return QSqlRecord();
+    return d->rInf;
+}
+
+QVariant QTHSQLiteResult::handle() const
+{
+    return QVariant::fromValue(d->stmt);
+}
+
+/////////////////////////////////////////////////////////
+
+QTHSQLiteDriver::QTHSQLiteDriver(QObject * parent)
+    : QSqlDriver(parent)
+{
+    d = new QTHSQLiteDriverPrivate();
+}
+
+QTHSQLiteDriver::QTHSQLiteDriver(sqlite3 *connection, QObject *parent)
+    : QSqlDriver(parent)
+{
+    d = new QTHSQLiteDriverPrivate();
+    d->access = connection;
+    setOpen(true);
+    setOpenError(false);
+}
+
+
+QTHSQLiteDriver::~QTHSQLiteDriver()
+{
+    delete d;
+}
+
+bool QTHSQLiteDriver::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 QTHSQLiteDriver::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;
+        if (option == QLatin1String("QSQLITE_ENABLE_SHARED_CACHE"))
+            sharedCache = true;
+    }
+
+    sqlite3_enable_shared_cache(sharedCache);
+
+    if (sqlite3_open_v2(db.toUtf8().constData(), &d->access, openMode, NULL) == SQLITE_OK) {
+        sqlite3_busy_timeout(d->access, timeOut);
+        setOpen(true);
+        setOpenError(false);
+        return true;
+    } else {
+        setLastError(qMakeError(d->access, tr("Error opening database"),
+                     QSqlError::ConnectionError));
+        setOpenError(true);
+        return false;
+    }
+}
+
+void QTHSQLiteDriver::close()
+{
+    if (isOpen()) {
+        foreach (QTHSQLiteResult *result, d->results)
+            result->d->finalize();
+
+        if (sqlite3_close(d->access) != SQLITE_OK)
+            setLastError(qMakeError(d->access, tr("Error closing database"),
+                                    QSqlError::ConnectionError));
+        d->access = 0;
+        setOpen(false);
+        setOpenError(false);
+    }
+}
+
+QSqlResult *QTHSQLiteDriver::createResult() const
+{
+    return new QTHSQLiteResult(this);
+}
+
+bool QTHSQLiteDriver::beginTransaction()
+{
+    if (!isOpen() || isOpenError())
+        return false;
+
+    QSqlQuery q(createResult());
+    if (!q.exec(QLatin1String("BEGIN"))) {
+        setLastError(QSqlError(tr("Unable to begin transaction"),
+                               q.lastError().databaseText(), QSqlError::TransactionError));
+        return false;
+    }
+
+    return true;
+}
+
+bool QTHSQLiteDriver::commitTransaction()
+{
+    if (!isOpen() || isOpenError())
+        return false;
+
+    QSqlQuery q(createResult());
+    if (!q.exec(QLatin1String("COMMIT"))) {
+        setLastError(QSqlError(tr("Unable to commit transaction"),
+                               q.lastError().databaseText(), QSqlError::TransactionError));
+        return false;
+    }
+
+    return true;
+}
+
+bool QTHSQLiteDriver::rollbackTransaction()
+{
+    if (!isOpen() || isOpenError())
+        return false;
+
+    QSqlQuery q(createResult());
+    if (!q.exec(QLatin1String("ROLLBACK"))) {
+        setLastError(QSqlError(tr("Unable to rollback transaction"),
+                               q.lastError().databaseText(), QSqlError::TransactionError));
+        return false;
+    }
+
+    return true;
+}
+
+QStringList QTHSQLiteDriver::tables(QSql::TableType type) const
+{
+    QStringList res;
+    if (!isOpen())
+        return res;
+
+    QSqlQuery q(createResult());
+    q.setForwardOnly(true);
+
+    QString sql = QLatin1String("SELECT name FROM sqlite_master WHERE %1 "
+                                "UNION ALL SELECT name FROM sqlite_temp_master WHERE %1");
+    if ((type & QSql::Tables) && (type & QSql::Views))
+        sql = sql.arg(QLatin1String("type='table' OR type='view'"));
+    else if (type & QSql::Tables)
+        sql = sql.arg(QLatin1String("type='table'"));
+    else if (type & QSql::Views)
+        sql = sql.arg(QLatin1String("type='view'"));
+    else
+        sql.clear();
+
+    if (!sql.isEmpty() && q.exec(sql)) {
+        while(q.next())
+            res.append(q.value(0).toString());
+    }
+
+    if (type & QSql::SystemTables) {
+        // there are no internal tables beside this one:
+        res.append(QLatin1String("sqlite_master"));
+    }
+
+    return res;
+}
+
+static QSqlIndex qGetTableInfo(QSqlQuery &q, const QString &tableName, bool onlyPIndex = false)
+{
+    QString schema;
+    QString table(tableName);
+    int indexOfSeparator = tableName.indexOf(QLatin1Char('.'));
+    if (indexOfSeparator > -1) {
+        schema = tableName.left(indexOfSeparator).append(QLatin1Char('.'));
+        table = tableName.mid(indexOfSeparator + 1);
+    }
+    q.exec(QLatin1String("PRAGMA ") + schema + QLatin1String("table_info (") + _q_escapeIdentifier(table) + QLatin1String(")"));
+
+    QSqlIndex ind;
+    while (q.next()) {
+        bool isPk = q.value(5).toInt();
+        if (onlyPIndex && !isPk)
+            continue;
+        QString typeName = q.value(2).toString().toLower();
+        QSqlField fld(q.value(1).toString(), qGetColumnType(typeName));
+        if (isPk && (typeName == QLatin1String("integer")))
+            // INTEGER PRIMARY KEY fields are auto-generated in sqlite
+            // INT PRIMARY KEY is not the same as INTEGER PRIMARY KEY!
+            fld.setAutoValue(true);
+        fld.setRequired(q.value(3).toInt() != 0);
+        fld.setDefaultValue(q.value(4));
+        ind.append(fld);
+    }
+    return ind;
+}
+
+QSqlIndex QTHSQLiteDriver::primaryIndex(const QString &tblname) const
+{
+    if (!isOpen())
+        return QSqlIndex();
+
+    QString table = tblname;
+    if (isIdentifierEscaped(table, QSqlDriver::TableName))
+        table = stripDelimiters(table, QSqlDriver::TableName);
+
+    QSqlQuery q(createResult());
+    q.setForwardOnly(true);
+    return qGetTableInfo(q, table, true);
+}
+
+QSqlRecord QTHSQLiteDriver::record(const QString &tbl) const
+{
+    if (!isOpen())
+        return QSqlRecord();
+
+    QString table = tbl;
+    if (isIdentifierEscaped(table, QSqlDriver::TableName))
+        table = stripDelimiters(table, QSqlDriver::TableName);
+
+    QSqlQuery q(createResult());
+    q.setForwardOnly(true);
+    return qGetTableInfo(q, table);
+}
+
+QVariant QTHSQLiteDriver::handle() const
+{
+    return QVariant::fromValue(d->access);
+}
+
+QString QTHSQLiteDriver::escapeIdentifier(const QString &identifier, IdentifierType type) const
+{
+    Q_UNUSED(type);
+    return _q_escapeIdentifier(identifier);
+}
+
+QT_END_NAMESPACE

thirdparty/qsqlite-4.8.1/qsql_thsqlite.h

@@ -0,0 +1,123 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 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$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSQL_THSQLITE_H
+#define QSQL_THSQLITE_H
+
+#include <QtSql/qsqldriver.h>
+#include <QtSql/qsqlresult.h>
+#include <qsqlcachedresult_p.h>
+
+struct sqlite3;
+
+#ifdef QT_PLUGIN
+#define Q_EXPORT_SQLDRIVER_THSQLITE
+#else
+#define Q_EXPORT_SQLDRIVER_THSQLITE Q_SQL_EXPORT
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+class QTHSQLiteDriverPrivate;
+class QTHSQLiteResultPrivate;
+class QTHSQLiteDriver;
+
+class QTHSQLiteResult : public QSqlCachedResult
+{
+    friend class QTHSQLiteDriver;
+    friend class QTHSQLiteResultPrivate;
+public:
+    explicit QTHSQLiteResult(const QTHSQLiteDriver* db);
+    ~QTHSQLiteResult();
+    QVariant handle() const;
+
+protected:
+    bool gotoNext(QSqlCachedResult::ValueCache& row, int idx);
+    bool reset(const QString &query);
+    bool prepare(const QString &query);
+    bool exec();
+    int size();
+    int numRowsAffected();
+    QVariant lastInsertId() const;
+    QSqlRecord record() const;
+    void virtual_hook(int id, void *data);
+
+private:
+    QTHSQLiteResultPrivate* d;
+};
+
+class Q_EXPORT_SQLDRIVER_THSQLITE QTHSQLiteDriver : public QSqlDriver
+{
+    Q_OBJECT
+    friend class QTHSQLiteResult;
+public:
+    explicit QTHSQLiteDriver(QObject *parent = 0);
+    explicit QTHSQLiteDriver(sqlite3 *connection, QObject *parent = 0);
+    ~QTHSQLiteDriver();
+    bool hasFeature(DriverFeature f) const;
+    bool open(const QString & db,
+                   const QString & user,
+                   const QString & password,
+                   const QString & host,
+                   int port,
+                   const QString & connOpts);
+    void close();
+    QSqlResult *createResult() const;
+    bool beginTransaction();
+    bool commitTransaction();
+    bool rollbackTransaction();
+    QStringList tables(QSql::TableType) const;
+
+    QSqlRecord record(const QString& tablename) const;
+    QSqlIndex primaryIndex(const QString &table) const;
+    QVariant handle() const;
+    QString escapeIdentifier(const QString &identifier, IdentifierType) const;
+
+private:
+    QTHSQLiteDriverPrivate* d;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QSQL_THSQLITE_H

thirdparty/qsqlite-4.8.1/qsqlcachedresult_p.h

@@ -0,0 +1,100 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 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$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSQLCACHEDRESULT_P_H
+#define QSQLCACHEDRESULT_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtSql/qsqlresult.h"
+
+QT_BEGIN_NAMESPACE
+
+class QVariant;
+template <typename T> class QVector;
+
+class QSqlCachedResultPrivate;
+
+class Q_SQL_EXPORT QSqlCachedResult: public QSqlResult
+{
+public:
+    virtual ~QSqlCachedResult();
+
+    typedef QVector<QVariant> ValueCache;
+
+protected:
+    QSqlCachedResult(const QSqlDriver * db);
+
+    void init(int colCount);
+    void cleanup();
+    void clearValues();
+
+    virtual bool gotoNext(ValueCache &values, int index) = 0;
+
+    QVariant data(int i);
+    bool isNull(int i);
+    bool fetch(int i);
+    bool fetchNext();
+    bool fetchPrevious();
+    bool fetchFirst();
+    bool fetchLast();
+
+    int colCount() const;
+    ValueCache &cache();
+
+    void virtual_hook(int id, void *data);
+private:
+    bool cacheNext();
+    QSqlCachedResultPrivate *d;
+};
+
+QT_END_NAMESPACE
+
+#endif // QSQLCACHEDRESULT_P_H

thirdparty/qsqlite-4.8.1/smain.cpp

@@ -0,0 +1,81 @@
+/****************************************************************************
+**
+** 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 plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qsqldriverplugin.h>
+#include <qstringlist.h>
+#include "qsql_thsqlite.h"
+
+QT_BEGIN_NAMESPACE
+
+class QTHSQLiteDriverPlugin : public QSqlDriverPlugin
+{
+public:
+    QTHSQLiteDriverPlugin();
+
+    QSqlDriver* create(const QString &);
+    QStringList keys() const;
+};
+
+QTHSQLiteDriverPlugin::QTHSQLiteDriverPlugin()
+    : QSqlDriverPlugin()
+{
+}
+
+QSqlDriver* QTHSQLiteDriverPlugin::create(const QString &name)
+{
+    if (name == QLatin1String("QTHSQLITE")) {
+        QTHSQLiteDriver* driver = new QTHSQLiteDriver();
+        return driver;
+    }
+    return 0;
+}
+
+QStringList QTHSQLiteDriverPlugin::keys() const
+{
+    QStringList l;
+    l.append(QLatin1String("QTHSQLITE"));
+    return l;
+}
+
+Q_EXPORT_STATIC_PLUGIN(QTHSQLiteDriverPlugin)
+Q_EXPORT_PLUGIN2(qsqlthsqlite, QTHSQLiteDriverPlugin)
+
+QT_END_NAMESPACE