Cleanup remaining QVariant::Type uses in Qt Sql

Change-Id: Ibcaa678cd9f9c957392a75b477fa6821f9a69127
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>

7 files changed, 270 insertions, 268 deletions

diff --git a/src/plugins/sqldrivers/sqlite/qsql_sqlite.cpp b/src/plugins/sqldrivers/sqlite/qsql_sqlite.cpp
index 60e871a25a..d6a0f319f9 100644
--- a/src/plugins/sqldrivers/sqlite/qsql_sqlite.cpp
+++ b/src/plugins/sqldrivers/sqlite/qsql_sqlite.cpp
@@ -85,24 +85,24 @@ static QString _q_escapeIdentifier(const QString &identifier)
     return res;
 }
 
-static QVariant::Type qGetColumnType(const QString &tpName)
+static int qGetColumnType(const QString &tpName)
 {
     const QString typeName = tpName.toLower();
 
     if (typeName == QLatin1String("integer")
         || typeName == QLatin1String("int"))
-        return QVariant::Int;
+        return QMetaType::Int;
     if (typeName == QLatin1String("double")
         || typeName == QLatin1String("float")
         || typeName == QLatin1String("real")
         || typeName.startsWith(QLatin1String("numeric")))
-        return QVariant::Double;
+        return QMetaType::Double;
     if (typeName == QLatin1String("blob"))
-        return QVariant::ByteArray;
+        return QMetaType::QByteArray;
     if (typeName == QLatin1String("boolean")
         || typeName == QLatin1String("bool"))
-        return QVariant::Bool;
-    return QVariant::String;
+        return QMetaType::Bool;
+    return QMetaType::QString;
 }
 
 static QSqlError qMakeError(sqlite3 *access, const QString &descr, QSqlError::ErrorType type,
@@ -214,7 +214,7 @@ void QSQLiteResultPrivate::initColumns(bool emptyResultset)
         // 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;
+        int fieldType;
 
         if (!typeName.isEmpty()) {
             fieldType = qGetColumnType(typeName);
@@ -222,25 +222,25 @@ void QSQLiteResultPrivate::initColumns(bool emptyResultset)
             // Get the proper type for the field based on stp value
             switch (stp) {
             case SQLITE_INTEGER:
-                fieldType = QVariant::Int;
+                fieldType = QMetaType::Int;
                 break;
             case SQLITE_FLOAT:
-                fieldType = QVariant::Double;
+                fieldType = QMetaType::Double;
                 break;
             case SQLITE_BLOB:
-                fieldType = QVariant::ByteArray;
+                fieldType = QMetaType::QByteArray;
                 break;
             case SQLITE_TEXT:
-                fieldType = QVariant::String;
+                fieldType = QMetaType::QString;
                 break;
             case SQLITE_NULL:
             default:
-                fieldType = QVariant::Invalid;
+                fieldType = QMetaType::UnknownType;
                 break;
             }
         }
 
-        QSqlField fld(colName, fieldType, tableName);
+        QSqlField fld(colName, QMetaType(fieldType), tableName);
         fld.setSqlType(stp);
         rInf.append(fld);
     }
