1 files changed, 52 insertions, 35 deletions

diff --git a/platform/qt/src/sqlite3.cpp b/platform/qt/src/sqlite3.cpp
index 7d47ae552b..2f3db12f33 100644
--- a/platform/qt/src/sqlite3.cpp
+++ b/platform/qt/src/sqlite3.cpp
@@ -6,6 +6,7 @@
 #include <QStringList>
 #include <QThread>
 #include <QVariant>
+#include <QAtomicInt>
 
 #include <cassert>
 #include <cstring>
@@ -60,20 +61,26 @@ void checkDatabaseOpenError(const QSqlDatabase &db) {
     }
 }
 
+namespace {
+    QString incrementCounter() {
+        static QAtomicInt count = 0;
+        return QString::number(count.fetchAndAddAcquire(1));
+    }
+}
+
 class DatabaseImpl {
 public:
-    DatabaseImpl(const char* filename, int flags) {
-        static uint64_t count = 0;
-        const QString connectionName = QString::number(uint64_t(QThread::currentThread())) + QString::number(count++);
-
+    DatabaseImpl(const char* filename, int flags)
+        : connectionName(QString::number(uint64_t(QThread::currentThread())) + incrementCounter())
+    {
         if (!QSqlDatabase::drivers().contains("QSQLITE")) {
             throw Exception { Exception::Code::CANTOPEN, "SQLite driver not found." };
         }
 
         assert(!QSqlDatabase::contains(connectionName));
-        db.reset(new QSqlDatabase(QSqlDatabase::addDatabase("QSQLITE", connectionName)));
+        auto db = QSqlDatabase::addDatabase("QSQLITE", connectionName);
 
-        QString connectOptions = db->connectOptions();
+        QString connectOptions = db.connectOptions();
         if (flags & OpenFlag::ReadOnly) {
             if (!connectOptions.isEmpty()) connectOptions.append(';');
             connectOptions.append("QSQLITE_OPEN_READONLY");
@@ -83,26 +90,26 @@ public:
             connectOptions.append("QSQLITE_ENABLE_SHARED_CACHE");
         }
 
-        db->setConnectOptions(connectOptions);
-        db->setDatabaseName(QString(filename));
+        db.setConnectOptions(connectOptions);
+        db.setDatabaseName(QString(filename));
 
-        if (!db->open()) {
-            checkDatabaseOpenError(*db);
+        if (!db.open()) {
+            checkDatabaseOpenError(db);
         }
     }
 
     ~DatabaseImpl() {
-        db->close();
-        checkDatabaseError(*db);
+        auto db = QSqlDatabase::database(connectionName);
+        db.close();
+        checkDatabaseError(db);
     }
 
-    QScopedPointer<QSqlDatabase> db;
+    QString connectionName;
 };
 
 class StatementImpl {
 public:
     StatementImpl(const QString& sql, const QSqlDatabase& db) : query(db) {
-        query.setForwardOnly(true);
         if (!query.prepare(sql)) {
             checkQueryError(query);
         }
@@ -147,17 +154,18 @@ void Database::setBusyTimeout(std::chrono::milliseconds timeout) {
     // internally to int, so we need to make sure the limits apply.
     std::string timeoutStr = mbgl::util::toString(timeout.count() & INT_MAX);
 
-    QString connectOptions = impl->db->connectOptions();
+    auto db = QSqlDatabase::database(impl->connectionName);
+    QString connectOptions = db.connectOptions();
     if (connectOptions.isEmpty()) {
         if (!connectOptions.isEmpty()) connectOptions.append(';');
         connectOptions.append("QSQLITE_BUSY_TIMEOUT=").append(QString::fromStdString(timeoutStr));
     }
-    if (impl->db->isOpen()) {
-        impl->db->close();
+    if (db.isOpen()) {
+        db.close();
     }
-    impl->db->setConnectOptions(connectOptions);
-    if (!impl->db->open()) {
-        checkDatabaseOpenError(*impl->db);
+    db.setConnectOptions(connectOptions);
+    if (!db.open()) {
+        checkDatabaseOpenError(db);
     }
 }
 
@@ -169,9 +177,9 @@ void Database::exec(const std::string &sql) {
         if (!statement.endsWith(';')) {
             statement.append(';');
         }
-        QSqlQuery query(*impl->db);
-        query.setForwardOnly(true);
+        QSqlQuery query(QSqlDatabase::database(impl->connectionName));
         query.prepare(statement);
+
         if (!query.exec()) {
             checkQueryError(query);
         }
@@ -183,7 +191,7 @@ Statement Database::prepare(const char *query) {
 }
 
 Statement::Statement(Database *db, const char *sql)
-        : impl(std::make_unique<StatementImpl>(QString(sql), *db->impl->db)) {
+        : impl(std::make_unique<StatementImpl>(QString(sql), QSqlDatabase::database(db->impl->connectionName))) {
     assert(impl);
 }
 
@@ -269,9 +277,13 @@ void Statement::bind(int offset, const char* value, std::size_t length, bool ret
         throw std::range_error("value too long");
     }
 
+    // Qt SQLite driver treats QByteArray as blob: we need to explicitly
+    // declare the variant type as string.
+    QVariant text(QVariant::Type::String);
+    text.setValue(retain ? QByteArray(value, length) : QByteArray::fromRawData(value, length));
+
     // Field numbering starts at 0.
-    impl->query.bindValue(offset - 1, retain ? QByteArray(value, length) :
-            QByteArray::fromRawData(value, length), QSql::In);
+    impl->query.bindValue(offset - 1, std::move(text), QSql::In);
 
     checkQueryError(impl->query);
 }
@@ -281,7 +293,12 @@ void Statement::bind(int offset, const std::string& value, bool retain) {
 }
 
 void Statement::bindBlob(int offset, const void* value_, std::size_t length, bool retain) {
+    assert(impl);
     const char* value = reinterpret_cast<const char*>(value_);
+    if (length > std::numeric_limits<int>::max()) {
+        // Kept for consistence with the default implementation.
+        throw std::range_error("value too long");
+    }
 
     // Field numbering starts at 0.
     impl->query.bindValue(offset - 1, retain ? QByteArray(value, length) :
@@ -296,20 +313,20 @@ void Statement::bindBlob(int offset, const std::vector<uint8_t>& value, bool ret
 
 bool Statement::run() {
     assert(impl);
-    if (impl->query.isValid()) {
-        return impl->query.next();
-    }
 
-    assert(!impl->query.isActive());
-    impl->query.setForwardOnly(true);
-    if (!impl->query.exec()) {
-        checkQueryError(impl->query);
+    if (!impl->query.isValid()) {
+       if (impl->query.exec()) {
+           impl->lastInsertRowId = impl->query.lastInsertId().value<int64_t>();
+           impl->changes = impl->query.numRowsAffected();
+       } else {
+           checkQueryError(impl->query);
+       }
     }
 
-    impl->lastInsertRowId = impl->query.lastInsertId().value<int64_t>();
-    impl->changes = impl->query.numRowsAffected();
+    const bool hasNext = impl->query.next();
+    if (!hasNext) impl->query.finish();
 
-    return impl->query.next();
+    return hasNext;
 }
 
 template bool Statement::get(int);