SQL/Tests: use TableScope where possible

Use TableScope helper class to make sure the table used for the test is
really cleaned up before usage.

Change-Id: I45fffcd13acae6032636ae07097b14af174ede21
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>

4 files changed, 242 insertions, 319 deletions

diff --git a/tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp b/tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp
index f34045b2a0..3eeb91b680 100644
--- a/tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp
+++ b/tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp
@@ -175,13 +175,13 @@ private slots:
     void sqlite_check_json1();
 
 private:
-    void createTestTables(QSqlDatabase db);
-    void dropTestTables(QSqlDatabase db);
-    void populateTestTables(QSqlDatabase db);
+    void createTestTables(const QSqlDatabase &db);
+    void dropTestTables(const QSqlDatabase &db);
+    void populateTestTables(const QSqlDatabase &db);
     void generic_data(const QString &engine=QString());
 
-    void testRecord(const FieldDef fieldDefs[], const QSqlRecord& inf, QSqlDatabase db);
-    void commonFieldTest(const FieldDef fieldDefs[], QSqlDatabase, const int);
+    void testRecord(const FieldDef fieldDefs[], const QSqlRecord& inf, const QSqlDatabase &db);
+    void commonFieldTest(const FieldDef fieldDefs[], const QSqlDatabase &db, const int fieldCount);
 
     tst_Databases dbs;
 };
@@ -216,7 +216,7 @@ struct FieldDef {
 
 // creates a table out of the FieldDefs and returns the number of fields
 // excluding the primary key field
-static int createFieldTable(const FieldDef fieldDefs[], QSqlDatabase db)
+static int createFieldTable(const FieldDef fieldDefs[], const QSqlDatabase &db)
 {
     QSqlDriver::DbmsType dbType = tst_Databases::getDatabaseType(db);
     const QString tableName = qTableName("qtestfields", __FILE__, db);
@@ -251,7 +251,7 @@ static int createFieldTable(const FieldDef fieldDefs[], QSqlDatabase db)
     return i;
 }
 
-void tst_QSqlDatabase::createTestTables(QSqlDatabase db)
+void tst_QSqlDatabase::createTestTables(const QSqlDatabase &db)
 {
     if (!db.isValid())
     return;
@@ -285,7 +285,7 @@ void tst_QSqlDatabase::createTestTables(QSqlDatabase db)
     QVERIFY_SQL(q, exec(qry));
 }
 
-void tst_QSqlDatabase::dropTestTables(QSqlDatabase db)
+void tst_QSqlDatabase::dropTestTables(const QSqlDatabase &db)
 {
     if (!db.isValid())
         return;
@@ -297,30 +297,11 @@ void tst_QSqlDatabase::dropTestTables(QSqlDatabase db)
     }
 
     // drop the view first, otherwise we'll get dependency problems
-    tst_Databases::safeDropViews(db, QStringList() << qTableName("qtest_view", __FILE__, db) << qTableName("qtest_view2", __FILE__, db));
-    const QString qtestTable = qTableName("qtest", __FILE__, db);
-    QStringList tableNames;
-    tableNames << qtestTable
-            << qTableName("qtest test", __FILE__, db)
-            << qTableName("qtestfields", __FILE__, db)
-            << qTableName("qtestalter", __FILE__, db)
-            << qTableName("qtest_temp", __FILE__, db)
-            << qTableName("qtest_xmltype", __FILE__, db)
-            << qTableName("latin1table", __FILE__, db)
-            << qTableName("qtest_sqlguid", __FILE__, db)
-            << qTableName("batable", __FILE__, db)
-            << qTableName("qtest_prec", __FILE__, db)
-            << qTableName("uint", __FILE__, db)
-            << qTableName("strings", __FILE__, db)
-            << qTableName("numericfields", __FILE__, db)
-            << qTableName("qtest_ibaseblobs", __FILE__, db)
-            << qTableName("qtestBindBool", __FILE__, db)
-            << qTableName("testqGetString", __FILE__, db)
-            << qTableName("qtest_sqlguid", __FILE__, db)
-            << qTableName("uint_table", __FILE__, db)
-            << qTableName("uint_test", __FILE__, db)
-            << qTableName("bug_249059", __FILE__, db)
-            << qTableName("regexp_test", __FILE__, db);
+    tst_Databases::safeDropViews(db, {qTableName("qtest_view", __FILE__, db),
+                                      qTableName("qtest_view2", __FILE__, db)});
+    QStringList tableNames = {qTableName("qtest", __FILE__, db),
+                              qTableName("qtest test", __FILE__, db),
+                              qTableName("qtestfields", __FILE__, db)};
 
     QSqlQuery q(0, db);
     if (dbType == QSqlDriver::PostgreSQL) {
@@ -340,7 +321,7 @@ void tst_QSqlDatabase::dropTestTables(QSqlDatabase db)
     }
 }
 
-void tst_QSqlDatabase::populateTestTables(QSqlDatabase db)
+void tst_QSqlDatabase::populateTestTables(const QSqlDatabase &db)
 {
     if (!db.isValid())
         return;
@@ -526,11 +507,11 @@ void tst_QSqlDatabase::alterTable()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-    const QString qtestalter(qTableName("qtestalter", __FILE__, db));
+    TableScope ts(db, "qtestalter", __FILE__);
     QSqlQuery q(db);
 
-    QVERIFY_SQL(q, exec("create table " + qtestalter + " (F1 char(20), F2 char(20), F3 char(20))"));
-    QSqlRecord rec = db.record(qtestalter);
+    QVERIFY_SQL(q, exec("create table " + ts.tableName() + " (F1 char(20), F2 char(20), F3 char(20))"));
+    QSqlRecord rec = db.record(ts.tableName());
     QCOMPARE((int)rec.count(), 3);
 
     int i;
@@ -538,18 +519,18 @@ void tst_QSqlDatabase::alterTable()
         QCOMPARE(rec.field(i).name().toUpper(), QString("F%1").arg(i + 1));
     }
 
-    if (!q.exec("alter table " + qtestalter + " drop column F2")) {
+    if (!q.exec("alter table " + ts.tableName() + " drop column F2")) {
         QSKIP("DBMS doesn't support dropping columns in ALTER TABLE statement");
     }
 
-    rec = db.record(qtestalter);
+    rec = db.record(ts.tableName());
 
     QCOMPARE(rec.count(), 2);
 
     QCOMPARE(rec.field(0).name().toUpper(), QString("F1"));
     QCOMPARE(rec.field(1).name().toUpper(), QString("F3"));
 
-    q.exec("select * from " + qtestalter);
+    q.exec("select * from " + ts.tableName());
 }
 
 #if 0
@@ -577,12 +558,11 @@ void tst_QSqlDatabase::record()
 }
 #endif
 