@@ -502,37 +502,37 @@ bool QSQLiteResult::exec()
                 res = sqlite3_bind_null(d->stmt, i + 1);
             } else {
                 switch (value.userType()) {
-                case QVariant::ByteArray: {
+                case QMetaType::QByteArray: {
                     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:
-                case QVariant::Bool:
+                case QMetaType::Int:
+                case QMetaType::Bool:
                     res = sqlite3_bind_int(d->stmt, i + 1, value.toInt());
                     break;
-                case QVariant::Double:
+                case QMetaType::Double:
                     res = sqlite3_bind_double(d->stmt, i + 1, value.toDouble());
                     break;
-                case QVariant::UInt:
-                case QVariant::LongLong:
+                case QMetaType::UInt:
+                case QMetaType::LongLong:
                     res = sqlite3_bind_int64(d->stmt, i + 1, value.toLongLong());
                     break;
-                case QVariant::DateTime: {
+                case QMetaType::QDateTime: {
                     const QDateTime dateTime = value.toDateTime();
                     const QString str = dateTime.toString(Qt::ISODateWithMs);
                     res = sqlite3_bind_text16(d->stmt, i + 1, str.utf16(),
                                               str.size() * sizeof(ushort), SQLITE_TRANSIENT);
                     break;
                 }
-                case QVariant::Time: {
+                case QMetaType::QTime: {
                     const QTime time = value.toTime();
                     const QString str = time.toString(u"hh:mm:ss.zzz");
                     res = sqlite3_bind_text16(d->stmt, i + 1, str.utf16(),
                                               str.size() * sizeof(ushort), SQLITE_TRANSIENT);
                     break;
                 }
-                case QVariant::String: {
+                case QMetaType::QString: {
                     // 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(),
@@ -925,7 +925,7 @@ static QSqlIndex qGetTableInfo(QSqlQuery &q, const QString &tableName, bool only
                 defVal = defVal.mid(1, end - 1);
         }
 
-        QSqlField fld(q.value(1).toString(), qGetColumnType(typeName), tableName);
+        QSqlField fld(q.value(1).toString(), QMetaType(qGetColumnType(typeName)), tableName);
         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!
diff --git a/src/sql/kernel/qsqlfield.h b/src/sql/kernel/qsqlfield.h
index 3a133c4e6b..27ad47ca35 100644
--- a/src/sql/kernel/qsqlfield.h
+++ b/src/sql/kernel/qsqlfield.h
@@ -54,7 +54,7 @@ class Q_SQL_EXPORT QSqlField
 public:
     enum RequiredStatus { Unknown = -1, Optional = 0, Required = 1 };
 
-#if QT_DEPRECATED_SINCE(6,0)
+#if QT_DEPRECATED_SINCE(6, 0)
     QT_DEPRECATED_VERSION_X_6_0("Use the constructor using a QMetaType instead")
     QSqlField(const QString& fieldName, QVariant::Type type, const QString &tableName = QString())
         : QSqlField(fieldName, QMetaType(type), tableName)
@@ -84,12 +84,14 @@ public:
 
     QMetaType metaType() const;
     void setMetaType(QMetaType type);
-#if QT_DEPRECATED_SINCE(6,0)
+
+#if QT_DEPRECATED_SINCE(6, 0)
     QT_DEPRECATED_VERSION_X_6_0("Use metaType() instead")
     QVariant::Type type() const { return QVariant::Type(metaType().id()); };
     QT_DEPRECATED_VERSION_X_6_0("Use setMetaType() instead")
     void setType(QVariant::Type type) { setMetaType(QMetaType(int(type))); }
 #endif
+
     void setRequiredStatus(RequiredStatus status);
     inline void setRequired(bool required)
     { setRequiredStatus(required ? Required : Optional); }
diff --git a/tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp b/tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp
index e412b6f3ed..4e6664faa0 100644
--- a/tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp
+++ b/tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp
@@ -220,7 +220,7 @@ static const int ITERATION_COUNT = 2;
 //helper class for database specific tests
 struct FieldDef {
     FieldDef(QString tn = QString(),
-          QVariant::Type t = QVariant::Invalid,
+          int t = QMetaType::UnknownType,
           QVariant v = QVariant(),
           bool nl = true):
         typeName(tn), type(t), val(v), nullable(nl) {}
@@ -237,7 +237,7 @@ struct FieldDef {
         return "t_" + rt.left(i);
     }
     QString typeName;
-    QVariant::Type type;
+    int type;
     QVariant val;
     bool nullable;
 };
@@ -656,8 +656,8 @@ void tst_QSqlDatabase::record()
     CHECK_DATABASE(db);
 
     static const FieldDef fieldDefs[] = {
-        FieldDef("char(20)", QMetaType(QMetaType::String),         QString("blah1"), false),
-        FieldDef("varchar(20)", QMetaType(QMetaType::String),      QString("blah2"), false),
+        FieldDef("char(20)", QMetaType(QMetaType::QString),         QString("blah1"), false),
+        FieldDef("varchar(20)", QMetaType(QMetaType::QString),      QString("blah2"), false),
         FieldDef()
     };
 
@@ -675,7 +675,7 @@ void tst_QSqlDatabase::testRecord(const FieldDef fieldDefs[], const QSqlRecord&
         QVERIFY2(inf.field(i).isAutoValue(), qPrintable(inf.field(i).name() + " should be reporting as an autovalue"));
     for (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() != int(fieldDefs[ i ].type)) {
+        if (inf.field(i+1).metaType().id() != fieldDefs[ i ].type) {
             QFAIL(qPrintable(QString(" Expected: '%1' Received: '%2' for field %3 in testRecord").arg(
               QMetaType(fieldDefs[ i ].type).name()).arg(
               inf.field(i+1).metaType().name()).arg(
@@ -713,26 +713,26 @@ void tst_QSqlDatabase::recordTDS()
     CHECK_DATABASE(db);
 
     static const FieldDef fieldDefs[] = {
-        FieldDef("tinyint", QVariant::Int,              255),
-        FieldDef("smallint", QVariant::Int,             32767),
-        FieldDef("int", QVariant::Int,                  2147483647),
-        FieldDef("numeric(10,9)", QVariant::Double,     1.23456789),
-        FieldDef("decimal(10,9)", QVariant::Double,     1.23456789),
-        FieldDef("float(4)", QVariant::Double,          1.23456789),
-        FieldDef("double precision", QVariant::Double,  1.23456789),
-        FieldDef("real", QVariant::Double,              1.23456789),
-        FieldDef("smallmoney", QVariant::Double,        100.42),
-        FieldDef("money", QVariant::Double,             200.42),
+        FieldDef("tinyint", QMetaType::Int,              255),
+        FieldDef("smallint", QMetaType::Int,             32767),
+        FieldDef("int", QMetaType::Int,                  2147483647),
+        FieldDef("numeric(10,9)", QMetaType::Double,     1.23456789),
+        FieldDef("decimal(10,9)", QMetaType::Double,     1.23456789),
+        FieldDef("float(4)", QMetaType::Double,          1.23456789),
+        FieldDef("double precision", QMetaType::Double,  1.23456789),
+        FieldDef("real", QMetaType::Double,              1.23456789),
+        FieldDef("smallmoney", QMetaType::Double,        100.42),
+        FieldDef("money", QMetaType::Double,             200.42),
         // accuracy is that of a minute
-        FieldDef("smalldatetime", QVariant::DateTime,   QDateTime(QDate::currentDate(), QTime(1, 2, 0, 0))),
+        FieldDef("smalldatetime", QMetaType::QDateTime,   QDateTime(QDate::currentDate(), QTime(1, 2, 0, 0))),
         // accuracy is that of a second
-        FieldDef("datetime", QVariant::DateTime,        QDateTime(QDate::currentDate(), QTime(1, 2, 3, 0))),
-        FieldDef("char(20)", QVariant::String,          "blah1"),
-        FieldDef("varchar(20)", QVariant::String,       "blah2"),
-        FieldDef("nchar(20)", QVariant::String,         "blah3"),
-        FieldDef("nvarchar(20)", QVariant::String,      "blah4"),
-        FieldDef("text", QVariant::String,              "blah5"),
-        FieldDef("bit", QVariant::Int,                  1, false),
+        FieldDef("datetime", QMetaType::QDateTime,        QDateTime(QDate::currentDate(), QTime(1, 2, 3, 0))),
+        FieldDef("char(20)", QMetaType::QString,          "blah1"),
+        FieldDef("varchar(20)", QMetaType::QString,       "blah2"),
+        FieldDef("nchar(20)", QMetaType::QString,         "blah3"),
+        FieldDef("nvarchar(20)", QMetaType::QString,      "blah4"),
+        FieldDef("text", QMetaType::QString,              "blah5"),
+        FieldDef("bit", QMetaType::Int,                  1, false),
 
         FieldDef()
     };
@@ -764,26 +764,26 @@ void tst_QSqlDatabase::recordOCI()
     static const QDateTime dt(QDate::currentDate(), QTime(1, 2, 3, 0));
 
     if (hasTimeStamp) {
-        tsdef = FieldDef("timestamp", QVariant::DateTime,  dt);
-        tstzdef = FieldDef("timestamp with time zone", QVariant::DateTime, dt);
-        tsltzdef = FieldDef("timestamp with local time zone", QVariant::DateTime, dt);
-        intytm = FieldDef("interval year to month", QVariant::String, QString("+01-01"));
-        intdts = FieldDef("interval day to second", QVariant::String, QString("+01 00:00:01.000000"));
+        tsdef = FieldDef("timestamp", QMetaType::QDateTime,  dt);
+        tstzdef = FieldDef("timestamp with time zone", QMetaType::QDateTime, dt);
+        tsltzdef = FieldDef("timestamp with local time zone", QMetaType::QDateTime, dt);
+        intytm = FieldDef("interval year to month", QMetaType::QString, QString("+01-01"));
+        intdts = FieldDef("interval day to second", QMetaType::QString, QString("+01 00:00:01.000000"));
     }
 
     const FieldDef fieldDefs[] = {
-        FieldDef("char(20)", QVariant::String,          QString("blah1")),
-        FieldDef("varchar(20)", QVariant::String,       QString("blah2")),
-        FieldDef("nchar(20)", QVariant::String,         QString("blah3")),
-        FieldDef("nvarchar2(20)", QVariant::String,     QString("blah4")),
-        FieldDef("number(10,5)", QVariant::Double,      1.1234567),
-        FieldDef("date", QVariant::DateTime,            dt),
-        FieldDef("long raw", QVariant::ByteArray,       QByteArray("blah5")),
-        FieldDef("raw(2000)", QVariant::ByteArray,      QByteArray("blah6"), false),
-        FieldDef("blob", QVariant::ByteArray,           QByteArray("blah7")),
-        FieldDef("clob", QVariant::ByteArray, QByteArray("blah8")),
-        FieldDef("nclob", QVariant::ByteArray, QByteArray("blah9")),
-//        FieldDef("bfile", QVariant::ByteArray,         QByteArray("blah10")),
+        FieldDef("char(20)", QMetaType::QString,          QString("blah1")),
+        FieldDef("varchar(20)", QMetaType::QString,       QString("blah2")),
+        FieldDef("nchar(20)", QMetaType::QString,         QString("blah3")),
+        FieldDef("nvarchar2(20)", QMetaType::QString,     QString("blah4")),
+        FieldDef("number(10,5)", QMetaType::Double,      1.1234567),
+        FieldDef("date", QMetaType::QDateTime,            dt),
+        FieldDef("long raw", QMetaType::QByteArray,       QByteArray("blah5")),
+        FieldDef("raw(2000)", QMetaType::QByteArray,      QByteArray("blah6"), false),
+        FieldDef("blob", QMetaType::QByteArray,           QByteArray("blah7")),
+        FieldDef("clob", QMetaType::QByteArray, QByteArray("blah8")),
+        FieldDef("nclob", QMetaType::QByteArray, QByteArray("blah9")),
+//        FieldDef("bfile", QMetaType::QByteArray,         QByteArray("blah10")),
 
         intytm,
         intdts,
@@ -819,39 +819,39 @@ void tst_QSqlDatabase::recordPSQL()
 
     FieldDef byteadef;
     if (db.driver()->hasFeature(QSqlDriver::BLOB))
-        byteadef = FieldDef("bytea", QVariant::ByteArray, QByteArray("bl\\ah"));
+        byteadef = FieldDef("bytea", QMetaType::QByteArray, QByteArray("bl\\ah"));
     static FieldDef fieldDefs[] = {
-        FieldDef("bigint", QVariant::LongLong,       Q_INT64_C(9223372036854775807)),
-        FieldDef("bigserial", QVariant::LongLong,    100, false),
-        FieldDef("bit", QVariant::String,            "1"), // a bit in postgres is a bit-string
-        FieldDef("box", QVariant::String,            "(5,6),(1,2)"),
-        FieldDef("char(20)", QVariant::String,       "blah5678901234567890"),
-        FieldDef("varchar(20)", QVariant::String,    "blah5678901234567890"),
-        FieldDef("cidr", QVariant::String,           "12.123.0.0/24"),
-        FieldDef("circle", QVariant::String,         "<(1,2),3>"),
-        FieldDef("date", QVariant::Date,             QDate::currentDate()),
-        FieldDef("float8", QVariant::Double,         1.12345678912),
-        FieldDef("inet", QVariant::String,           "12.123.12.23"),
-        FieldDef("integer", QVariant::Int,           2147483647),
-        FieldDef("interval", QVariant::String,       "1 day 12:59:10"),
+        FieldDef("bigint", QMetaType::LongLong,       Q_INT64_C(9223372036854775807)),
+        FieldDef("bigserial", QMetaType::LongLong,    100, false),
+        FieldDef("bit", QMetaType::QString,            "1"), // a bit in postgres is a bit-string
+        FieldDef("box", QMetaType::QString,            "(5,6),(1,2)"),
+        FieldDef("char(20)", QMetaType::QString,       "blah5678901234567890"),
+        FieldDef("varchar(20)", QMetaType::QString,    "blah5678901234567890"),
+        FieldDef("cidr", QMetaType::QString,           "12.123.0.0/24"),
+        FieldDef("circle", QMetaType::QString,         "<(1,2),3>"),
+        FieldDef("date", QMetaType::QDate,             QDate::currentDate()),
+        FieldDef("float8", QMetaType::Double,         1.12345678912),
+        FieldDef("inet", QMetaType::QString,           "12.123.12.23"),
+        FieldDef("integer", QMetaType::Int,           2147483647),
+        FieldDef("interval", QMetaType::QString,       "1 day 12:59:10"),
 //      LOL... you can create a "line" datatype in PostgreSQL <= 7.2.x but
 //      as soon as you want to insert data you get a "not implemented yet" error
-//      FieldDef("line", QVariant::Polygon, QPolygon(QRect(1, 2, 3, 4))),
-        FieldDef("lseg", QVariant::String,           "[(1,1),(2,2)]"),
-        FieldDef("macaddr", QVariant::String,        "08:00:2b:01:02:03"),
-        FieldDef("money", QVariant::String,          "$12.23"),
-        FieldDef("numeric", QVariant::Double,        1.2345678912),
-        FieldDef("path", QVariant::String,           "((1,2),(3,2),(3,5),(1,5))"),
-        FieldDef("point", QVariant::String,          "(1,2)"),
-        FieldDef("polygon", QVariant::String,        "((1,2),(3,2),(3,5),(1,5))"),
-        FieldDef("real", QVariant::Double,           1.1234),
-        FieldDef("smallint", QVariant::Int,          32767),
-        FieldDef("serial", QVariant::Int,            100, false),
-        FieldDef("text", QVariant::String,           "blah"),
-        FieldDef("time(6)", QVariant::Time,          QTime(1, 2, 3)),
-        FieldDef("timetz", QVariant::Time,           QTime(1, 2, 3)),
-        FieldDef("timestamp(6)", QVariant::DateTime, QDateTime::currentDateTime()),
-        FieldDef("timestamptz", QVariant::DateTime,  QDateTime::currentDateTime()),
+//      FieldDef("line", QMetaType::Polygon, QPolygon(QRect(1, 2, 3, 4))),
+        FieldDef("lseg", QMetaType::QString,           "[(1,1),(2,2)]"),
+        FieldDef("macaddr", QMetaType::QString,        "08:00:2b:01:02:03"),
+        FieldDef("money", QMetaType::QString,          "$12.23"),
+        FieldDef("numeric", QMetaType::Double,        1.2345678912),
+        FieldDef("path", QMetaType::QString,           "((1,2),(3,2),(3,5),(1,5))"),
+        FieldDef("point", QMetaType::QString,          "(1,2)"),
+        FieldDef("polygon", QMetaType::QString,        "((1,2),(3,2),(3,5),(1,5))"),
+        FieldDef("real", QMetaType::Double,           1.1234),
+        FieldDef("smallint", QMetaType::Int,          32767),
+        FieldDef("serial", QMetaType::Int,            100, false),
+        FieldDef("text", QMetaType::QString,           "blah"),
+        FieldDef("time(6)", QMetaType::QTime,          QTime(1, 2, 3)),
+        FieldDef("timetz", QMetaType::QTime,           QTime(1, 2, 3)),
+        FieldDef("timestamp(6)", QMetaType::QDateTime, QDateTime::currentDateTime()),
+        FieldDef("timestamptz", QMetaType::QDateTime,  QDateTime::currentDateTime()),
         byteadef,
 
         FieldDef()
@@ -901,37 +901,37 @@ void tst_QSqlDatabase::recordMySQL()
         with space on insert, and trailing spaces are removed on select.
     */
     if( vernum >= ((5 << 16) + 15) ) {
-        bin10 = FieldDef("binary(10)", QVariant::ByteArray, QString("123abc    "));
-        varbin10 = FieldDef("varbinary(10)", QVariant::ByteArray, QString("123abcv   "));
+        bin10 = FieldDef("binary(10)", QMetaType::QByteArray, QString("123abc    "));
+        varbin10 = FieldDef("varbinary(10)", QMetaType::QByteArray, QString("123abcv   "));
     }
 
     static QDateTime dt(QDate::currentDate(), QTime(1, 2, 3, 0));
     static const FieldDef fieldDefs[] = {
-        FieldDef("tinyint", static_cast<QVariant::Type>(QMetaType::Char), 127),
-        FieldDef("tinyint unsigned", static_cast<QVariant::Type>(QMetaType::UChar), 255),
-        FieldDef("smallint", static_cast<QVariant::Type>(QMetaType::Short), 32767),
-        FieldDef("smallint unsigned", static_cast<QVariant::Type>(QMetaType::UShort), 65535),
-        FieldDef("mediumint", QVariant::Int,             8388607),
-        FieldDef("mediumint unsigned", QVariant::UInt,   16777215),
-        FieldDef("integer", QVariant::Int,               2147483647),
-        FieldDef("integer unsigned", QVariant::UInt,     4294967295u),
-        FieldDef("bigint", QVariant::LongLong,           Q_INT64_C(9223372036854775807)),
-        FieldDef("bigint unsigned", QVariant::ULongLong, Q_UINT64_C(18446744073709551615)),
-        FieldDef("float", QVariant::Double,              1.12345),
-        FieldDef("double", QVariant::Double,             1.123456789),
-        FieldDef("decimal(10, 9)", QVariant::Double,     1.123456789),
-        FieldDef("numeric(5, 2)", QVariant::Double,      123.67),
-        FieldDef("date", QVariant::Date,                 QDate::currentDate()),
-        FieldDef("datetime", QVariant::DateTime,         dt),
-        FieldDef("timestamp", QVariant::DateTime,        dt, false),
-        FieldDef("time", QVariant::String,               dt.time()),
-        FieldDef("year", QVariant::Int,                  2003),
-        FieldDef("char(20)", QVariant::String,           "Blah"),
-        FieldDef("varchar(20)", QVariant::String,        "BlahBlah"),
-        FieldDef("tinytext", QVariant::String,           QString("blah5")),
-        FieldDef("text", QVariant::String,               QString("blah6")),
-        FieldDef("mediumtext", QVariant::String,         QString("blah7")),
-        FieldDef("longtext", QVariant::String,           QString("blah8")),
+        FieldDef("tinyint", QMetaType::Char, 127),
+        FieldDef("tinyint unsigned", QMetaType::UChar, 255),
+        FieldDef("smallint", QMetaType::Short, 32767),
+        FieldDef("smallint unsigned", QMetaType::UShort, 65535),
+        FieldDef("mediumint", QMetaType::Int,             8388607),
+        FieldDef("mediumint unsigned", QMetaType::UInt,   16777215),
+        FieldDef("integer", QMetaType::Int,               2147483647),
+        FieldDef("integer unsigned", QMetaType::UInt,     4294967295u),
+        FieldDef("bigint", QMetaType::LongLong,           Q_INT64_C(9223372036854775807)),
+        FieldDef("bigint unsigned", QMetaType::ULongLong, Q_UINT64_C(18446744073709551615)),
+        FieldDef("float", QMetaType::Double,              1.12345),
+        FieldDef("double", QMetaType::Double,             1.123456789),
+        FieldDef("decimal(10, 9)", QMetaType::Double,     1.123456789),
+        FieldDef("numeric(5, 2)", QMetaType::Double,      123.67),
+        FieldDef("date", QMetaType::QDate,                 QDate::currentDate()),
+        FieldDef("datetime", QMetaType::QDateTime,         dt),
+        FieldDef("timestamp", QMetaType::QDateTime,        dt, false),
+        FieldDef("time", QMetaType::QString,               dt.time()),
+        FieldDef("year", QMetaType::Int,                  2003),
+        FieldDef("char(20)", QMetaType::QString,           "Blah"),
+        FieldDef("varchar(20)", QMetaType::QString,        "BlahBlah"),
+        FieldDef("tinytext", QMetaType::QString,           QString("blah5")),
+        FieldDef("text", QMetaType::QString,               QString("blah6")),
+        FieldDef("mediumtext", QMetaType::QString,         QString("blah7")),
+        FieldDef("longtext", QMetaType::QString,           QString("blah8")),
         // SET OF?
 
         FieldDef()
@@ -955,26 +955,26 @@ void tst_QSqlDatabase::recordDB2()
     CHECK_DATABASE(db);
 
     static const FieldDef fieldDefs[] = {
-        FieldDef("char(20)", QVariant::String,         QString("Blah1")),
-        FieldDef("varchar(20)", QVariant::String,      QString("Blah2")),
-        FieldDef("long varchar", QVariant::String,     QString("Blah3")),
+        FieldDef("char(20)", QMetaType::QString,         QString("Blah1")),
+        FieldDef("varchar(20)", QMetaType::QString,      QString("Blah2")),
+        FieldDef("long varchar", QMetaType::QString,     QString("Blah3")),
         // using BOOLEAN results in "SQL0486N  The BOOLEAN data type is currently only supported internally."
-//X     FieldDef("boolean" , QVariant::Bool,           QVariant(true, 1)),
-        FieldDef("smallint", QVariant::Int,            32767),
-        FieldDef("integer", QVariant::Int,             2147483647),
-        FieldDef("bigint", QVariant::LongLong,         Q_INT64_C(9223372036854775807)),
-        FieldDef("real", QVariant::Double,             1.12345),
-        FieldDef("double", QVariant::Double,           1.23456789),
-        FieldDef("float", QVariant::Double,            1.23456789),
-        FieldDef("decimal(10,9)", QVariant::Double,    1.234567891),
-        FieldDef("numeric(10,9)", QVariant::Double,    1.234567891),
-        FieldDef("date", QVariant::Date,               QDate::currentDate()),
-        FieldDef("time", QVariant::Time,               QTime(1, 2, 3)),
-        FieldDef("timestamp", QVariant::DateTime,      QDateTime::currentDateTime()),
-//         FieldDef("graphic(20)", QVariant::String,       QString("Blah4")),
-//         FieldDef("vargraphic(20)", QVariant::String,    QString("Blah5")),
-//         FieldDef("long vargraphic", QVariant::String,   QString("Blah6")),
-        //X FieldDef("datalink", QVariant::String,          QString("DLVALUE('Blah10')")),
+//X     FieldDef("boolean" , QMetaType::Bool,           QVariant(true, 1)),
+        FieldDef("smallint", QMetaType::Int,            32767),
+        FieldDef("integer", QMetaType::Int,             2147483647),
+        FieldDef("bigint", QMetaType::LongLong,         Q_INT64_C(9223372036854775807)),
+        FieldDef("real", QMetaType::Double,             1.12345),
+        FieldDef("double", QMetaType::Double,           1.23456789),
+        FieldDef("float", QMetaType::Double,            1.23456789),
+        FieldDef("decimal(10,9)", QMetaType::Double,    1.234567891),
+        FieldDef("numeric(10,9)", QMetaType::Double,    1.234567891),
+        FieldDef("date", QMetaType::QDate,               QDate::currentDate()),
+        FieldDef("time", QMetaType::QTime,               QTime(1, 2, 3)),
+        FieldDef("timestamp", QMetaType::QDateTime,      QDateTime::currentDateTime()),
+//         FieldDef("graphic(20)", QMetaType::QString,       QString("Blah4")),
+//         FieldDef("vargraphic(20)", QMetaType::QString,    QString("Blah5")),
+//         FieldDef("long vargraphic", QMetaType::QString,   QString("Blah6")),
+        //X FieldDef("datalink", QMetaType::QString,          QString("DLVALUE('Blah10')")),
         FieldDef()
     };
 
@@ -991,16 +991,16 @@ void tst_QSqlDatabase::recordIBase()
     CHECK_DATABASE(db);
 
     static const FieldDef fieldDefs[] = {
-        FieldDef("char(20)", QVariant::String, QString("Blah1"), false),
-        FieldDef("varchar(20)", QVariant::String, QString("Blah2")),
-        FieldDef("smallint", QVariant::Int, 32767),
-        FieldDef("float", QVariant::Double, 1.2345),
-        FieldDef("double precision", QVariant::Double, 1.2345678),
-        FieldDef("timestamp", QVariant::DateTime, QDateTime::currentDateTime()),
-        FieldDef("time", QVariant::Time, QTime::currentTime()),
-        FieldDef("decimal(18)", QVariant::LongLong, Q_INT64_C(9223372036854775807)),
-        FieldDef("numeric(5,2)", QVariant::Double, 123.45),
-        FieldDef("boolean", QVariant::Bool, true),
+        FieldDef("char(20)", QMetaType::QString, QString("Blah1"), false),
+        FieldDef("varchar(20)", QMetaType::QString, QString("Blah2")),
+        FieldDef("smallint", QMetaType::Int, 32767),
+        FieldDef("float", QMetaType::Double, 1.2345),
+        FieldDef("double precision", QMetaType::Double, 1.2345678),
+        FieldDef("timestamp", QMetaType::QDateTime, QDateTime::currentDateTime()),
+        FieldDef("time", QMetaType::QTime, QTime::currentTime()),
+        FieldDef("decimal(18)", QMetaType::LongLong, Q_INT64_C(9223372036854775807)),
+        FieldDef("numeric(5,2)", QMetaType::Double, 123.45),
+        FieldDef("boolean", QMetaType::Bool, true),
 
         FieldDef()
     };
@@ -1019,14 +1019,14 @@ void tst_QSqlDatabase::recordSQLite()
 
     static const FieldDef fieldDefs[] = {
         // The affinity of these fields are TEXT so SQLite should give us strings, not ints or doubles.
-        FieldDef("char(20)", QVariant::String,          QString("123")),
-        FieldDef("varchar(20)", QVariant::String,       QString("123.4")),
-        FieldDef("clob", QVariant::String,              QString("123.45")),
-        FieldDef("text", QVariant::String,              QString("123.456")),
+        FieldDef("char(20)", QMetaType::QString,          QString("123")),
+        FieldDef("varchar(20)", QMetaType::QString,       QString("123.4")),
+        FieldDef("clob", QMetaType::QString,              QString("123.45")),
+        FieldDef("text", QMetaType::QString,              QString("123.456")),
 
-        FieldDef("integer", QVariant::Int,              QVariant(13)),
-        FieldDef("int", QVariant::Int,                  QVariant(12)),
-        FieldDef("real", QVariant::Double,              QVariant(1.234567890123456)),
+        FieldDef("integer", QMetaType::Int,              QVariant(13)),
+        FieldDef("int", QMetaType::Int,                  QVariant(12)),
+        FieldDef("real", QMetaType::Double,              QVariant(1.234567890123456)),
 
         FieldDef()
     };
@@ -1049,13 +1049,13 @@ void tst_QSqlDatabase::recordSQLServer()
 
     // ### TODO: Add the rest of the fields
     static const FieldDef fieldDefs[] = {
-        FieldDef("varchar(20)", QVariant::String, QString("Blah1")),
-        FieldDef("bigint", QVariant::LongLong, 12345),
-        FieldDef("int", QVariant::Int, 123456),
-        FieldDef("tinyint", QVariant::UInt, 255),
-        FieldDef("float", QVariant::Double, 1.12345),
-        FieldDef("numeric(5,2)", QVariant::Double, 123.45),
-        FieldDef("uniqueidentifier", QVariant::String,
+        FieldDef("varchar(20)", QMetaType::QString, QString("Blah1")),
+        FieldDef("bigint", QMetaType::LongLong, 12345),
+        FieldDef("int", QMetaType::Int, 123456),
+        FieldDef("tinyint", QMetaType::UInt, 255),
+        FieldDef("float", QMetaType::Double, 1.12345),
+        FieldDef("numeric(5,2)", QMetaType::Double, 123.45),
+        FieldDef("uniqueidentifier", QMetaType::QString,
             QString("AA7DF450-F119-11CD-8465-00AA00425D90")),
 
         FieldDef()
@@ -1082,12 +1082,12 @@ void tst_QSqlDatabase::recordAccess()
 
     // ### TODO: Add the rest of the fields
     static const FieldDef fieldDefs[] = {
-    FieldDef("varchar(20)", QVariant::String, QString("Blah1")),
-    FieldDef("single", QVariant::Double, 1.12345),
-    FieldDef("double", QVariant::Double, 1.123456),
-    FieldDef("byte", QVariant::UInt, 255),
-    FieldDef("long", QVariant::Int, 2147483647),
-        FieldDef("memo", QVariant::String, memo),
+    FieldDef("varchar(20)", QMetaType::QString, QString("Blah1")),
+    FieldDef("single", QMetaType::Double, 1.12345),
+    FieldDef("double", QMetaType::Double, 1.123456),
+    FieldDef("byte", QMetaType::UInt, 255),
+    FieldDef("long", QMetaType::Int, 2147483647),
+        FieldDef("memo", QMetaType::QString, memo),
     FieldDef()
     };
 
diff --git a/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp b/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp
index 322c1b3b84..352687a369 100644
--- a/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp
+++ b/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp
@@ -534,7 +534,7 @@ void tst_QSqlQuery::oraRowId()
     QSqlQuery q( db );
     QVERIFY_SQL( q, exec( "select rowid from " + qtest ) );
     QVERIFY( q.next() );
-    QCOMPARE( q.value( 0 ).type(), QVariant::String );
+    QCOMPARE( q.value( 0 ).metaType().id(), QMetaType::QString );
     QVERIFY( !q.value( 0 ).toString().isEmpty() );
 
     QVERIFY_SQL( q, exec( "create table " + oraRowId + " (id char(1))" ) );
@@ -676,7 +676,7 @@ void tst_QSqlQuery::oraOutValues()
     QCOMPARE( q.boundValue( 0 ).toInt(), 42 );
 
     // bind a null value, make sure the OCI driver resets the null flag
-    q.addBindValue( QVariant( QVariant::Int ), QSql::Out );
+    q.addBindValue( QVariant(QMetaType(QMetaType::Int)), QSql::Out );
     QVERIFY_SQL( q, exec() );
     QCOMPARE( q.boundValue( 0 ).toInt(), 42 );
     QVERIFY( !q.boundValue( 0 ).isNull() );
@@ -766,7 +766,7 @@ void tst_QSqlQuery::oraOutValues()
     QVERIFY(q.prepare("call " + tst_outValues + "(?, ?)"));
     const QDateTime dt = QDateTime::currentDateTime();
     q.addBindValue(dt, QSql::In);
-    q.addBindValue(QVariant(QVariant::DateTime), QSql::Out);
+    q.addBindValue(QVariant(QMetaType(QMetaType::QDateTime)), QSql::Out);
     QVERIFY_SQL(q, exec());
     QCOMPARE(q.boundValue(1).toDateTime(), dt);
 }
@@ -2497,15 +2497,15 @@ void tst_QSqlQuery::batchExec()
                                        "dtstamp ") + timeStampString +
                                        QStringLiteral(", extraId int, extraName varchar(20))")));
 
-    const QVariantList intCol = { 1, 2, QVariant(QVariant::Int) };
+    const QVariantList intCol = { 1, 2, QVariant(QMetaType(QMetaType::Int)) };
     const QVariantList charCol = { QStringLiteral("harald"), QStringLiteral("boris"),
-                                   QVariant(QVariant::String) };
+                                   QVariant(QMetaType(QMetaType::QString)) };
     const QDateTime currentDateTime = QDateTime(QDateTime::currentDateTime());
     const QVariantList dateCol = { currentDateTime.date(), currentDateTime.date().addDays(-1),
-                                   QVariant(QVariant::Date) };
-    const QVariantList numCol = { 2.3, 3.4, QVariant(QVariant::Double) };
+                                   QVariant(QMetaType(QMetaType::QDate)) };
+    const QVariantList numCol = { 2.3, 3.4, QVariant(QMetaType(QMetaType::Double)) };
     const QVariantList timeStampCol = { currentDateTime, currentDateTime.addDays(-1),
-                                        QVariant(QVariant::DateTime) };
+                                        QVariant(QMetaType(QMetaType::QDateTime)) };
 
     // Test with positional placeholders
     QVERIFY_SQL(q, prepare(QStringLiteral("insert into ") + tableName +
@@ -2720,18 +2720,18 @@ void tst_QSqlQuery::record_sqlite()
     QSqlRecord rec = db.record(qTableName("record_sqlite", __FILE__, db));
 
     QCOMPARE( rec.count(), 3 );
-    QCOMPARE( rec.field( 0 ).metaType().id(), QVariant::Int );
-    QCOMPARE( rec.field( 1 ).metaType().id(), QVariant::String );
-    QCOMPARE( rec.field( 2 ).metaType().id(), QVariant::Int );
+    QCOMPARE( rec.field( 0 ).metaType().id(), QMetaType::Int );
+    QCOMPARE( rec.field( 1 ).metaType().id(), QMetaType::QString );
+    QCOMPARE( rec.field( 2 ).metaType().id(), QMetaType::Int );
 
     /* important - select from an empty table */
     QVERIFY_SQL(q, exec("select id, name, title from " + qTableName("record_sqlite", __FILE__, db)));
 
     rec = q.record();
     QCOMPARE( rec.count(), 3 );
-    QCOMPARE( rec.field( 0 ).metaType().id(), QVariant::Int );
-    QCOMPARE( rec.field( 1 ).metaType().id(), QVariant::String );
-    QCOMPARE( rec.field( 2 ).metaType().id(), QVariant::Int );
+    QCOMPARE( rec.field( 0 ).metaType().id(), QMetaType::Int );
+    QCOMPARE( rec.field( 1 ).metaType().id(), QMetaType::QString );
+    QCOMPARE( rec.field( 2 ).metaType().id(), QMetaType::Int );
 }
 
 void tst_QSqlQuery::oraLong()
@@ -3118,7 +3118,7 @@ void tst_QSqlQuery::nextResult()
 
     QCOMPARE( q.record().field( 0 ).name().toUpper(), QString( "ID" ) );
 
-    QCOMPARE( q.record().field( 0 ).metaType().id(), QVariant::Int );
+    QCOMPARE( q.record().field( 0 ).metaType().id(), QMetaType::Int );
 
     QVERIFY( q.nextResult() );          // Discards first result set and move to the next
 
@@ -3126,10 +3126,10 @@ void tst_QSqlQuery::nextResult()
 
     QCOMPARE( q.record().field( 0 ).name().toUpper(), QString( "TEXT" ) );
 
-    QCOMPARE( q.record().field( 0 ).metaType().id(), QVariant::String );
+    QCOMPARE( q.record().field( 0 ).metaType().id(), QMetaType::QString );
 
     QCOMPARE( q.record().field( 1 ).name().toUpper(), QString( "NUM" ) );
-    QCOMPARE(q.record().field(1).metaType().id(), QVariant::Double);
+    QCOMPARE(q.record().field(1).metaType().id(), QMetaType::Double);
 
     QVERIFY( q.next() );                    // Move to first row of the second result set
 
@@ -3946,14 +3946,14 @@ void tst_QSqlQuery::QTBUG_23895()
     QVERIFY_SQL(q, exec(sql));
     QVERIFY_SQL(q, next());
 
-    QCOMPARE(q.record().field(0).metaType().id(), QVariant::Int);
-    QCOMPARE(q.value(0).metaType().id(), QVariant::LongLong);
+    QCOMPARE(q.record().field(0).metaType().id(), QMetaType::Int);
+    QCOMPARE(q.value(0).metaType().id(), QMetaType::LongLong);
     QCOMPARE(q.value(0).toInt(), 1);
-    QCOMPARE(q.record().field(1).metaType().id(), QVariant::Bool);
-    QCOMPARE(q.value(1).metaType().id(), QVariant::LongLong);
+    QCOMPARE(q.record().field(1).metaType().id(), QMetaType::Bool);
+    QCOMPARE(q.value(1).metaType().id(), QMetaType::LongLong);
     QCOMPARE(q.value(1).toBool(), true);
-    QCOMPARE(q.record().field(2).metaType().id(), QVariant::Bool);
-    QCOMPARE(q.value(2).metaType().id(), QVariant::LongLong);
+    QCOMPARE(q.record().field(2).metaType().id(), QMetaType::Bool);
+    QCOMPARE(q.value(2).metaType().id(), QMetaType::LongLong);
     QCOMPARE(q.value(2).toBool(), false);
 
     q.prepare("insert into " + tableName + "(id, val1, val2) values(?, ?, ?);");
@@ -4002,14 +4002,14 @@ void tst_QSqlQuery::QTBUG_14904()
     QVERIFY_SQL(q, next());
 
     QCOMPARE(q.record().indexOf("value1"), 0);
-    QCOMPARE(q.record().field(0).metaType().id(), QVariant::Bool);
+    QCOMPARE(q.record().field(0).metaType().id(), QMetaType::Bool);
     QCOMPARE(q.value(0).toBool(), true);
 
     sql="select val1 AS 'value.one' from " + tableName;
     QVERIFY_SQL(q, exec(sql));
     QVERIFY_SQL(q, next());
     QCOMPARE(q.record().indexOf("value.one"), 0);  // was -1 before bug fix
-    QCOMPARE(q.record().field(0).metaType().id(), QVariant::Bool);
+    QCOMPARE(q.record().field(0).metaType().id(), QMetaType::Bool);
     QCOMPARE(q.value(0).toBool(), true);
 }
 
@@ -4135,7 +4135,7 @@ void tst_QSqlQuery::gisPointDatatype()
     QVERIFY(sqlQuery.exec(sqlCommand));
     sqlCommand = QStringLiteral("SELECT * FROM %1;").arg(tableName);
     QVERIFY(sqlQuery.exec(sqlCommand));
-    QCOMPARE(sqlQuery.record().field(0).metaType().id(), QVariant::Type::ByteArray);
+    QCOMPARE(sqlQuery.record().field(0).metaType().id(), QMetaType::QByteArray);
     QVERIFY(sqlQuery.next());
 }
 
@@ -4281,7 +4281,7 @@ void tst_QSqlQuery::sqlite_real()
     QVERIFY_SQL(q, exec("SELECT realVal FROM " + tableName));
     QVERIFY(q.next());
     QCOMPARE(q.value(0).toDouble(), 2.3);
-    QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
+    QCOMPARE(q.record().field(0).metaType().id(), QMetaType::Double);
 
     q.prepare("INSERT INTO " + tableName + " (id, realVal) VALUES (?, ?)");
     QVariant var((double)5.6);
@@ -4299,18 +4299,18 @@ void tst_QSqlQuery::aggregateFunctionTypes()
     QFETCH(QString, dbName);
     QSqlDatabase db = QSqlDatabase::database(dbName);
     CHECK_DATABASE(db);
-    QVariant::Type intType = QVariant::Int;
-    QVariant::Type sumType = intType;
-    QVariant::Type countType = intType;
+    int intType = QMetaType::Int;
+    int sumType = intType;
+    int countType = intType;
     // QPSQL uses LongLong for manipulation of integers
     const QSqlDriver::DbmsType dbType = tst_Databases::getDatabaseType(db);
     if (dbType == QSqlDriver::PostgreSQL || dbType == QSqlDriver::Interbase) {
-        sumType = countType = QVariant::LongLong;
+        sumType = countType = QMetaType::LongLong;
     } else if (dbType == QSqlDriver::Oracle) {
-        intType = sumType = countType = QVariant::Double;
+        intType = sumType = countType = QMetaType::Double;
     } else if (dbType == QSqlDriver::MySqlServer) {
-        sumType = QVariant::Double;
-        countType = QVariant::LongLong;
+        sumType = QMetaType::Double;
+        countType = QMetaType::LongLong;
     }
     {
         const QString tableName(qTableName("numericFunctionsWithIntValues", __FILE__, db));
@@ -4323,7 +4323,7 @@ void tst_QSqlQuery::aggregateFunctionTypes()
         QVERIFY_SQL(q, exec("SELECT SUM(id) FROM " + tableName));
         QVERIFY(q.next());
         if (dbType == QSqlDriver::SQLite)
-            QCOMPARE(q.record().field(0).metaType().id(), QVariant::Invalid);
+            QCOMPARE(q.record().field(0).metaType().id(), QMetaType::UnknownType);
         else
             QCOMPARE(q.record().field(0).metaType().id(), sumType);
 
@@ -4340,10 +4340,10 @@ void tst_QSqlQuery::aggregateFunctionTypes()
         if (dbType == QSqlDriver::SQLite || dbType == QSqlDriver::PostgreSQL || dbType == QSqlDriver::MySqlServer
             || dbType == QSqlDriver::Oracle) {
             QCOMPARE(q.value(0).toDouble(), 1.5);
-            QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
+            QCOMPARE(q.record().field(0).metaType().id(), QMetaType::Double);
         } else {
             QCOMPARE(q.value(0).toInt(), 1);
-            QCOMPARE(q.record().field(0).metaType().id(), (dbType == QSqlDriver::Interbase ? QVariant::LongLong : QVariant::Int));
+            QCOMPARE(q.record().field(0).metaType().id(), (dbType == QSqlDriver::Interbase ? QMetaType::LongLong : QMetaType::Int));
         }
 
         QVERIFY_SQL(q, exec("SELECT COUNT(id) FROM " + tableName));
@@ -4372,9 +4372,9 @@ void tst_QSqlQuery::aggregateFunctionTypes()
         QVERIFY_SQL(q, exec("SELECT SUM(id) FROM " + tableName));
         QVERIFY(q.next());
         if (dbType == QSqlDriver::SQLite)
-            QCOMPARE(q.record().field(0).metaType().id(), QVariant::Invalid);
+            QCOMPARE(q.record().field(0).metaType().id(), QMetaType::UnknownType);
         else
-            QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
+            QCOMPARE(q.record().field(0).metaType().id(), QMetaType::Double);
 
         QVERIFY_SQL(q, exec("INSERT INTO " + tableName + " (id) VALUES (1.5)"));
         QVERIFY_SQL(q, exec("INSERT INTO " + tableName + " (id) VALUES (2.5)"));
@@ -4382,12 +4382,12 @@ void tst_QSqlQuery::aggregateFunctionTypes()
         QVERIFY_SQL(q, exec("SELECT SUM(id) FROM " + tableName));
         QVERIFY(q.next());
         QCOMPARE(q.value(0).toDouble(), 4.0);
-        QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
+        QCOMPARE(q.record().field(0).metaType().id(), QMetaType::Double);
 
         QVERIFY_SQL(q, exec("SELECT AVG(id) FROM " + tableName));
         QVERIFY(q.next());
         QCOMPARE(q.value(0).toDouble(), 2.0);
-        QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
+        QCOMPARE(q.record().field(0).metaType().id(), QMetaType::Double);
 
         QVERIFY_SQL(q, exec("SELECT COUNT(id) FROM " + tableName));
         QVERIFY(q.next());
@@ -4397,12 +4397,12 @@ void tst_QSqlQuery::aggregateFunctionTypes()
         QVERIFY_SQL(q, exec("SELECT MIN(id) FROM " + tableName));
         QVERIFY(q.next());
         QCOMPARE(q.value(0).toDouble(), 1.5);
-        QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
+        QCOMPARE(q.record().field(0).metaType().id(), QMetaType::Double);
 
         QVERIFY_SQL(q, exec("SELECT MAX(id) FROM " + tableName));
         QVERIFY(q.next());
         QCOMPARE(q.value(0).toDouble(), 2.5);
-        QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
+        QCOMPARE(q.record().field(0).metaType().id(), QMetaType::Double);
 
         QString field = "id";
 
@@ -4414,7 +4414,7 @@ void tst_QSqlQuery::aggregateFunctionTypes()
         QVERIFY_SQL(q, exec("SELECT ROUND(" + field + ", 1) FROM " + tableName + " WHERE id=1.5"));
         QVERIFY(q.next());
         QCOMPARE(q.value(0).toDouble(), 1.5);
-        QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
+        QCOMPARE(q.record().field(0).metaType().id(), QMetaType::Double);
 
         QVERIFY_SQL(q, exec("SELECT ROUND(" + field + ", 0) FROM " + tableName + " WHERE id=2.5"));
         QVERIFY(q.next());
@@ -4422,7 +4422,7 @@ void tst_QSqlQuery::aggregateFunctionTypes()
             QCOMPARE(q.value(0).toDouble(), 2.0);
         else
             QCOMPARE(q.value(0).toDouble(), 3.0);
-        QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
+        QCOMPARE(q.record().field(0).metaType().id(), QMetaType::Double);
     }
     {
         const QString tableName(qTableName("stringFunctions", __FILE__, db));
@@ -4434,9 +4434,9 @@ void tst_QSqlQuery::aggregateFunctionTypes()
         QVERIFY_SQL(q, exec("SELECT MAX(txt) FROM " + tableName));
         QVERIFY(q.next());
         if (dbType == QSqlDriver::SQLite)
-            QCOMPARE(q.record().field(0).metaType().id(), QVariant::Invalid);
+            QCOMPARE(q.record().field(0).metaType().id(), QMetaType::UnknownType);
         else
-            QCOMPARE(q.record().field(0).metaType().id(), QVariant::String);
+            QCOMPARE(q.record().field(0).metaType().id(), QMetaType::QString);
 
         QVERIFY_SQL(q, exec("INSERT INTO " + tableName + " (id, txt) VALUES (1, 'lower')"));
         QVERIFY_SQL(q, exec("INSERT INTO " + tableName + " (id, txt) VALUES (2, 'upper')"));
@@ -4444,7 +4444,7 @@ void tst_QSqlQuery::aggregateFunctionTypes()
         QVERIFY_SQL(q, exec("SELECT MAX(txt) FROM " + tableName));
         QVERIFY(q.next());
         QCOMPARE(q.value(0).toString(), QLatin1String("upper"));
-        QCOMPARE(q.record().field(0).metaType().id(), QVariant::String);
+        QCOMPARE(q.record().field(0).metaType().id(), QMetaType::QString);
     }
 }
 
diff --git a/tests/auto/sql/kernel/qsqlrecord/tst_qsqlrecord.cpp b/tests/auto/sql/kernel/qsqlrecord/tst_qsqlrecord.cpp
index 83a61b91d7..ed259f3cde 100644
--- a/tests/auto/sql/kernel/qsqlrecord/tst_qsqlrecord.cpp
+++ b/tests/auto/sql/kernel/qsqlrecord/tst_qsqlrecord.cpp
@@ -111,10 +111,10 @@ void tst_QSqlRecord::createTestRecord()
 {
     delete rec;
     rec = new QSqlRecord();
-    fields[0] = new QSqlField(QStringLiteral("string"), QVariant::String, QStringLiteral("stringtable"));
-    fields[1] = new QSqlField(QStringLiteral("int"), QVariant::Int, QStringLiteral("inttable"));
-    fields[2] = new QSqlField(QStringLiteral("double"), QVariant::Double, QStringLiteral("doubletable"));
-    fields[3] = new QSqlField(QStringLiteral("bool"), QVariant::Bool);
+    fields[0] = new QSqlField(QStringLiteral("string"), QMetaType(QMetaType::QString), QStringLiteral("stringtable"));
+    fields[1] = new QSqlField(QStringLiteral("int"), QMetaType(QMetaType::Int), QStringLiteral("inttable"));
+    fields[2] = new QSqlField(QStringLiteral("double"), QMetaType(QMetaType::Double), QStringLiteral("doubletable"));
+    fields[3] = new QSqlField(QStringLiteral("bool"), QMetaType(QMetaType::Bool));
     for ( int i = 0; i < NUM_FIELDS; ++i )
         rec->append( *(fields[ i ] ) );
 }
@@ -124,19 +124,19 @@ void tst_QSqlRecord::append()
 {
     delete rec;
     rec = new QSqlRecord();
-    rec->append(QSqlField("string", QVariant::String, QStringLiteral("stringtable")));
+    rec->append(QSqlField("string", QMetaType(QMetaType::QString), QStringLiteral("stringtable")));
     QCOMPARE( rec->field( 0 ).name(), (QString) "string" );
     QCOMPARE(rec->field(0).tableName(), QStringLiteral("stringtable"));
     QVERIFY( !rec->isEmpty() );
     QCOMPARE( (int)rec->count(), 1 );
-    rec->append(QSqlField("int", QVariant::Int, QStringLiteral("inttable")));
+    rec->append(QSqlField("int", QMetaType(QMetaType::Int), QStringLiteral("inttable")));
     QCOMPARE( rec->field( 1 ).name(), (QString) "int" );
     QCOMPARE(rec->field(1).tableName(), QStringLiteral("inttable"));
     QCOMPARE( (int)rec->count(), 2 );
-    rec->append( QSqlField( "double", QVariant::Double ) );
+    rec->append( QSqlField( "double", QMetaType(QMetaType::Double) ) );
     QCOMPARE( rec->field( 2 ).name(), (QString) "double" );
     QCOMPARE( (int)rec->count(), 3 );
-    rec->append( QSqlField( "bool", QVariant::Bool ) );
+    rec->append( QSqlField( "bool", QMetaType(QMetaType::Bool) ) );
     QCOMPARE( rec->field( 3 ).name(), (QString) "bool" );
     QCOMPARE( (int)rec->count(), 4 );
     QCOMPARE( rec->indexOf( "string" ), 0 );
@@ -186,17 +186,17 @@ void tst_QSqlRecord::clearValues()
         delete rec;
 
     rec = new QSqlRecord();
-    rec->append( QSqlField( "string", QVariant::String ) );
+    rec->append( QSqlField( "string", QMetaType(QMetaType::QString) ) );
     QCOMPARE( rec->field(0).name(), (QString) "string" );
     QVERIFY( !rec->isEmpty() );
     QCOMPARE( (int)rec->count(), 1 );
-    rec->append( QSqlField( "int", QVariant::Int ) );
+    rec->append( QSqlField( "int", QMetaType(QMetaType::Int) ) );
     QCOMPARE( rec->field(1).name(), (QString) "int" );
     QCOMPARE( (int)rec->count(), 2 );
-    rec->append( QSqlField( "double", QVariant::Double ) );
+    rec->append( QSqlField( "double", QMetaType(QMetaType::Double) ) );
     QCOMPARE( rec->field(2).name(), (QString) "double" );
     QCOMPARE( (int)rec->count(), 3 );
-    rec->append( QSqlField( "bool", QVariant::Bool ) );
+    rec->append( QSqlField( "bool", QMetaType(QMetaType::Bool) ) );
     QCOMPARE( rec->field(3).name(), (QString) "bool" );
     QCOMPARE( (int)rec->count(), 4 );
     QCOMPARE( rec->indexOf( "string" ), 0 );
@@ -268,29 +268,29 @@ void tst_QSqlRecord::insert()
     QSqlRecord iRec;
     int i;
     for ( i = 0; i <= 100; ++i ) {
-        iRec.insert( i, QSqlField( QString::number( i ), QVariant::Int ) );
+        iRec.insert( i, QSqlField( QString::number( i ), QMetaType(QMetaType::Int) ) );
     }
     for ( i = 0; i <= 100; ++i ) {
         QCOMPARE( iRec.fieldName( i ), QString::number( i ) );
     }
-//    iRec.insert( 505, QSqlField( "Harry", QVariant::Double ) );
+//    iRec.insert( 505, QSqlField( "Harry", QMetaType(QMetaType::Double) ) );
 //    QCOMPARE( iRec.fieldName( 505 ), (QString)"Harry" );
-//    QVERIFY( iRec.field( 505 ).type() == QVariant::Double );
+//    QVERIFY( iRec.field( 505 ).type() == QMetaType(QMetaType::Double) );
 
-    iRec.insert( 42, QSqlField( "Everything", QVariant::String ) );
+    iRec.insert( 42, QSqlField( "Everything", QMetaType(QMetaType::QString) ) );
     QCOMPARE( iRec.fieldName( 42 ), (QString)"Everything" );
-    QVERIFY( iRec.field( 42 ).type() == QVariant::String );
+    QVERIFY( iRec.field( 42 ).metaType() == QMetaType(QMetaType::QString) );
 }
 
 void tst_QSqlRecord::isEmpty()
 {
     QSqlRecord eRec;
     QVERIFY( eRec.isEmpty() );
-    eRec.append( QSqlField( "Harry", QVariant::String ) );
+    eRec.append( QSqlField( "Harry", QMetaType(QMetaType::QString) ) );
     QVERIFY( !eRec.isEmpty() );
     eRec.remove( 0 );
     QVERIFY( eRec.isEmpty() );
-    eRec.insert( 0, QSqlField( "Harry", QVariant::String ) );
+    eRec.insert( 0, QSqlField( "Harry", QMetaType(QMetaType::QString) ) );
     QVERIFY( !eRec.isEmpty() );
     eRec.clear();
     QVERIFY( eRec.isEmpty() );
@@ -383,7 +383,7 @@ void tst_QSqlRecord::operator_Assign()
     buf3.remove( NUM_FIELDS - 1 );
     QSqlRecord buf5 = buf3;
     for ( i = 0; i < NUM_FIELDS - 1; ++i ) {
-        QSqlField fi(fields[i]->name(), fields[i]->type(), fields[i]->tableName());
+        QSqlField fi(fields[i]->name(), fields[i]->metaType(), fields[i]->tableName());
         fi.clear();
         QVERIFY( buf5.field( i ) == fi );
         QVERIFY( buf5.isGenerated( i ) );
@@ -413,7 +413,7 @@ void tst_QSqlRecord::remove()
     }
     rec->remove( NUM_FIELDS * 2 ); // nothing should happen
     for ( i = 0; i < NUM_FIELDS; ++i ) {
-        rec->insert( i, QSqlField( fields[ i ]->name(), fields[ i ]->type() ) );
+        rec->insert( i, QSqlField( fields[ i ]->name(), fields[ i ]->metaType() ) );
         QVERIFY( rec->isGenerated( i ) );
     }
 }
@@ -439,17 +439,17 @@ void tst_QSqlRecord::setValue()
 
     delete rec;
     rec = new QSqlRecord();
-    rec->append( QSqlField( "string", QVariant::String ) );
+    rec->append( QSqlField( "string", QMetaType(QMetaType::QString) ) );
     QCOMPARE( rec->field( 0 ).name(), (QString) "string" );
     QVERIFY( !rec->isEmpty() );
     QCOMPARE( (int)rec->count(), 1 );
-    rec->append( QSqlField( "int", QVariant::Int ) );
+    rec->append( QSqlField( "int", QMetaType(QMetaType::Int) ) );
     QCOMPARE( rec->field( 1 ).name(), (QString) "int" );
     QCOMPARE( (int)rec->count(), 2 );
-    rec->append( QSqlField( "double", QVariant::Double ) );
+    rec->append( QSqlField( "double", QMetaType(QMetaType::Double) ) );
     QCOMPARE( rec->field( 2 ).name(), (QString) "double" );
     QCOMPARE( (int)rec->count(), 3 );
-    rec->append( QSqlField( "bool", QVariant::Bool ) );
+    rec->append( QSqlField( "bool", QMetaType(QMetaType::Bool) ) );
     QCOMPARE( rec->field( 3 ).name(), (QString) "bool" );
     QCOMPARE( (int)rec->count(), 4 );
     QCOMPARE( rec->indexOf( "string" ), 0 );
@@ -498,7 +498,7 @@ void tst_QSqlRecord::value()
 {
     // this test is already covered in setValue()
     QSqlRecord rec2;
-    rec2.append( QSqlField( "string", QVariant::String ) );
+    rec2.append( QSqlField( "string", QMetaType(QMetaType::QString) ) );
     rec2.setValue( "string", "Harry" );
     QCOMPARE(rec2.value("string").toString(), QLatin1String("Harry"));
 }
diff --git a/tests/auto/sql/kernel/qsqlresult/testsqldriver.h b/tests/auto/sql/kernel/qsqlresult/testsqldriver.h
index b4fb65bf7d..d9c5a411ba 100644
--- a/tests/auto/sql/kernel/qsqlresult/testsqldriver.h
+++ b/tests/auto/sql/kernel/qsqlresult/testsqldriver.h
@@ -41,7 +41,7 @@ public:
         : QSqlResult(driver) {}
     ~TestSqlDriverResult() {}
 
-    bool savePrepare(const QString& sqlquery)
+    bool savePrepare(const QString& sqlquery) override
     {
         return QSqlResult::savePrepare(sqlquery);
     }
@@ -49,15 +49,15 @@ public:
     QList<QVariant> boundValues() const { return QSqlResult::boundValues(); }
 
 protected:
-    QVariant data(int /* index */) { return QVariant(); }
-    bool isNull(int /* index */) { return false; }
-    bool reset(const QString & /* query */) { return false; }
-    bool fetch(int /* index */) { return false; }
-    bool fetchFirst() { return false; }
-    bool fetchLast() { return false; }
-    int size() { return 0; }
-    int numRowsAffected() { return 0; }
-    QSqlRecord record() const { return QSqlRecord(); }
+    QVariant data(int /* index */) override { return QVariant(); }
+    bool isNull(int /* index */) override { return false; }
+    bool reset(const QString & /* query */) override { return false; }
+    bool fetch(int /* index */) override { return false; }
+    bool fetchFirst() override { return false; }
+    bool fetchLast() override { return false; }
+    int size() override { return 0; }
+    int numRowsAffected() override { return 0; }
+    QSqlRecord record() const override { return QSqlRecord(); }
 };
 
 class TestSqlDriver : public QSqlDriver
@@ -68,7 +68,7 @@ public:
     TestSqlDriver() {}
     ~TestSqlDriver() {}
 
-    bool hasFeature(DriverFeature f) const {
+    bool hasFeature(DriverFeature f) const override {
         switch (f) {
         case QSqlDriver::PreparedQueries:
         case QSqlDriver::NamedPlaceholders:
@@ -80,11 +80,11 @@ public:
     }
     bool open(const QString & /* db */, const QString & /* user */,
               const QString & /* password */, const QString & /* host */,
-              int /* port */, const QString & /* options */)
+              int /* port */, const QString & /* options */) override
         { return false; }
-    void close() {}
+    void close() override {}
 
-    QSqlResult *createResult() const { return new TestSqlDriverResult(this); }
+    QSqlResult *createResult() const override { return new TestSqlDriverResult(this); }
 };
 
 #endif // TESTSQLDRIVER_H
diff --git a/tests/auto/sql/models/qsqltablemodel/tst_qsqltablemodel.cpp b/tests/auto/sql/models/qsqltablemodel/tst_qsqltablemodel.cpp
index 53f1b195a9..2ceba66bf8 100644
--- a/tests/auto/sql/models/qsqltablemodel/tst_qsqltablemodel.cpp
+++ b/tests/auto/sql/models/qsqltablemodel/tst_qsqltablemodel.cpp
@@ -402,7 +402,7 @@ class SelectRowOverrideTestModel: public QSqlTableModel
     Q_OBJECT
 public:
     SelectRowOverrideTestModel(QObject *parent, QSqlDatabase db):QSqlTableModel(parent, db) { }
-    bool selectRow(int row)
+    bool selectRow(int row) override
     {
         Q_UNUSED(row);
         return select();
@@ -551,9 +551,9 @@ void tst_QSqlTableModel::setData()
 
     // change 0 to NULL
     idx = model.index(0, 0);
-    QVERIFY_SQL(model, setData(idx, QVariant(QVariant::Int)));
+    QVERIFY_SQL(model, setData(idx, QVariant(QMetaType(QMetaType::Int))));
     val = model.data(idx);
-    QCOMPARE(val, QVariant(QVariant::Int));
+    QCOMPARE(val, QVariant(QMetaType(QMetaType::Int)));
     QVERIFY(val.isNull());
     QVERIFY_SQL(model, isDirty(idx));
     QVERIFY_SQL(model, submitAll());
@@ -580,13 +580,13 @@ void tst_QSqlTableModel::setData()
     // initial state
     idx = model.index(0, 0);
     QSqlRecord rec = model.record(0);
-    QCOMPARE(rec.value(0), QVariant(QVariant::Int));
+    QCOMPARE(rec.value(0), QVariant(QMetaType(QMetaType::Int)));
     QVERIFY(rec.isNull(0));
     QVERIFY(!rec.isGenerated(0));
     // unchanged value, but causes column to be included in INSERT
-    QVERIFY_SQL(model, setData(idx, QVariant(QVariant::Int)));
+    QVERIFY_SQL(model, setData(idx, QVariant(QMetaType(QMetaType::Int))));
     rec = model.record(0);
-    QCOMPARE(rec.value(0), QVariant(QVariant::Int));
+    QCOMPARE(rec.value(0), QVariant(QMetaType(QMetaType::Int)));
     QVERIFY(rec.isNull(0));
     QVERIFY(rec.isGenerated(0));
     QVERIFY_SQL(model, submitAll());
@@ -657,7 +657,7 @@ class SetRecordReimplModel: public QSqlTableModel
     Q_OBJECT
 public:
     SetRecordReimplModel(QObject *parent, QSqlDatabase db):QSqlTableModel(parent, db) {}
-    bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole)
+    bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override
     {
         Q_UNUSED(value);
         return QSqlTableModel::setData(index, QString("Qt"), role);
@@ -693,7 +693,7 @@ class RecordReimplModel: public QSqlTableModel
     Q_OBJECT
 public:
     RecordReimplModel(QObject *parent, QSqlDatabase db):QSqlTableModel(parent, db) {}
-    QVariant data(const QModelIndex &index, int role = Qt::EditRole) const
+    QVariant data(const QModelIndex &index, int role = Qt::EditRole) const override
     {
         if (role == Qt::EditRole)
             return QString("Qt");
@@ -2139,7 +2139,7 @@ class SqlThread : public QThread
 {
 public:
     SqlThread() : QThread() {}
-    void run()
+    void run() override
     {
         QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE", "non-default-connection");
         QSqlTableModel stm(nullptr, db);