-void tst_QSqlDatabase::testRecord(const FieldDef fieldDefs[], const QSqlRecord& inf, QSqlDatabase db)
+void tst_QSqlDatabase::testRecord(const FieldDef fieldDefs[], const QSqlRecord &inf, const QSqlDatabase &db)
 {
-    int i = 0;
     if (!tst_Databases::autoFieldName(db).isEmpty()) // Currently only MySQL is tested
-        QVERIFY2(inf.field(i).isAutoValue(), qPrintable(inf.field(i).name() + " should be reporting as an autovalue"));
-    for (i = 0; !fieldDefs[ i ].typeName.isNull(); ++i) {
+        QVERIFY2(inf.field(0).isAutoValue(), qPrintable(inf.field(0).name() + " should be reporting as an autovalue"));
+    for (int i = 0; !fieldDefs[ i ].typeName.isNull(); ++i) {
         QCOMPARE(inf.field(i+1).name().toUpper(), fieldDefs[ i ].fieldName().toUpper());
         if (inf.field(i+1).metaType().id() != fieldDefs[ i ].type) {
             QFAIL(qPrintable(QString(" Expected: '%1' Received: '%2' for field %3 in testRecord").arg(
@@ -597,7 +577,7 @@ void tst_QSqlDatabase::testRecord(const FieldDef fieldDefs[], const QSqlRecord&
 }
 
 // non-dbms specific tests
-void tst_QSqlDatabase::commonFieldTest(const FieldDef fieldDefs[], QSqlDatabase db, const int fieldCount)
+void tst_QSqlDatabase::commonFieldTest(const FieldDef fieldDefs[], const QSqlDatabase &db, const int fieldCount)
 {
     CHECK_DATABASE(db);
 
@@ -1267,24 +1247,24 @@ void tst_QSqlDatabase::psql_escapeBytea()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
+    TableScope ts(db, "batable", __FILE__);
 
     const char dta[4] = {'\x71', '\x14', '\x32', '\x81'};
     QByteArray ba(dta, 4);
 
     QSqlQuery q(db);
-    const QString tableName(qTableName("batable", __FILE__, db));
-    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (ba bytea)").arg(tableName)));
+    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (ba bytea)").arg(ts.tableName())));
 
     QSqlQuery iq(db);
-    QVERIFY_SQL(iq, prepare(QString("INSERT INTO %1 VALUES (?)").arg(tableName)));
+    QVERIFY_SQL(iq, prepare(QString("INSERT INTO %1 VALUES (?)").arg(ts.tableName())));
     iq.bindValue(0, QVariant(ba));
     QVERIFY_SQL(iq, exec());
 
-    QVERIFY_SQL(q, exec(QString("SELECT ba FROM %1").arg(tableName)));
+    QVERIFY_SQL(q, exec(QString("SELECT ba FROM %1").arg(ts.tableName())));
     QVERIFY_SQL(q, next());
 
     QByteArray res = q.value(0).toByteArray();
-    int i = 0;
+    qsizetype i = 0;
     for (; i < ba.size(); ++i){
         if (ba[i] != res[i])
             break;
@@ -1298,13 +1278,13 @@ void tst_QSqlDatabase::psql_bug249059()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
+    TableScope ts(db, "bug_249059", __FILE__);
 
     QSqlQuery q(db);
-    const QString tableName(qTableName("bug_249059", __FILE__, db));
-    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (dt timestamp, t time)").arg(tableName)));
+    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (dt timestamp, t time)").arg(ts.tableName())));
 
     QSqlQuery iq(db);
-    QVERIFY_SQL(iq, prepare(QString("INSERT INTO %1 VALUES (?, ?)").arg(tableName)));
+    QVERIFY_SQL(iq, prepare(QString("INSERT INTO %1 VALUES (?, ?)").arg(ts.tableName())));
     iq.bindValue(0, QVariant(QString("2001-09-09 04:05:06.789 -5:00")));
     iq.bindValue(1, QVariant(QString("04:05:06.789 -5:00")));
     QVERIFY_SQL(iq, exec());
@@ -1312,7 +1292,7 @@ void tst_QSqlDatabase::psql_bug249059()
     iq.bindValue(1, QVariant(QString("04:05:06.789 +5:00")));
     QVERIFY_SQL(iq, exec());
 
-    QVERIFY_SQL(q, exec(QString("SELECT dt, t FROM %1").arg(tableName)));
+    QVERIFY_SQL(q, exec(QString("SELECT dt, t FROM %1").arg(ts.tableName())));
     QVERIFY_SQL(q, next());
     QDateTime dt1=q.value(0).toDateTime();
     QTime t1=q.value(1).toTime();
@@ -1325,17 +1305,15 @@ void tst_QSqlDatabase::psql_bug249059()
     QCOMPARE(t1, t2);
 }
 
-// This test should be rewritten to work with Oracle as well - or the Oracle driver
-// should be fixed to make this test pass (handle overflows)
 void tst_QSqlDatabase::precisionPolicy()
 {
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-//     DBMS_SPECIFIC(db, "QPSQL");
+    TableScope ts(db, "qtest_prec", __FILE__);
+    const auto &tableName = ts.tableName();
 
     QSqlQuery q(db);
-    const QString tableName(qTableName("qtest_prec", __FILE__, db));
     if(!db.driver()->hasFeature(QSqlDriver::LowPrecisionNumbers))
         QSKIP("Driver or database doesn't support setting precision policy");
 
@@ -1466,14 +1444,14 @@ void tst_QSqlDatabase::mysqlOdbc_unsignedIntegers()
 
     if (tst_Databases::getDatabaseType(db) != QSqlDriver::MySqlServer || !db.driverName().startsWith("QODBC"))
        QSKIP("MySQL through ODBC-driver specific test");
+    TableScope ts(db, "uint", __FILE__);
 
     QSqlQuery q(db);
-    const QString tableName(qTableName("uint", __FILE__, db));
-    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (foo integer(10) unsigned, bar integer(10))").arg(tableName)));
-    QVERIFY_SQL(q, exec(QString("INSERT INTO %1 VALUES (-4000000000, -4000000000)").arg(tableName)));
-    QVERIFY_SQL(q, exec(QString("INSERT INTO %1 VALUES (4000000000, 4000000000)").arg(tableName)));
+    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (foo integer(10) unsigned, bar integer(10))").arg(ts.tableName())));
+    QVERIFY_SQL(q, exec(QString("INSERT INTO %1 VALUES (-4000000000, -4000000000)").arg(ts.tableName())));
+    QVERIFY_SQL(q, exec(QString("INSERT INTO %1 VALUES (4000000000, 4000000000)").arg(ts.tableName())));
 
-    QVERIFY_SQL(q, exec(QString("SELECT foo, bar FROM %1").arg(tableName)));
+    QVERIFY_SQL(q, exec(QString("SELECT foo, bar FROM %1").arg(ts.tableName())));
     QVERIFY(q.next());
     QCOMPARE(q.value(0).toString(), QString("0"));
     QCOMPARE(q.value(1).toString(), QString("-2147483648"));
@@ -1490,13 +1468,13 @@ void tst_QSqlDatabase::accessOdbc_strings()
 
     if (!tst_Databases::isMSAccess(db))
         QSKIP("MS Access specific test");
+    TableScope ts(db, "strings", __FILE__);
 
     QSqlQuery q(db);
-    const QString tableName(qTableName("strings", __FILE__, db));
     QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (aStr memo, bStr memo, cStr memo, dStr memo"
-            ", eStr memo, fStr memo, gStr memo, hStr memo)").arg(tableName)));
+            ", eStr memo, fStr memo, gStr memo, hStr memo)").arg(ts.tableName())));
 
-    QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES (?, ?, ?, ?, ?, ?, ?, ?)").arg(tableName)));
+    QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES (?, ?, ?, ?, ?, ?, ?, ?)").arg(ts.tableName())));
     QString aStr, bStr, cStr, dStr, eStr, fStr, gStr, hStr;
 
     q.bindValue(0, aStr.fill('A', 32));
@@ -1510,7 +1488,7 @@ void tst_QSqlDatabase::accessOdbc_strings()
 
     QVERIFY_SQL(q, exec());
 
-    QVERIFY_SQL(q, exec(QString("SELECT aStr, bStr, cStr, dStr, eStr, fStr, gStr, hStr FROM %1").arg(tableName)));
+    QVERIFY_SQL(q, exec(QString("SELECT aStr, bStr, cStr, dStr, eStr, fStr, gStr, hStr FROM %1").arg(ts.tableName())));
     q.next();
     QCOMPARE(q.value(0).toString(), aStr);
     QCOMPARE(q.value(1).toString(), bStr);
@@ -1528,9 +1506,10 @@ void tst_QSqlDatabase::ibase_numericFields()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
+    TableScope ts(db, "numericfields", __FILE__);
+    const auto &tableName = ts.tableName();
 
     QSqlQuery q(db);
-    const QString tableName(qTableName("numericfields", __FILE__, db));
     QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (id int not null, num1 NUMERIC(2,1), "
         "num2 NUMERIC(5,2), num3 NUMERIC(10,3), "
         "num4 NUMERIC(18,4))").arg(tableName)));
@@ -1601,8 +1580,9 @@ void tst_QSqlDatabase::ibase_fetchBlobs()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
+    TableScope ts(db, "qtest_ibaseblobs", __FILE__);
+    const auto &tableName = ts.tableName();
 
-    const QString tableName(qTableName("qtest_ibaseblobs", __FILE__, db));
     QSqlQuery q(db);
     QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (blob1 BLOB segment size 256)").arg(tableName)));
 
@@ -1736,13 +1716,13 @@ void tst_QSqlDatabase::odbc_bindBoolean()
     QSqlDriver::DbmsType dbType = tst_Databases::getDatabaseType(db);
     if (dbType == QSqlDriver::MySqlServer)
         QSKIP("MySql has inconsistent behaviour of bit field type across versions.");
+    TableScope ts(db, "qtestBindBool", __FILE__);
 
     QSqlQuery q(db);
-    const QString tableName = qTableName("qtestBindBool", __FILE__, db);
-    QVERIFY_SQL(q, exec("CREATE TABLE " + tableName + "(id int, boolvalue bit)"));
+    QVERIFY_SQL(q, exec("CREATE TABLE " + ts.tableName() + "(id int, boolvalue bit)"));
 
     // Bind and insert
-    QVERIFY_SQL(q, prepare("INSERT INTO " + tableName + " VALUES(?, ?)"));
+    QVERIFY_SQL(q, prepare("INSERT INTO " + ts.tableName() + " VALUES(?, ?)"));
     q.bindValue(0, 1);
     q.bindValue(1, true);
     QVERIFY_SQL(q, exec());
@@ -1751,7 +1731,7 @@ void tst_QSqlDatabase::odbc_bindBoolean()
     QVERIFY_SQL(q, exec());
 
     // Retrive
-    QVERIFY_SQL(q, exec("SELECT id, boolvalue FROM " + tableName + " ORDER BY id"));
+    QVERIFY_SQL(q, exec("SELECT id, boolvalue FROM " + ts.tableName() + " ORDER BY id"));
     QVERIFY_SQL(q, next());
     QCOMPARE(q.value(0).toInt(), 1);
     QCOMPARE(q.value(1).toBool(), true);
@@ -1765,7 +1745,8 @@ void tst_QSqlDatabase::odbc_testqGetString()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-    const QString testqGetString(qTableName("testqGetString", __FILE__, db));
+    TableScope ts(db, "testqGetString", __FILE__);
+    const auto &testqGetString = ts.tableName();
 
     QSqlQuery q(db);
     QSqlDriver::DbmsType dbType = tst_Databases::getDatabaseType(db);
@@ -1845,8 +1826,9 @@ void tst_QSqlDatabase::oci_xmltypeSupport()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
+    TableScope ts(db, "qtest_xmltype", __FILE__);
+    const auto &tableName = ts.tableName();
 
-    const QString tableName(qTableName("qtest_xmltype", __FILE__, db));
     QString xml("<?xml version=\"1.0\"?>\n<TABLE_NAME>MY_TABLE</TABLE_NAME>\n");
     QSqlQuery q(db);
 
@@ -1924,14 +1906,14 @@ void tst_QSqlDatabase::odbc_uniqueidentifier()
     if (dbType != QSqlDriver::MSSqlServer)
         QSKIP("SQL Server (ODBC) specific test");
 
-    const QString tableName(qTableName("qtest_sqlguid", __FILE__, db));
+    TableScope ts(db, "qtest_sqlguid", __FILE__);
     QString guid = QString("AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE");
     QString invalidGuid = QString("GAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE");
 
     QSqlQuery q(db);
-    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(id uniqueidentifier)").arg(tableName)));
+    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(id uniqueidentifier)").arg(ts.tableName())));
 
-    q.prepare(QString("INSERT INTO %1 VALUES(?)").arg(tableName));;
+    q.prepare(QString("INSERT INTO %1 VALUES(?)").arg(ts.tableName()));
     q.addBindValue(guid);
     QVERIFY_SQL(q, exec());
 
@@ -1940,7 +1922,7 @@ void tst_QSqlDatabase::odbc_uniqueidentifier()
         Continue);
     QVERIFY_SQL(q, exec());
 
-    QVERIFY_SQL(q, exec(QString("SELECT id FROM %1").arg(tableName)));
+    QVERIFY_SQL(q, exec(QString("SELECT id FROM %1").arg(ts.tableName())));
     QVERIFY_SQL(q, next());
     QCOMPARE(q.value(0).toString(), guid);
 }
@@ -1966,20 +1948,20 @@ void tst_QSqlDatabase::odbc_uintfield()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
+    TableScope ts(db, "uint_table", __FILE__);
 
-    const QString tableName(qTableName("uint_table", __FILE__, db));
-    unsigned int val = 4294967295U;
+    constexpr auto val = std::numeric_limits<unsigned int>::max();
 
     QSqlQuery q(db);
     if ( tst_Databases::isMSAccess( db ) )
-        QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(num number)").arg(tableName)));
+        QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(num number)").arg(ts.tableName())));
     else
-        QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(num numeric(10))").arg(tableName)));
-    q.prepare(QString("INSERT INTO %1 VALUES(?)").arg(tableName));
+        QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(num numeric(10))").arg(ts.tableName())));
+    q.prepare(QString("INSERT INTO %1 VALUES(?)").arg(ts.tableName()));
     q.addBindValue(val);
     QVERIFY_SQL(q, exec());
 
-    q.exec(QString("SELECT num FROM %1").arg(tableName));
+    q.exec(QString("SELECT num FROM %1").arg(ts.tableName()));
     if (q.next())
         QCOMPARE(q.value(0).toUInt(), val);
 }
@@ -2048,7 +2030,7 @@ void tst_QSqlDatabase::eventNotificationIBase()
     q.exec(QString("DROP PROCEDURE %1").arg(procedureName));
     q.exec(QString("CREATE PROCEDURE %1\nAS BEGIN\nPOST_EVENT '%1';\nEND;").arg(procedureName));
     q.exec(QString("EXECUTE PROCEDURE %1").arg(procedureName));
-    QSignalSpy spy(driver, QOverload<const QString &, QSqlDriver::NotificationSource, const QVariant &>::of(&QSqlDriver::notification));
+    QSignalSpy spy(driver, &QSqlDriver::notification);
     db.commit();        // No notifications are posted until the transaction is committed.
     // Interbase needs some time to post the notification and call the driver callback.
     // This happends from another thread, and we have to process events in order for the
@@ -2064,8 +2046,6 @@ void tst_QSqlDatabase::eventNotificationPSQL()
 {
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
-    if (db.driverName().compare(QLatin1String("QPSQL"), Qt::CaseInsensitive))
-        QSKIP("QPSQL specific test");
     CHECK_DATABASE(db);
 
     QSqlQuery query(db);
@@ -2073,7 +2053,7 @@ void tst_QSqlDatabase::eventNotificationPSQL()
     QString payload = "payload";
     QSqlDriver *driver = db.driver();
     QVERIFY_SQL(*driver, subscribeToNotification(procedureName));
-    QSignalSpy spy(driver, QOverload<const QString &, QSqlDriver::NotificationSource, const QVariant &>::of(&QSqlDriver::notification));
+    QSignalSpy spy(driver, &QSqlDriver::notification);
     query.exec(QString("NOTIFY \"%1\", '%2'").arg(procedureName).arg(payload));
     QTRY_COMPARE(spy.size(), 1);
     QList<QVariant> arguments = spy.takeFirst();
@@ -2087,15 +2067,13 @@ void tst_QSqlDatabase::eventNotificationSQLite()
 {
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
-    if (db.driverName().compare(QLatin1String("QSQLITE"), Qt::CaseInsensitive))
-        QSKIP("QSQLITE specific test");
     CHECK_DATABASE(db);
 
     TableScope ts(db, "sqlitnotifytest", __FILE__);
     TableScope tsEscape(db, "sqlitnotifytest", __FILE__, false);
 
     QSqlDriver *driver = db.driver();
-    QSignalSpy spy(driver, QOverload<const QString &, QSqlDriver::NotificationSource, const QVariant &>::of(&QSqlDriver::notification));
+    QSignalSpy spy(driver, &QSqlDriver::notification);
     QSqlQuery q(db);
     QVERIFY_SQL(q, exec("CREATE TABLE " + ts.tableName() + " (id INTEGER, realVal REAL)"));
     driver->subscribeToNotification(tsEscape.tableName());
@@ -2113,13 +2091,13 @@ void tst_QSqlDatabase::sqlite_bindAndFetchUInt()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
+    TableScope ts(db, "uint_test", __FILE__);
     QSqlQuery q(db);
-    const QString tableName(qTableName("uint_test", __FILE__, db));
-    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(uint_field UNSIGNED INTEGER)").arg(tableName)));
-    QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES(?)").arg(tableName)));
+    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(uint_field UNSIGNED INTEGER)").arg(ts.tableName())));
+    QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES(?)").arg(ts.tableName())));
     q.addBindValue(4000000000U);
     QVERIFY_SQL(q, exec());
-    QVERIFY_SQL(q, exec(QString("SELECT uint_field FROM %1").arg(tableName)));
+    QVERIFY_SQL(q, exec(QString("SELECT uint_field FROM %1").arg(ts.tableName())));
     QVERIFY_SQL(q, next());
 
     // All integers in SQLite are signed, so even though we bound the value
@@ -2229,18 +2207,18 @@ void tst_QSqlDatabase::sqlite_enableRegexp()
     db.close();
     db.setConnectOptions("QSQLITE_ENABLE_REGEXP");
     QVERIFY_SQL(db, open());
+    TableScope ts(db, "regexp_test", __FILE__);
 
     QSqlQuery q(db);
-    const QString tableName(qTableName("regexp_test", __FILE__, db));
-    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(text TEXT)").arg(tableName)));
-    QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES(?)").arg(tableName)));
+    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(text TEXT)").arg(ts.tableName())));
+    QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES(?)").arg(ts.tableName())));
     q.addBindValue("a0");
     QVERIFY_SQL(q, exec());
     q.addBindValue("a1");
     QVERIFY_SQL(q, exec());
 
     QVERIFY_SQL(q, exec(QString("SELECT text FROM %1 WHERE text REGEXP 'a[^0]' "
-                                "ORDER BY text").arg(tableName)));
+                                "ORDER BY text").arg(ts.tableName())));
     QVERIFY_SQL(q, next());
     QCOMPARE(q.value(0).toString(), QString("a1"));
     QFAIL_SQL(q, next());
diff --git a/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp b/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp
index c92e6d4608..26003a8916 100644
--- a/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp
+++ b/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp
@@ -170,11 +170,11 @@ private slots:
     void task_250026();
     void crashQueryOnCloseDatabase();
 
-    void task_233829_data() { generic_data("QPSQL"); }
-    void task_233829();
+    void testNaN_data() { generic_data("QPSQL"); }
+    void testNaN();
 
-    void QTBUG_12477_data() { generic_data("QPSQL"); }
-    void QTBUG_12477();
+    void psqlNumericMetadata_data() { generic_data("QPSQL"); }
+    void psqlNumericMetadata();
 
     void sqlServerReturn0_data() { generic_data(); }
     void sqlServerReturn0();
@@ -340,49 +340,8 @@ void tst_QSqlQuery::dropTestTables(QSqlDatabase db)
     // Drop all the table in case a testcase failed:
     tablenames <<  qtest
                << qTableName("qtest_null", __FILE__, db)
-               << qTableName("qtest_writenull", __FILE__, db)
-               << qTableName("qtest_blob", __FILE__, db)
-               << qTableName("qtest_bittest", __FILE__, db)
-               << qTableName("qtest_nullblob", __FILE__, db)
-               << qTableName("qtest_rawtest", __FILE__, db)
-               << qTableName("qtest_precision", __FILE__, db)
-               << qTableName("qtest_prepare", __FILE__, db)
-               << qTableName("qtestj1", __FILE__, db)
-               << qTableName("qtestj2", __FILE__, db)
-               << qTableName("char1Select", __FILE__, db)
-               << qTableName("char1SU", __FILE__, db)
-               << qTableName("qxmltest", __FILE__, db)
-               << qTableName("qtest_exerr", __FILE__, db)
-               << qTableName("qtest_empty", __FILE__, db)
-               << qTableName("clobby", __FILE__, db)
-               << qTableName("bindtest", __FILE__, db)
-               << qTableName("more_results", __FILE__, db)
-               << qTableName("blobstest", __FILE__, db)
-               << qTableName("oraRowId", __FILE__, db)
-               << qTableName("bug43874", __FILE__, db)
-               << qTableName("bug6421", __FILE__, db).toUpper()
-               << qTableName("bug5765", __FILE__, db)
-               << qTableName("bug6852", __FILE__, db)
-               << qTableName("bug21884", __FILE__, db)
-               << qTableName("bug23895", __FILE__, db)
-               << qTableName("qtest_lockedtable", __FILE__, db)
-               << qTableName("Planet", __FILE__, db)
-               << qTableName("task_250026", __FILE__, db)
-               << qTableName("task_234422", __FILE__, db)
-               << qTableName("test141895", __FILE__, db)
-               << qTableName("qtest_oraOCINumber", __FILE__, db)
-               << qTableName("bug2192", __FILE__, db)
                << qTableName("tst_record", __FILE__, db);
 
-    if (dbType == QSqlDriver::PostgreSQL)
-        tablenames << qTableName("task_233829", __FILE__, db);
-
-    if (dbType == QSqlDriver::SQLite)
-        tablenames << qTableName("record_sqlite", __FILE__, db);
-
-    if (dbType == QSqlDriver::MSSqlServer || dbType == QSqlDriver::Oracle)
-        tablenames << qTableName("qtest_longstr", __FILE__, db);
-
     if (dbType == QSqlDriver::MSSqlServer) {
         QSqlQuery q(db);
         q.exec("DROP PROCEDURE " + qTableName("test141895_proc", __FILE__, db));
@@ -460,12 +419,11 @@ void tst_QSqlQuery::char1Select()
     CHECK_DATABASE(db);
 
     {
+        TableScope ts(db, "char1Select", __FILE__);
         QSqlQuery q(db);
-        const QString tbl = qTableName("char1Select", __FILE__, db);
-        q.exec("drop table " + tbl);
-        QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id char(1))").arg(tbl)));
-        QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values ('a')").arg(tbl)));
-        QVERIFY_SQL(q, exec("select * from " + tbl));
+        QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id char(1))").arg(ts.tableName())));
+        QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values ('a')").arg(ts.tableName())));
+        QVERIFY_SQL(q, exec("select * from " + ts.tableName()));
         QVERIFY(q.next());
         if (tst_Databases::getDatabaseType(db) == QSqlDriver::Interbase)
             QCOMPARE(q.value(0).toString().left(1), u"a");
@@ -489,9 +447,9 @@ void tst_QSqlQuery::char1SelectUnicode()
         QSKIP("Database not unicode capable");
 
     QString uniStr(QChar(0x0915)); // DEVANAGARI LETTER KA
+    TableScope ts(db, "char1SU", __FILE__);
     QSqlQuery q(db);
     QLatin1String createQuery;
-    const QString char1SelectUnicode(qTableName("char1SU", __FILE__, db));
 
     switch (dbType) {
     case QSqlDriver::MimerSQL:
@@ -514,12 +472,12 @@ void tst_QSqlQuery::char1SelectUnicode()
         break;
     }
 
-    QVERIFY_SQL(q, exec(createQuery.arg(char1SelectUnicode)));
-    QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 values(?)").arg(char1SelectUnicode)));
+    QVERIFY_SQL(q, exec(createQuery.arg(ts.tableName())));
+    QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 values(?)").arg(ts.tableName())));
 
     q.bindValue(0, uniStr);
     QVERIFY_SQL(q, exec());
-    QVERIFY_SQL(q, exec("select * from " + char1SelectUnicode));
+    QVERIFY_SQL(q, exec("select * from " + ts.tableName()));
 
     QVERIFY(q.next());
     if (!q.value(0).toString().isEmpty())
@@ -534,7 +492,8 @@ void tst_QSqlQuery::oraRowId()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-    const QString oraRowId(qTableName("oraRowId", __FILE__, db));
+    TableScope ts(db, "oraRowId", __FILE__);
+    const auto &oraRowId = ts.tableName();
 
     QSqlQuery q(db);
     QVERIFY_SQL(q, exec("select rowid from " + qtest));
@@ -793,7 +752,8 @@ void tst_QSqlQuery::oraClob()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-    const QString clobby(qTableName("clobby", __FILE__, db));
+    TableScope ts(db, "clobby", __FILE__);
+    const auto &clobby = ts.tableName();
 
     QSqlQuery q(db);
 
@@ -1006,15 +966,15 @@ void tst_QSqlQuery::blob()
     for (int i = 0; i < ba.size(); ++i)
         ba[i] = i % 256;
 
+    TableScope ts(db, "qtest_blob", __FILE__);
     QSqlQuery q(db);
     q.setForwardOnly(true);
-    const QString tableName = qTableName("qtest_blob", __FILE__, db);
 
     QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int not null primary key, t_blob %2)")
-                        .arg(tableName, tst_Databases::blobTypeName(db, BLOBSIZE))));
+                        .arg(ts.tableName(), tst_Databases::blobTypeName(db, BLOBSIZE))));
 
     QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 (id, t_blob) values (?, ?)")
-                           .arg(tableName)));
+                           .arg(ts.tableName())));
 
     for (int i = 0; i < BLOBCOUNT; ++i) {
         q.addBindValue(i);
@@ -1022,7 +982,7 @@ void tst_QSqlQuery::blob()
         QVERIFY_SQL(q, exec());
     }
 
-    QVERIFY_SQL(q, exec("select * from " + tableName));
+    QVERIFY_SQL(q, exec("select * from " + ts.tableName()));
 
     for (int i = 0; i < BLOBCOUNT; ++i) {
         QVERIFY(q.next());
@@ -1032,10 +992,10 @@ void tst_QSqlQuery::blob()
                                 "array sizes differ, expected (at least) %" PRIdQSIZETYPE
                                 ", got %" PRIdQSIZETYPE, ba.size(), res.size())));
 
-        for (int i2 = 0; i2 < ba.size(); ++i2) {
+        for (qsizetype i2 = 0; i2 < ba.size(); ++i2) {
             if (res[i2] != ba[i2]) {
                 QFAIL(qPrintable(QString::asprintf(
-                                     "ByteArrays differ at position %d, expected %hhu, got %hhu",
+                                     "ByteArrays differ at position %lld, expected %hhu, got %hhu",
                                      i2, ba[i2], res[i2])));
             }
         }
@@ -1788,9 +1748,6 @@ void tst_QSqlQuery::writeNull()
     CHECK_DATABASE(db);
     const QSqlDriver::DbmsType dbType = tst_Databases::getDatabaseType(db);
 
-    QSqlQuery q(db);
-    const QString tableName = qTableName("qtest_writenull", __FILE__, db);
-
     // The test data table is already used, so use a local hash to exercise the various
     // cases from the QSqlResultPrivate::isVariantNull helper. Only PostgreSQL and Mimer SQL
     // supports QUuid.
@@ -1808,7 +1765,7 @@ void tst_QSqlQuery::writeNull()
 
     // Helper to count rows with null values in the data column.
     // Since QSqlDriver::QuerySize might not be supported, we have to count anyway
-    const auto countRowsWithNull = [&]{
+    const auto countRowsWithNull = [&](QSqlQuery &q, const QString &tableName){
         q.exec(QLatin1String("select id, data from %1 where data is null").arg(tableName));
         int size = 0;
         while (q.next())
@@ -1817,37 +1774,37 @@ void tst_QSqlQuery::writeNull()
     };
 
     for (const auto &nullableType : nullableTypes.keys()) {
-        const auto tableGuard = qScopeGuard([&]{
-            q.exec("drop table " + tableName);
-        });
+        TableScope ts(db, "qtest_writenull", __FILE__);
+        QSqlQuery q(db);
+
         const QVariant nonNullValue = nullableTypes.value(nullableType);
         // some useful diagnostic output in case of any test failure
         auto errorHandler = qScopeGuard([&]{
             qWarning() << "Test failure for data type" << nonNullValue.metaType().name();
-            q.exec("select id, data from " + tableName);
+            q.exec("select id, data from " + ts.tableName());
             while (q.next())
                 qWarning() << q.value(0) << q.value(1);
         });
         QString createQuery = QLatin1String("create table %3 (id int, data %1%2)")
             .arg(nullableType,
                  dbType == QSqlDriver::MSSqlServer || dbType == QSqlDriver::Sybase ? " null" : "",
-                 tableName);
+                 ts.tableName());
         QVERIFY_SQL(q, exec(createQuery));
 
         int expectedNullCount = 0;
         // Verify that inserting a non-null value works:
-        QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 values(:id, :data)").arg(tableName)));
+        QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 values(:id, :data)").arg(ts.tableName())));
         q.bindValue(":id", expectedNullCount);
         q.bindValue(":data", nonNullValue);
         QVERIFY_SQL(q, exec());
-        QCOMPARE(countRowsWithNull(), expectedNullCount);
+        QCOMPARE(countRowsWithNull(q, ts.tableName()), expectedNullCount);
 
         // Verify that inserting using a null QVariant produces a null entry in the database:
-        QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 values(:id, :data)").arg(tableName)));
+        QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 values(:id, :data)").arg(ts.tableName())));
         q.bindValue(":id", ++expectedNullCount);
         q.bindValue(":data", QVariant());
         QVERIFY_SQL(q, exec());
-        QCOMPARE(countRowsWithNull(), expectedNullCount);
+        QCOMPARE(countRowsWithNull(q, ts.tableName()), expectedNullCount);
 
         // Verify that writing a null-value (but not a null-variant) produces a
         // null entry in the database:
@@ -1862,11 +1819,11 @@ void tst_QSqlQuery::writeNull()
         const QVariant nullValueVariant(nullableMetaType, defaultData);
         QVERIFY(!nullValueVariant.isNull());
 
-        QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 values(:id, :data)").arg(tableName)));
+        QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 values(:id, :data)").arg(ts.tableName())));
         q.bindValue(":id", ++expectedNullCount);
         q.bindValue(":data", nullValueVariant);
         QVERIFY_SQL(q, exec());
-        QCOMPARE(countRowsWithNull(), expectedNullCount);
+        QCOMPARE(countRowsWithNull(q, ts.tableName()), expectedNullCount);
 
         // All tests passed for this type if we got here, so don't print diagnostics:
         errorHandler.dismiss();
@@ -1879,19 +1836,19 @@ void tst_QSqlQuery::oci_nullBlob()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-    const QString qtest_nullblob(qTableName("qtest_nullblob", __FILE__, db));
+    TableScope ts(db, "qtest_nullblob", __FILE__);
 
     QSqlQuery q(db);
     QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int primary key, bb blob)")
-                        .arg(qtest_nullblob)));
+                        .arg(ts.tableName())));
     QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (0, EMPTY_BLOB())")
-                        .arg(qtest_nullblob)));
-    QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1, NULL)").arg(qtest_nullblob)));
+                        .arg(ts.tableName())));
+    QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1, NULL)").arg(ts.tableName())));
     QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (2, 'aabbcc00112233445566')")
-                        .arg(qtest_nullblob)));
+                        .arg(ts.tableName())));
     // Necessary otherwise Oracle will bombard you with internal errors:
     q.setForwardOnly(true);
-    QVERIFY_SQL(q, exec(QLatin1String("select * from %1 order by id").arg(qtest_nullblob)));
+    QVERIFY_SQL(q, exec(QLatin1String("select * from %1 order by id").arg(ts.tableName())));
 
     QVERIFY(q.next());
     QVERIFY(q.value(1).toByteArray().isEmpty());
@@ -1912,15 +1869,15 @@ void tst_QSqlQuery::oci_rawField()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-    const QString qtest_rawtest(qTableName("qtest_rawtest", __FILE__, db));
+    TableScope ts(db, "qtest_rawtest", __FILE__);
 
     QSqlQuery q(db);
     q.setForwardOnly(true);
-    QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int, col raw(20))").arg(qtest_rawtest)));
-    QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (0, NULL)").arg(qtest_rawtest)));
+    QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int, col raw(20))").arg(ts.tableName())));
+    QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (0, NULL)").arg(ts.tableName())));
     QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1, '00aa1100ddeeff')")
-                        .arg(qtest_rawtest)));
-    QVERIFY_SQL(q, exec(QLatin1String("select col from %1 order by id").arg(qtest_rawtest)));
+                        .arg(ts.tableName())));
+    QVERIFY_SQL(q, exec(QLatin1String("select col from %1 order by id").arg(ts.tableName())));
     QVERIFY(q.next());
     QVERIFY(q.isNull(0));
     QVERIFY(q.value(0).toByteArray().isEmpty());
@@ -1946,22 +1903,21 @@ void tst_QSqlQuery::precision()
     });
 
     db.driver()->setNumericalPrecisionPolicy(QSql::HighPrecision);
-    const QString qtest_precision(qTableName("qtest_precision", __FILE__, db));
+    TableScope ts(db, "qtest_precision", __FILE__);
     static const QLatin1String precStr("1.2345678901234567891");
 
     {
         // need a new scope for SQLITE
         QSqlQuery q(db);
 
-        q.exec("drop table " + qtest_precision);
         QVERIFY_SQL(q, exec(QLatin1String(tst_Databases::isMSAccess(db)
                                           ? "CREATE TABLE %1 (col1 number)"
                                           : "CREATE TABLE %1 (col1 numeric(21, 20))")
-                            .arg(qtest_precision)));
+                            .arg(ts.tableName())));
 
         QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (col1) VALUES (%2)")
-                            .arg(qtest_precision, precStr)));
-        QVERIFY_SQL(q, exec("SELECT * FROM " + qtest_precision));
+                            .arg(ts.tableName(), precStr)));
+        QVERIFY_SQL(q, exec("SELECT * FROM " + ts.tableName()));
         QVERIFY(q.next());
         const QString val = q.value(0).toString();
         if (!val.startsWith(precStr)) {
@@ -2007,29 +1963,29 @@ void tst_QSqlQuery::joins()
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
     const QSqlDriver::DbmsType dbType = tst_Databases::getDatabaseType(db);
-    const QString qtestj1(qTableName("qtestj1", __FILE__, db));
-    const QString qtestj2(qTableName("qtestj2", __FILE__, db));
 
     if (dbType == QSqlDriver::Oracle || dbType == QSqlDriver::Sybase
             || dbType == QSqlDriver::Interbase || db.driverName().startsWith("QODBC")) {
         // Oracle broken beyond recognition - cannot outer join on more than one table:
         QSKIP("DBMS cannot understand standard SQL");
     }
+    TableScope j1(db, "qtestj1", __FILE__);
+    TableScope j2(db, "qtestj2", __FILE__);
 
     QSqlQuery q(db);
 
-    QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id1 int, id2 int)").arg(qtestj1)));
-    QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int, name varchar(20))").arg(qtestj2)));
-    QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1, 1)").arg(qtestj1)));
-    QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1, 2)").arg(qtestj1)));
-    QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values(1, 'trenton')").arg(qtestj2)));
-    QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values(2, 'marius')").arg(qtestj2)));
+    QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id1 int, id2 int)").arg(j1.tableName())));
+    QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int, name varchar(20))").arg(j2.tableName())));
+    QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1, 1)").arg(j1.tableName())));
+    QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1, 2)").arg(j1.tableName())));
+    QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values(1, 'trenton')").arg(j2.tableName())));
+    QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values(2, 'marius')").arg(j2.tableName())));
 
     QVERIFY_SQL(q, exec(QLatin1String(
                             "select qtestj1.id1, qtestj1.id2, qtestj2.id, qtestj2.name, "
                             "qtestj3.id, qtestj3.name from %1 qtestj1 left outer join %2 qtestj2 "
                             "on (qtestj1.id1 = qtestj2.id) left outer join %2 as qtestj3 "
-                            "on (qtestj1.id2 = qtestj3.id)").arg(qtestj1, qtestj2)));
+                            "on (qtestj1.id2 = qtestj3.id)").arg(j1.tableName(), j2.tableName())));
 
     QVERIFY(q.next());
     QCOMPARE(q.value(0).toInt(), 1);
@@ -2077,7 +2033,8 @@ void tst_QSqlQuery::prepare_bind_exec()
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
     const QSqlDriver::DbmsType dbType = tst_Databases::getDatabaseType(db);
-    const QString qtest_prepare(qTableName("qtest_prepare", __FILE__, db));
+    TableScope ts(db, "qtest_prepare", __FILE__);
+    const auto &qtest_prepare = ts.tableName();
 
     if (dbType == QSqlDriver::DB2)
         QSKIP("Needs someone with more Unicode knowledge than I have to fix");
@@ -2118,13 +2075,10 @@ void tst_QSqlQuery::prepare_bind_exec()
             break;
         }
 
-        q.exec("drop table " + qtest_prepare);
         QVERIFY_SQL(q, exec(createQuery.arg(qtest_prepare)));
         QVERIFY(q.prepare(QLatin1String("insert into %1 (id, name) values (:id, :name)")
                           .arg(qtest_prepare)));
-        int i;
-
-        for (i = 0; i < 6; ++i) {
+        for (int i = 0; i < 6; ++i) {
             q.bindValue(":name", values[i]);
             q.bindValue(":id", i);
             QVERIFY_SQL(q, exec());
@@ -2150,7 +2104,7 @@ void tst_QSqlQuery::prepare_bind_exec()
         }
 
         QVERIFY_SQL(q, exec(QLatin1String("SELECT * FROM %1 order by id").arg(qtest_prepare)));
-        for (i = 0; i < 6; ++i) {
+        for (int i = 0; i < 6; ++i) {
             QVERIFY(q.next());
             QCOMPARE(q.value(0).toInt(), i);
             QCOMPARE(q.value(1).toString().trimmed(), values[i]);
@@ -2175,7 +2129,7 @@ void tst_QSqlQuery::prepare_bind_exec()
         QVERIFY(q.exec(QLatin1String("select * from %1 where id > 98 order by id")
                        .arg(qtest_prepare)));
 
-        for (i = 99; i <= 100; ++i) {
+        for (int i = 99; i <= 100; ++i) {
             QVERIFY(q.next());
             QCOMPARE(q.value(0).toInt(), i);
             QCOMPARE(q.value(1).toString().trimmed(), u"Bart");
@@ -2184,7 +2138,7 @@ void tst_QSqlQuery::prepare_bind_exec()
         /*** SELECT stuff ***/
         QVERIFY(q.prepare(QLatin1String("select * from %1 where id = :id").arg(qtest_prepare)));
 
-        for (i = 0; i < 6; ++i) {
+        for (int i = 0; i < 6; ++i) {
             q.bindValue(":id", i);
             QVERIFY_SQL(q, exec());
             QVERIFY_SQL(q, next());
@@ -2297,7 +2251,7 @@ void tst_QSqlQuery::prepare_bind_exec()
         QFAIL_SQL(q, exec());
 
         QVERIFY_SQL(q, exec(QLatin1String("SELECT * FROM %1 order by id").arg(qtest_prepare)));
-        for (i = 0; i < 6; ++i) {
+        for (int i = 0; i < 6; ++i) {
             QVERIFY(q.next());
             QCOMPARE(q.value(0).toInt(), i);
             QCOMPARE(q.value(1).toString().trimmed(), values[i]);
@@ -2323,7 +2277,7 @@ void tst_QSqlQuery::prepare_bind_exec()
 
         QVERIFY(q.exec(QLatin1String("select * from %1 where id > 98 order by id")
                        .arg(qtest_prepare)));
-        for (i = 99; i <= 100; ++i) {
+        for (int i = 99; i <= 100; ++i) {
             QVERIFY(q.next());
             QCOMPARE(q.value(0).toInt(), i);
             QCOMPARE(q.value(1).toString().trimmed(), u"Bart");
@@ -2342,7 +2296,7 @@ void tst_QSqlQuery::prepare_bind_exec()
         QVERIFY(q.prepare(QLatin1String(
                               "insert into %1 (id, name, name2) values (:id, :name, :name)")
                           .arg(qtest_prepare)));
-        for (i = 101; i < 103; ++i) {
+        for (int i = 101; i < 103; ++i) {
             q.bindValue(":id", i);
             q.bindValue(":name", "name");
             QVERIFY(q.exec());
@@ -2360,7 +2314,7 @@ void tst_QSqlQuery::prepare_bind_exec()
         // works correctly - QTBUG-65150
         QVERIFY(q.prepare(QLatin1String("insert into %1 (id, name, name2) values (:id, :id, :name)")
                           .arg(qtest_prepare)));
-        for (i = 104; i < 106; ++i) {
+        for (int i = 104; i < 106; ++i) {
             q.bindValue(":id", i);
             q.bindValue(":name", "name");
             QVERIFY(q.exec());
@@ -2375,7 +2329,7 @@ void tst_QSqlQuery::prepare_bind_exec()
         // Test that duplicated named placeholders in any order
         QVERIFY(q.prepare(QLatin1String("insert into %1 (id, name, name2) values (:id, :name, :id)")
                           .arg(qtest_prepare)));
-        for (i = 107; i < 109; ++i) {
+        for (int i = 107; i < 109; ++i) {
             q.bindValue(":id", i);
             q.bindValue(":name", "name");
             QVERIFY(q.exec());
@@ -2444,12 +2398,12 @@ void tst_QSqlQuery::sqlServerLongStrings()
     if (tst_Databases::getDatabaseType(db) != QSqlDriver::MSSqlServer)
         QSKIP("Test is specific to SQL Server");
 
+    TableScope ts(db, "qtest_longstr", __FILE__);
     QSqlQuery q(db);
-    const QString tableName = qTableName("qtest_longstr", __FILE__, db);
 
     QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id int primary key, longstring ntext)")
-                        .arg(tableName)));
-    QVERIFY_SQL(q, prepare(QLatin1String("INSERT INTO %1 VALUES (?, ?)").arg(tableName)));
+                        .arg(ts.tableName())));
+    QVERIFY_SQL(q, prepare(QLatin1String("INSERT INTO %1 VALUES (?, ?)").arg(ts.tableName())));
 
     q.addBindValue(0);
     q.addBindValue(u"bubu"_s);
@@ -2460,7 +2414,7 @@ void tst_QSqlQuery::sqlServerLongStrings()
     q.addBindValue(1);
     q.addBindValue(testStr);
     QVERIFY_SQL(q, exec());
-    QVERIFY_SQL(q, exec("select * from " + tableName));
+    QVERIFY_SQL(q, exec("select * from " + ts.tableName()));
 
     QVERIFY_SQL(q, next());
     QCOMPARE(q.value(0).toInt(), 0);
@@ -2617,19 +2571,19 @@ void tst_QSqlQuery::QTBUG_43874()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
+    TableScope ts(db, "bug43874", __FILE__);
 
     QSqlQuery q(db);
-    const QString tableName = qTableName("bug43874", __FILE__, db);
 
-    QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id INT)").arg(tableName)));
-    QVERIFY_SQL(q, prepare(QLatin1String("INSERT INTO %1 (id) VALUES (?)").arg(tableName)));
+    QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id INT)").arg(ts.tableName())));
+    QVERIFY_SQL(q, prepare(QLatin1String("INSERT INTO %1 (id) VALUES (?)").arg(ts.tableName())));
 
     for (int i = 0; i < 2; ++i) {
         const QVariantList ids = { i };
         q.addBindValue(ids);
         QVERIFY_SQL(q, execBatch());
     }
-    QVERIFY_SQL(q, exec(QLatin1String("SELECT id FROM %1 ORDER BY id").arg(tableName)));
+    QVERIFY_SQL(q, exec(QLatin1String("SELECT id FROM %1 ORDER BY id").arg(ts.tableName())));
 
     QVERIFY(q.next());
     QCOMPARE(q.value(0).toInt(), 0);
@@ -2724,14 +2678,14 @@ void tst_QSqlQuery::record_sqlite()
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
 
+    TableScope ts(db, "record_sqlite");
     QSqlQuery q(db);
-    const QString tableName = qTableName("record_sqlite", __FILE__, db);
 
     QVERIFY_SQL(q, exec(QLatin1String(
                             "create table %1(id integer primary key, name varchar, title int)")
-                        .arg(tableName)));
+                        .arg(ts.tableName())));
 
-    QSqlRecord rec = db.record(tableName);
+    QSqlRecord rec = db.record(ts.tableName());
 
     QCOMPARE(rec.count(), 3);
     QCOMPARE(rec.field(0).metaType().id(), QMetaType::Int);
@@ -2739,7 +2693,7 @@ void tst_QSqlQuery::record_sqlite()
     QCOMPARE(rec.field(2).metaType().id(), QMetaType::Int);
 
     // Important - select from an empty table:
-    QVERIFY_SQL(q, exec("select id, name, title from " + tableName));
+    QVERIFY_SQL(q, exec("select id, name, title from " + ts.tableName()));
 
     rec = q.record();
     QCOMPARE(rec.count(), 3);
@@ -2754,20 +2708,19 @@ void tst_QSqlQuery::oraLong()
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
 
-    QSqlQuery q(db);
-
     QString aLotOfText(127000, QLatin1Char('H'));
-    const QString tableName = qTableName("qtest_longstr", __FILE__, db);
+    TableScope ts(db, "qtest_longstr", __FILE__);
 
+    QSqlQuery q(db);
     QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int primary key, astr long)")
-                        .arg(tableName)));
+                        .arg(ts.tableName())));
     QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 (id, astr) values (?, ?)")
-                           .arg(tableName)));
+                           .arg(ts.tableName())));
     q.addBindValue(1);
     q.addBindValue(aLotOfText);
     QVERIFY_SQL(q, exec());
 
-    QVERIFY_SQL(q, exec("select id,astr from " + tableName));
+    QVERIFY_SQL(q, exec("select id,astr from " + ts.tableName()));
 
     QVERIFY(q.next());
     QCOMPARE(q.value(0).toInt(), 1);
@@ -2780,12 +2733,11 @@ void tst_QSqlQuery::execErrorRecovery()
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
 
-    QSqlQuery q(db);
+    TableScope ts(db, "qtest_exerr", __FILE__);
 
-    const QString tbl = qTableName("qtest_exerr", __FILE__, db);
-    q.exec("drop table " + tbl);
-    QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int not null primary key)").arg(tbl)));
-    QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 values (?)").arg(tbl)));
+    QSqlQuery q(db);
+    QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int not null primary key)").arg(ts.tableName())));
+    QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 values (?)").arg(ts.tableName())));
 
     q.addBindValue(1);
     QVERIFY_SQL(q, exec());
@@ -2842,13 +2794,12 @@ void tst_QSqlQuery::lastInsertId()
     // PostgreSQL >= 8.1 relies on lastval() which does not work if a value is
     // manually inserted to the serial field, so we create a table specifically
     if (tst_Databases::getDatabaseType(db) == QSqlDriver::PostgreSQL) {
-        const auto tableName = qTableName("tst_lastInsertId", __FILE__, db);
-        tst_Databases::safeDropTables(db, {tableName});
+        TableScope ts(db, "tst_lastInsertId", __FILE__);
         QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id serial not null, t_varchar "
                                           "varchar(20), t_char char(20), primary key(id))")
-                            .arg(tableName)));
+                            .arg(ts.tableName())));
         QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (t_varchar, t_char) values "
-                                          "('VarChar41', 'Char41')").arg(tableName)));
+                                          "('VarChar41', 'Char41')").arg(ts.tableName())));
     } else {
         QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (41, 'VarChar41', 'Char41')")
                             .arg(qtest)));
@@ -2894,18 +2845,18 @@ void tst_QSqlQuery::psql_bindWithDoubleColonCastOperator()
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
 
-    const QString tablename(qTableName("bindtest", __FILE__, db));
+    TableScope ts(db, "bindtest", __FILE__);
 
     QSqlQuery q(db);
     QVERIFY_SQL(q, exec(QLatin1String(
                             "create table %1 (id1 int, id2 int, id3 int, fld1 int, fld2 int)")
-                        .arg(tablename)));
-    QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1, 2, 3, 10, 5)").arg(tablename)));
+                        .arg(ts.tableName())));
+    QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1, 2, 3, 10, 5)").arg(ts.tableName())));
 
     // Insert tableName last to let the other %-tokens' numbering match what they're replaced with:
     const auto queryTemplate = QLatin1String("select sum((fld1 - fld2)::int) from %4 where "
                                              "id1 = %1 and id2 =%2 and id3=%3");
-    const QString query = queryTemplate.arg(":myid1", ":myid2", ":myid3", tablename);
+    const QString query = queryTemplate.arg(":myid1", ":myid2", ":myid3", ts.tableName());
     QVERIFY_SQL(q, prepare(query));
     q.bindValue(":myid1", 1);
     q.bindValue(":myid2", 2);
@@ -2916,7 +2867,7 @@ void tst_QSqlQuery::psql_bindWithDoubleColonCastOperator()
 
     // The positional placeholders are converted to named placeholders in executedQuery()
     const QString expected = db.driver()->hasFeature(QSqlDriver::PreparedQueries)
-        ? query : queryTemplate.arg("1", "2", "3", tablename);
+        ? query : queryTemplate.arg("1", "2", "3", ts.tableName());
     QCOMPARE(q.executedQuery(), expected);
 }
 
@@ -3133,7 +3084,8 @@ void tst_QSqlQuery::nextResult()
         QSKIP("DBMS does not support multiple result sets");
 
     QSqlQuery q(db);
-    const QString tableName(qTableName("more_results", __FILE__, db));
+    TableScope ts(db, "more_results", __FILE__);
+    const auto &tableName = ts.tableName();
 
     QVERIFY_SQL(q, exec(QLatin1String(
                             "CREATE TABLE %1 (id integer, text varchar(20), "
@@ -3360,7 +3312,7 @@ void tst_QSqlQuery::blobsPreparedQuery()
         QSKIP("DBMS does not support BLOBs or prepared queries");
     }
 
-    const QString tableName(qTableName("blobstest", __FILE__, db));
+    TableScope ts(db, "blobstest", __FILE__);
 
     QSqlQuery q(db);
     q.setForwardOnly(true); // This is needed to make the test work with DB2.
@@ -3374,8 +3326,8 @@ void tst_QSqlQuery::blobsPreparedQuery()
                                  : dbType == QSqlDriver::MSSqlServer ? "IMAGE" : "BLOB");
 
     QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1(id INTEGER, data %2)")
-                        .arg(tableName, typeName)));
-    q.prepare(QLatin1String("INSERT INTO %1(id, data) VALUES(:id, :data)").arg(tableName));
+                        .arg(ts.tableName(), typeName)));
+    q.prepare(QLatin1String("INSERT INTO %1(id, data) VALUES(:id, :data)").arg(ts.tableName()));
     q.bindValue(":id", 1);
     q.bindValue(":data", shortBLOB);
     QVERIFY_SQL(q, exec());
@@ -3385,7 +3337,7 @@ void tst_QSqlQuery::blobsPreparedQuery()
     QVERIFY_SQL(q, exec());
 
     // Two executions and result sets
-    q.prepare(QLatin1String("SELECT data FROM %1 WHERE id = ?").arg(tableName));
+    q.prepare(QLatin1String("SELECT data FROM %1 WHERE id = ?").arg(ts.tableName()));
     q.bindValue(0, QVariant(1));
     QVERIFY_SQL(q, exec());
     QVERIFY_SQL(q, next());
@@ -3397,7 +3349,7 @@ void tst_QSqlQuery::blobsPreparedQuery()
     QCOMPARE(q.value(0).toString().toUtf8(), longerBLOB.toUtf8());
 
     // Only one execution and result set
-    q.prepare(QLatin1String("SELECT id, data FROM %1 ORDER BY id").arg(tableName));
+    q.prepare(QLatin1String("SELECT id, data FROM %1 ORDER BY id").arg(ts.tableName()));
     QVERIFY_SQL(q, exec());
     QVERIFY_SQL(q, next());
     QCOMPARE(q.value(1).toString(), shortBLOB);
@@ -3413,11 +3365,11 @@ void tst_QSqlQuery::emptyTableNavigate()
     CHECK_DATABASE(db);
 
     {
+        TableScope ts(db, "qtest_empty", __FILE__);
         QSqlQuery q(db);
-        const QString tbl = qTableName("qtest_empty", __FILE__, db);
-        q.exec("drop table " + tbl);
-        QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id char(10))").arg(tbl)));
-        QVERIFY_SQL(q, prepare("select * from " + tbl));
+        q.exec("drop table " + ts.tableName());
+        QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id char(10))").arg(ts.tableName())));
+        QVERIFY_SQL(q, prepare("select * from " + ts.tableName()));
         QVERIFY_SQL(q, exec());
         QVERIFY(!q.next());
         QVERIFY(!q.lastError().isValid());
@@ -3478,10 +3430,10 @@ void tst_QSqlQuery::task_217003()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-    QSqlQuery q(db);
-    const QString planets = qTableName("Planet", __FILE__, db);
+    TableScope ts(db, "Planet", __FILE__);
+    const auto &planets = ts.tableName();
 
-    q.exec("drop table " + planets);
+    QSqlQuery q(db);
     QVERIFY_SQL(q, exec(QLatin1String("create table %1 (Name varchar(20))").arg(planets)));
     QVERIFY_SQL(q, exec(QLatin1String("insert into %1 VALUES ('Mercury')").arg(planets)));
     QVERIFY_SQL(q, exec(QLatin1String("insert into %1 VALUES ('Venus')").arg(planets)));
@@ -3507,11 +3459,10 @@ void tst_QSqlQuery::task_250026()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-    QSqlQuery q(db);
-
-    const QString tableName(qTableName("task_250026", __FILE__, db));
+    TableScope ts(db, "task_250026", __FILE__);
 
-    if (!q.exec(QLatin1String("create table %1 (longfield varchar(1100))").arg(tableName))) {
+    QSqlQuery q(db);
+    if (!q.exec(QLatin1String("create table %1 (longfield varchar(1100))").arg(ts.tableName()))) {
         qDebug() << "Error" << q.lastError();
         QSKIP("Db doesn't support \"1100\" as a size for fields");
     }
@@ -3519,12 +3470,12 @@ void tst_QSqlQuery::task_250026()
     const QString data258(258, QLatin1Char('A'));
     const QString data1026(1026, QLatin1Char('A'));
     QVERIFY_SQL(q, prepare(QLatin1String("insert into %1(longfield) VALUES (:longfield)")
-                           .arg(tableName)));
+                           .arg(ts.tableName())));
     q.bindValue(":longfield", data258);
     QVERIFY_SQL(q, exec());
     q.bindValue(":longfield", data1026);
     QVERIFY_SQL(q, exec());
-    QVERIFY_SQL(q, exec("select * from " + tableName));
+    QVERIFY_SQL(q, exec("select * from " + ts.tableName()));
     QVERIFY_SQL(q, next());
     QCOMPARE(q.value(0).toString().size(), data258.size());
     QVERIFY_SQL(q, next());
@@ -3545,19 +3496,19 @@ void tst_QSqlQuery::crashQueryOnCloseDatabase()
     }
 }
 
-void tst_QSqlQuery::task_233829()
+void tst_QSqlQuery::testNaN()
 {
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
+    TableScope ts(db, "testNaN", __FILE__);
 
     QSqlQuery q(db);
-    const QString tableName(qTableName("task_233829", __FILE__, db));
     QVERIFY_SQL(q, exec(QLatin1String(
                             "CREATE TABLE %1(dbl1 double precision,dbl2 double precision) "
-                            "without oids;").arg(tableName)));
+                            "without oids;").arg(ts.tableName())));
     const QString queryString =
-        QLatin1String("INSERT INTO %1(dbl1, dbl2) VALUES(?,?)").arg(tableName);
+        QLatin1String("INSERT INTO %1(dbl1, dbl2) VALUES(?,?)").arg(ts.tableName());
 
     const double nan = qQNaN();
     QVERIFY_SQL(q, prepare(queryString));
@@ -3566,13 +3517,11 @@ void tst_QSqlQuery::task_233829()
     QVERIFY_SQL(q, exec());
 }
 
-void tst_QSqlQuery::QTBUG_12477()
+void tst_QSqlQuery::psqlNumericMetadata()
 {
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-    if (!db.driverName().startsWith("QPSQL"))
-        QSKIP("PostgreSQL-specific test");
 
     QSqlQuery q(db);
     QVERIFY_SQL(q, exec("SELECT 1::bit, '10101010000111101101'::varbit, "
@@ -3615,10 +3564,10 @@ void tst_QSqlQuery::sqlServerReturn0()
     if (tst_Databases::getDatabaseType(db) != QSqlDriver::MSSqlServer)
         QSKIP("Test is specific to SQL Server");
 
-    const QString tableName(qTableName("test141895", __FILE__, db));
+    TableScope ts(db, "test141895", __FILE__);
+    const auto &tableName = ts.tableName();
     const QString procName(qTableName("test141895_proc", __FILE__, db));
     QSqlQuery q(db);
-    q.exec("DROP TABLE " + tableName);
     q.exec("DROP PROCEDURE " + procName);
     QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id integer)").arg(tableName)));
     QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (id) VALUES (1)").arg(tableName)));
@@ -3785,9 +3734,10 @@ void tst_QSqlQuery::QTBUG_6421()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
+    const QString tableName(qTableName("bug6421", __FILE__, db).toUpper());
+    TableScope ts(db, tableName);
 
     QSqlQuery q(db);
-    const QString tableName(qTableName("bug6421", __FILE__, db).toUpper());
 
     QVERIFY_SQL(q, exec(QLatin1String(
                             "create table %1(COL1 char(10), COL2 char(10), COL3 char(10))")
@@ -3835,8 +3785,10 @@ void tst_QSqlQuery::QTBUG_6852()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
+    TableScope ts(db, "bug6852", __FILE__);
+    const auto &tableName = ts.tableName();
+
     QSqlQuery q(db);
-    const QString tableName(qTableName("bug6852", __FILE__, db));
     const QString procName(qTableName("bug6852_proc", __FILE__, db));
 
     QVERIFY_SQL(q, exec("DROP PROCEDURE IF EXISTS " + procName));
@@ -3867,19 +3819,19 @@ void tst_QSqlQuery::QTBUG_5765()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-    QSqlQuery q(db);
-    const QString tableName(qTableName("bug5765", __FILE__, db));
+    TableScope ts(db, "bug5765", __FILE__);
 
+    QSqlQuery q(db);
     QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1(testval TINYINT(1) DEFAULT 0)")
-                        .arg(tableName)));
-    q.prepare(QLatin1String("INSERT INTO %1 SET testval = :VALUE").arg(tableName));
+                        .arg(ts.tableName())));
+    q.prepare(QLatin1String("INSERT INTO %1 SET testval = :VALUE").arg(ts.tableName()));
     q.bindValue(":VALUE", 1);
     QVERIFY_SQL(q, exec());
     q.bindValue(":VALUE", 12);
     QVERIFY_SQL(q, exec());
     q.bindValue(":VALUE", 123);
     QVERIFY_SQL(q, exec());
-    QString sql = "select testval from " + tableName;
+    QString sql = "select testval from " + ts.tableName();
     QVERIFY_SQL(q, exec(sql));
     QVERIFY_SQL(q, next());
     QCOMPARE(q.value(0).toInt(), 1);
@@ -3906,9 +3858,10 @@ void tst_QSqlQuery::QTBUG_21884()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
+    TableScope ts(db, "bug21884", __FILE__);
+    const auto &tableName = ts.tableName();
 
     QSqlQuery q(db);
-    QString tableName(qTableName("bug21884", __FILE__, db));
 
     {
         const QString good[] = {
@@ -4005,10 +3958,11 @@ void tst_QSqlQuery::QTBUG_23895()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
+    TableScope ts(db, "bug23895", __FILE__);
+    const auto &tableName = ts.tableName();
 
     QSqlQuery q(db);
 
-    QString tableName(qTableName("bug23895", __FILE__, db));
     q.prepare(QLatin1String("create table %1(id integer primary key, val1 bool, val2 boolean)")
               .arg(tableName));
     QVERIFY_SQL(q, exec());
@@ -4059,11 +4013,9 @@ void tst_QSqlQuery::QTBUG_14904()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-
-    QSqlQuery q(db);
-
     TableScope ts(db, "bug14904", __FILE__);
 
+    QSqlQuery q(db);
     q.prepare(QLatin1String("create table %1(val1 bool)").arg(ts.tableName()));
     QVERIFY_SQL(q, exec());
     q.prepare(QLatin1String("insert into %1(val1) values(?);").arg(ts.tableName()));
@@ -4196,9 +4148,9 @@ void tst_QSqlQuery::gisPointDatatype()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
+    TableScope ts(db, "qtbug72140", __FILE__);
 
     QSqlQuery sqlQuery(db);
-    TableScope ts(db, "qtbug72140", __FILE__);
     QVERIFY(sqlQuery.exec(QLatin1String(
                               "CREATE TABLE %1 (`lonlat_point` POINT NULL) ENGINE = InnoDB;")
                           .arg(ts.tableName())));
@@ -4215,13 +4167,13 @@ void tst_QSqlQuery::oraOCINumber()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-    const QString qtest_oraOCINumber(qTableName("qtest_oraOCINumber", __FILE__, db));
+    TableScope ts(db, "qtest_oraOCINumber", __FILE__);
 
     QSqlQuery q(db);
     q.setForwardOnly(true);
     QVERIFY_SQL(q, exec(QLatin1String("create table %1 (col1 number(20), col2 number(20))")
-                        .arg(qtest_oraOCINumber)));
-    QVERIFY(q.prepare(QLatin1String("insert into %1 values (?, ?)").arg(qtest_oraOCINumber)));
+                        .arg(ts.tableName())));
+    QVERIFY(q.prepare(QLatin1String("insert into %1 values (?, ?)").arg(ts.tableName())));
 
     const QVariantList col1Values = {
         qulonglong(1), qulonglong(0), qulonglong(INT_MAX), qulonglong(UINT_MAX),
@@ -4238,7 +4190,7 @@ void tst_QSqlQuery::oraOCINumber()
     QVERIFY(q.execBatch());
     QVERIFY(q.prepare(QLatin1String(
                           "select * from %1 where col1 = :bindValue0 AND col2 = :bindValue1")
-                      .arg(qtest_oraOCINumber)));
+                      .arg(ts.tableName())));
 
     q.bindValue(":bindValue0", qulonglong(1), QSql::InOut);
     q.bindValue(":bindValue1", qlonglong(1), QSql::InOut);
@@ -4310,8 +4262,6 @@ void tst_QSqlQuery::sqlite_constraint()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-    if (tst_Databases::getDatabaseType(db) != QSqlDriver::SQLite)
-        QSKIP("SQLite3-specific test");
 
     QSqlQuery q(db);
     const QString trigger(qTableName("test_constraint", __FILE__, db));
@@ -4555,9 +4505,9 @@ void runIntegralTypesMysqlTest(QSqlDatabase &db, const QString &tableName, const
 {
     QList<QVariant> variantValues;
     variantValues.reserve(values.size());
+    TableScope ts(db, tableName);
 
     QSqlQuery q(db);
-    QVERIFY_SQL(q, exec("DROP TABLE IF EXISTS " + tableName));
     QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %2 (id %1)").arg(type, tableName)));
 
     if (withPreparedStatement) {
@@ -4663,9 +4613,9 @@ void tst_QSqlQuery::QTBUG_57138()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
+    TableScope ts(db, "qtbug57138", __FILE__);
 
     QSqlQuery create(db);
-    TableScope ts(db, "qtbug57138", __FILE__);
 
     QVERIFY_SQL(create, exec(QLatin1String(
                                  "create table %1 (id int, dt_utc datetime, dt_lt datetime, "
@@ -4697,10 +4647,9 @@ void tst_QSqlQuery::QTBUG_73286()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-
-    QSqlQuery create(db);
     TableScope ts(db, "qtbug73286", __FILE__);
 
+    QSqlQuery create(db);
     QVERIFY_SQL(create, exec(QLatin1String(
                                  "create table %1 (dec2 decimal(4,2), dec0 decimal(20,0), "
                                  "dec3 decimal(20,3))").arg(ts.tableName())));
@@ -4798,8 +4747,6 @@ void tst_QSqlQuery::dateTime_data()
         if (!db.isValid())
             continue;
         const QString tableNameTSWithTimeZone(qTableName("dateTimeTSWithTimeZone", __FILE__, db));
-        const QString tableNameTSWithLocalTimeZone(qTableName("dateTimeTSWithLocalTimeZone",
-                                                              __FILE__, db));
         const QString tableNameTS(qTableName("dateTimeTS", __FILE__, db));
         const QString tableNameDate(qTableName("dateTimeDate", __FILE__, db));
         QTest::newRow(QString(dbName + " timestamp with time zone").toLatin1())
diff --git a/tests/auto/sql/kernel/qsqlthread/tst_qsqlthread.cpp b/tests/auto/sql/kernel/qsqlthread/tst_qsqlthread.cpp
index a174ea6f37..7e6289e911 100644
--- a/tests/auto/sql/kernel/qsqlthread/tst_qsqlthread.cpp
+++ b/tests/auto/sql/kernel/qsqlthread/tst_qsqlthread.cpp
@@ -258,18 +258,16 @@ void tst_QSqlThread::generic_data(const QString& engine)
 
 void tst_QSqlThread::dropTestTables()
 {
-    for (int i = 0; i < dbs.dbNames.size(); ++i) {
-        QSqlDatabase db = QSqlDatabase::database(dbs.dbNames.at(i));
-        QSqlQuery q(db);
-
-        tst_Databases::safeDropTables(db, QStringList() << qtest << qTableName("qtest2", __FILE__, db) << qTableName("emptytable", __FILE__, db));
+    for (const auto &dbName : dbs.dbNames) {
+        QSqlDatabase db = QSqlDatabase::database(dbName);
+        tst_Databases::safeDropTables(db, { qtest, qTableName("qtest2", __FILE__, db), qTableName("emptytable", __FILE__, db) });
     }
 }
 
 void tst_QSqlThread::createTestTables()
 {
-    for (int i = 0; i < dbs.dbNames.size(); ++i) {
-        QSqlDatabase db = QSqlDatabase::database(dbs.dbNames.at(i));
+    for (const auto &dbName : dbs.dbNames) {
+        QSqlDatabase db = QSqlDatabase::database(dbName);
         QSqlQuery q(db);
 
         QVERIFY_SQL(q, exec("create table " + qtest
@@ -285,8 +283,8 @@ void tst_QSqlThread::createTestTables()
 
 void tst_QSqlThread::repopulateTestTables()
 {
-    for (int i = 0; i < dbs.dbNames.size(); ++i) {
-        QSqlDatabase db = QSqlDatabase::database(dbs.dbNames.at(i));
+    for (const auto &dbName : dbs.dbNames) {
+        QSqlDatabase db = QSqlDatabase::database(dbName);
         QSqlQuery q(db);
 
         QVERIFY_SQL(q, exec("delete from " + qtest));
diff --git a/tests/auto/sql/models/qsqlquerymodel/tst_qsqlquerymodel.cpp b/tests/auto/sql/models/qsqlquerymodel/tst_qsqlquerymodel.cpp
index 202fc1080c..a6915243a6 100644
--- a/tests/auto/sql/models/qsqlquerymodel/tst_qsqlquerymodel.cpp
+++ b/tests/auto/sql/models/qsqlquerymodel/tst_qsqlquerymodel.cpp
@@ -62,9 +62,9 @@ private slots:
     void task_QTBUG_4963_setHeaderDataWithProxyModel();
 
 private:
-    void generic_data(const QString &engine=QString());
-    void dropTestTables(QSqlDatabase db);
-    void createTestTables(QSqlDatabase db);
+    void generic_data(const QString &engine = QString());
+    void dropTestTables(const QSqlDatabase &db);
+    void createTestTables(const QSqlDatabase &db);
     void populateTestTables(QSqlDatabase db);
     tst_Databases dbs;
 };
@@ -73,8 +73,8 @@ private:
 class DBTestModel: public QSqlQueryModel
 {
 public:
-    DBTestModel(QObject *parent = nullptr): QSqlQueryModel(parent) {}
-    QModelIndex indexInQuery(const QModelIndex &item) const override { return QSqlQueryModel::indexInQuery(item); }
+    using QSqlQueryModel::QSqlQueryModel;
+    using QSqlQueryModel::indexInQuery;
 };
 
 tst_QSqlQueryModel::tst_QSqlQueryModel()
@@ -88,8 +88,8 @@ tst_QSqlQueryModel::~tst_QSqlQueryModel()
 void tst_QSqlQueryModel::initTestCase()
 {
     QVERIFY(dbs.open());
-    for (QStringList::ConstIterator it = dbs.dbNames.begin(); it != dbs.dbNames.end(); ++it) {
-        QSqlDatabase db = QSqlDatabase::database((*it));
+    for (const auto &dbName : std::as_const(dbs.dbNames)) {
+        QSqlDatabase db = QSqlDatabase::database(dbName);
         CHECK_DATABASE(db);
         dropTestTables(db); //in case of leftovers
         createTestTables(db);
@@ -99,15 +99,15 @@ void tst_QSqlQueryModel::initTestCase()
 
 void tst_QSqlQueryModel::cleanupTestCase()
 {
-    for (QStringList::ConstIterator it = dbs.dbNames.begin(); it != dbs.dbNames.end(); ++it) {
-        QSqlDatabase db = QSqlDatabase::database((*it));
+    for (const auto &dbName : std::as_const(dbs.dbNames)) {
+        QSqlDatabase db = QSqlDatabase::database(dbName);
         CHECK_DATABASE(db);
         dropTestTables(db);
     }
     dbs.close();
 }
 
-void tst_QSqlQueryModel::dropTestTables(QSqlDatabase db)
+void tst_QSqlQueryModel::dropTestTables(const QSqlDatabase &db)
 {
     QStringList tableNames;
     tableNames << qTableName("test", __FILE__, db)
@@ -117,7 +117,7 @@ void tst_QSqlQueryModel::dropTestTables(QSqlDatabase db)
     tst_Databases::safeDropTables(db, tableNames);
 }
 
-void tst_QSqlQueryModel::createTestTables(QSqlDatabase db)
+void tst_QSqlQueryModel::createTestTables(const QSqlDatabase &db)
 {
     dropTestTables(db);
     QSqlQuery q(db);