Deprecate QVariant::Type uses in QSqlField

Add metaType()/setMetaType() methods to be used instead
of the type() methods taking a QVariant::Type.

Change-Id: Ieaba35b73f8061cd83288dd6b50d58322db3c7ed
Reviewed-by: Maurice Kalinowski <maurice.kalinowski@qt.io>

6 files changed, 128 insertions, 128 deletions

diff --git a/tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp b/tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp
index f726139e08..7d75aec845 100644
--- a/tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp
+++ b/tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp
@@ -582,17 +582,17 @@ void tst_QSqlDatabase::whitespaceInIdentifiers()
         QCOMPARE(rec.count(), 1);
         QCOMPARE(rec.fieldName(0), QString("test test"));
         if (dbType == QSqlDriver::Oracle)
-            QCOMPARE(rec.field(0).type(), QVariant::Double);
+            QCOMPARE(rec.field(0).metaType(), QMetaType(QMetaType::Double));
         else
-            QCOMPARE(rec.field(0).type(), QVariant::Int);
+            QCOMPARE(rec.field(0).metaType(), QMetaType(QMetaType::Int));
 
         QSqlIndex idx = db.primaryIndex(tableName);
         QCOMPARE(idx.count(), 1);
         QCOMPARE(idx.fieldName(0), QString("test test"));
         if (dbType == QSqlDriver::Oracle)
-            QCOMPARE(idx.field(0).type(), QVariant::Double);
+            QCOMPARE(idx.field(0).metaType(), QMetaType(QMetaType::Double));
         else
-            QCOMPARE(idx.field(0).type(), QVariant::Int);
+            QCOMPARE(idx.field(0).metaType(), QMetaType(QMetaType::Int));
     } else {
         QSKIP("DBMS does not support whitespaces in identifiers");
     }
@@ -644,8 +644,8 @@ void tst_QSqlDatabase::record()
     CHECK_DATABASE(db);
 
     static const FieldDef fieldDefs[] = {
-        FieldDef("char(20)", QVariant::String,         QString("blah1"), false),
-        FieldDef("varchar(20)", QVariant::String,      QString("blah2"), false),
+        FieldDef("char(20)", QMetaType(QMetaType::String),         QString("blah1"), false),
+        FieldDef("varchar(20)", QMetaType(QMetaType::String),      QString("blah2"), false),
         FieldDef()
     };
 
@@ -663,10 +663,10 @@ 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).type() != fieldDefs[ i ].type) {
+        if (inf.field(i+1).metaType().id() != int(fieldDefs[ i ].type)) {
             QFAIL(qPrintable(QString(" Expected: '%1' Received: '%2' for field %3 in testRecord").arg(
-              QVariant::typeToName(fieldDefs[ i ].type)).arg(
-            QVariant::typeToName(inf.field(i+1).type())).arg(
+              QMetaType(fieldDefs[ i ].type).name()).arg(
+              inf.field(i+1).metaType().name()).arg(
               fieldDefs[ i ].fieldName())));
         }
         QVERIFY(!inf.field(i+1).isAutoValue());
@@ -681,7 +681,7 @@ void tst_QSqlDatabase::commonFieldTest(const FieldDef fieldDefs[], QSqlDatabase
     CHECK_DATABASE(db);
     const QStringList tableNames = { qTableName("qtestfields", __FILE__, db),
                                      qTableName("qtestfields", __FILE__, db, false) };
-    for (const QString table : tableNames) {
+    for (const QString &table : tableNames) {
         QSqlRecord rec = db.record(table);
         QCOMPARE(rec.count(), fieldCount + 1);
         testRecord(fieldDefs, rec, db);
@@ -1316,8 +1316,8 @@ void tst_QSqlDatabase::psql_escapedIdentifiers()
     QVERIFY(db.tables().contains(qTableName(bumpyCase, __FILE__, db, false) + '.' +
                                  qTableName("qtest", __FILE__, db, false), Qt::CaseSensitive));
 
-    QSqlField fld1(field1Name, QVariant::Int);
-    QSqlField fld2(field2Name, QVariant::String);
+    QSqlField fld1(field1Name, QMetaType(QMetaType::Int));
+    QSqlField fld2(field2Name, QMetaType(QMetaType::QString));
     QSqlRecord rec;
     rec.append(fld1);
     rec.append(fld2);
@@ -1330,7 +1330,7 @@ void tst_QSqlDatabase::psql_escapedIdentifiers()
     QCOMPARE(rec.count(), 2);
     QCOMPARE(rec.fieldName(0), field1Name);
     QCOMPARE(rec.fieldName(1), field2Name);
-    QCOMPARE(rec.field(0).type(), QVariant::Int);
+    QCOMPARE(rec.field(0).metaType(), QMetaType(QMetaType::Int));
 
     q.exec(QString("DROP SCHEMA %1 CASCADE").arg(schemaName));
 }
@@ -1433,14 +1433,14 @@ void tst_QSqlDatabase::precisionPolicy()
     QSqlDriver::DbmsType dbType = tst_Databases::getDatabaseType(db);
     if (dbType == QSqlDriver::SQLite)
         QEXPECT_FAIL("", "SQLite returns this value as determined by contents of the field, not the declaration", Continue);
-    QCOMPARE(q.value(0).type(), QVariant::String);
+    QCOMPARE(q.value(0).metaType(), QMetaType(QMetaType::QString));
 
     q.setNumericalPrecisionPolicy(QSql::LowPrecisionInt64);
     QVERIFY_SQL(q, exec(query));
     QVERIFY_SQL(q, next());
-    if(q.value(0).type() != QVariant::LongLong)
+    if(q.value(0).metaType() != QMetaType(QMetaType::LongLong))
         QEXPECT_FAIL("", "SQLite returns this value as determined by contents of the field, not the declaration", Continue);
-    QCOMPARE(q.value(0).type(), QVariant::LongLong);
+    QCOMPARE(q.value(0).metaType(), QMetaType(QMetaType::LongLong));
     QCOMPARE(q.value(0).toLongLong(), (qlonglong)123);
 
     q.setNumericalPrecisionPolicy(QSql::LowPrecisionInt32);
@@ -1448,7 +1448,7 @@ void tst_QSqlDatabase::precisionPolicy()
     QVERIFY_SQL(q, next());
     if (dbType == QSqlDriver::SQLite)
         QEXPECT_FAIL("", "SQLite returns this value as determined by contents of the field, not the declaration", Continue);
-    QCOMPARE(q.value(0).type(), QVariant::Int);
+    QCOMPARE(q.value(0).metaType(), QMetaType(QMetaType::Int));
     QCOMPARE(q.value(0).toInt(), 123);
 
     q.setNumericalPrecisionPolicy(QSql::LowPrecisionDouble);
@@ -1456,7 +1456,7 @@ void tst_QSqlDatabase::precisionPolicy()
     QVERIFY_SQL(q, next());
     if (dbType == QSqlDriver::SQLite)
         QEXPECT_FAIL("", "SQLite returns this value as determined by contents of the field, not the declaration", Continue);
-    QCOMPARE(q.value(0).type(), QVariant::Double);
+    QCOMPARE(q.value(0).metaType(), QMetaType(QMetaType::Double));
     QCOMPARE(q.value(0).toDouble(), (double)123);
 
     query = QString("SELECT num FROM %1 WHERE id = 2").arg(tableName);
@@ -1464,7 +1464,7 @@ void tst_QSqlDatabase::precisionPolicy()
     QVERIFY_SQL(q, next());
     if (dbType == QSqlDriver::SQLite)
         QEXPECT_FAIL("", "SQLite returns this value as determined by contents of the field, not the declaration", Continue);
-    QCOMPARE(q.value(0).type(), QVariant::Double);
+    QCOMPARE(q.value(0).metaType(), QMetaType(QMetaType::Double));
     QCOMPARE(q.value(0).toDouble(), QString("1850000000000.0001").toDouble());
 
     // Postgres returns invalid QVariants on overflow
@@ -1473,13 +1473,13 @@ void tst_QSqlDatabase::precisionPolicy()
     QVERIFY_SQL(q, next());
     if (dbType == QSqlDriver::SQLite)
         QEXPECT_FAIL("", "SQLite returns this value as determined by contents of the field, not the declaration", Continue);
-    QCOMPARE(q.value(0).type(), QVariant::String);
+    QCOMPARE(q.value(0).metaType(), QMetaType(QMetaType::QString));
 
     q.setNumericalPrecisionPolicy(QSql::LowPrecisionInt64);
     QEXPECT_FAIL("QOCI", "Oracle fails here, to retrieve next", Continue);
     QVERIFY_SQL(q, exec(query));
     QVERIFY_SQL(q, next());
-    QCOMPARE(q.value(0).type(), QVariant::LongLong);
+    QCOMPARE(q.value(0).metaType(), QMetaType(QMetaType::LongLong));
 
     QSql::NumericalPrecisionPolicy oldPrecision= db.numericalPrecisionPolicy();
     db.setNumericalPrecisionPolicy(QSql::LowPrecisionInt64);
@@ -1487,7 +1487,7 @@ void tst_QSqlDatabase::precisionPolicy()
     q2.exec(QString("SELECT num FROM %1 WHERE id = 2").arg(tableName));
     QVERIFY_SQL(q2, exec(query));
     QVERIFY_SQL(q2, next());
-    QCOMPARE(q2.value(0).type(), QVariant::LongLong);
+    QCOMPARE(q2.value(0).metaType(), QMetaType(QMetaType::LongLong));
     db.setNumericalPrecisionPolicy(oldPrecision);
 }
 
@@ -1634,11 +1634,11 @@ void tst_QSqlDatabase::ibase_numericFields()
         QCOMPARE(q.value(2).toString(), QString("%1").arg(num2));
         QCOMPARE(QString("%1").arg(q.value(3).toDouble()), QString("%1").arg(num3));
         QCOMPARE(QString("%1").arg(q.value(4).toDouble()), QString("%1").arg(num4));
-        QCOMPARE(q.value(0).type(), QVariant::Int);
-        QCOMPARE(q.value(1).type(), QVariant::Double);
-        QCOMPARE(q.value(2).type(), QVariant::Double);
-        QCOMPARE(q.value(3).type(), QVariant::Double);
-        QCOMPARE(q.value(4).type(), QVariant::Double);
+        QCOMPARE(q.value(0).metaType(), QMetaType(QMetaType::Int));
+        QCOMPARE(q.value(1).metaType(), QMetaType(QMetaType::Double));
+        QCOMPARE(q.value(2).metaType(), QMetaType(QMetaType::Double));
+        QCOMPARE(q.value(3).metaType(), QMetaType(QMetaType::Double));
+        QCOMPARE(q.value(4).metaType(), QMetaType(QMetaType::Double));
 
         QCOMPARE(q.record().field(1).length(), 2);
         QCOMPARE(q.record().field(1).precision(), 1);
@@ -1653,11 +1653,11 @@ void tst_QSqlDatabase::ibase_numericFields()
     }
 
     QSqlRecord r = db.record(tableName);
-    QCOMPARE(r.field(0).type(), QVariant::Int);
-    QCOMPARE(r.field(1).type(), QVariant::Double);
-    QCOMPARE(r.field(2).type(), QVariant::Double);
-    QCOMPARE(r.field(3).type(), QVariant::Double);
-    QCOMPARE(r.field(4).type(), QVariant::Double);
+    QCOMPARE(r.field(0).metaType(), QMetaType(QMetaType::Int));
+    QCOMPARE(r.field(1).metaType(), QMetaType(QMetaType::Double));
+    QCOMPARE(r.field(2).metaType(), QMetaType(QMetaType::Double));
+    QCOMPARE(r.field(3).metaType(), QMetaType(QMetaType::Double));
+    QCOMPARE(r.field(4).metaType(), QMetaType(QMetaType::Double));
     QCOMPARE(r.field(1).length(), 2);
     QCOMPARE(r.field(1).precision(), 1);
     QCOMPARE(r.field(2).length(), 5);
@@ -2220,7 +2220,7 @@ void tst_QSqlDatabase::sqlite_bindAndFetchUInt()
 
     // All integers in SQLite are signed, so even though we bound the value
     // as an UInt it will come back as a LongLong
-    QCOMPARE(q.value(0).type(), QVariant::LongLong);
+    QCOMPARE(q.value(0).metaType(), QMetaType(QMetaType::LongLong));
     QCOMPARE(q.value(0).toUInt(), 4000000000U);
 }
 
diff --git a/tests/auto/sql/kernel/qsqlfield/tst_qsqlfield.cpp b/tests/auto/sql/kernel/qsqlfield/tst_qsqlfield.cpp
index 7efd19a2b8..0be74c126c 100644
--- a/tests/auto/sql/kernel/qsqlfield/tst_qsqlfield.cpp
+++ b/tests/auto/sql/kernel/qsqlfield/tst_qsqlfield.cpp
@@ -134,7 +134,7 @@ void tst_QSqlField::clear_data()
 
 void tst_QSqlField::clear()
 {
-    QSqlField field( "Testfield", QVariant::Int );
+    QSqlField field( "Testfield", QMetaType(QMetaType::Int) );
     QFETCH( int, val );
     field.setValue( val );
     field.setReadOnly(true);
@@ -142,7 +142,7 @@ void tst_QSqlField::clear()
     QVERIFY( field.value() == val );
     QVERIFY( !field.isNull() );
 
-    QSqlField bfield( "Testfield", QVariant::Bool );
+    QSqlField bfield( "Testfield", QMetaType(QMetaType::Bool) );
     QFETCH( bool, bval );
     bfield.setValue( QVariant(bval) );
     bfield.setReadOnly(true);
@@ -151,7 +151,7 @@ void tst_QSqlField::clear()
     QVERIFY( bfield.value() == QVariant(bval) );
     QVERIFY( !bfield.isNull() );
 
-    QSqlField ffield( "Testfield", QVariant::Double );
+    QSqlField ffield( "Testfield", QMetaType(QMetaType::Double) );
     QFETCH( double, fval );
     ffield.setValue( fval );
     ffield.setReadOnly(true);
@@ -159,7 +159,7 @@ void tst_QSqlField::clear()
     QVERIFY( ffield.value() == fval );
     QVERIFY( !ffield.isNull() );
 
-    QSqlField sfield( "Testfield", QVariant::String );
+    QSqlField sfield( "Testfield", QMetaType(QMetaType::QString) );
     QFETCH( QString, strVal );
     sfield.setValue( strVal );
     sfield.setReadOnly(true);
@@ -170,13 +170,13 @@ void tst_QSqlField::clear()
 
 void tst_QSqlField::isNull()
 {
-    QSqlField field( "test", QVariant::String );
+    QSqlField field( "test", QMetaType(QMetaType::QString) );
     QVERIFY( field.isNull() );
 }
 
 void tst_QSqlField::isReadOnly()
 {
-    QSqlField field( "test", QVariant::String );
+    QSqlField field( "test", QMetaType(QMetaType::QString) );
     QVERIFY( !field.isReadOnly() );
     field.setReadOnly( true );
     QVERIFY( field.isReadOnly() );
@@ -196,7 +196,7 @@ void tst_QSqlField::name_data()
 
 void tst_QSqlField::name()
 {
-    QSqlField field( "test", QVariant::String );
+    QSqlField field( "test", QMetaType(QMetaType::QString) );
     QFETCH( QString, val );
     QCOMPARE(field.name(), QLatin1String("test"));
     field.setName( val );
@@ -205,28 +205,28 @@ void tst_QSqlField::name()
 
 void tst_QSqlField::operator_Assign()
 {
-    QSqlField field1( "test", QVariant::String );
+    QSqlField field1( "test", QMetaType(QMetaType::QString) );
     field1.setValue( "Harry" );
     field1.setReadOnly( true );
     QSqlField field2 = field1;
     QVERIFY( field1 == field2 );
-    QSqlField field3( "test", QVariant::Double );
+    QSqlField field3( "test", QMetaType(QMetaType::Double) );
     field3.clear();
     field1 = field3;
     QVERIFY( field1 == field3 );
-    QSqlField field4("test", QVariant::String, "ATable");
+    QSqlField field4("test", QMetaType(QMetaType::QString), "ATable");
     field1 = field4;
     QVERIFY(field1 == field4);
 }
 
 void tst_QSqlField::operator_Equal()
 {
-    QSqlField field1( "test", QVariant::String );
-    QSqlField field2( "test2", QVariant::String );
-    QSqlField field3( "test", QVariant::Int );
-    QSqlField field4("test", QVariant::String, QString("ATable"));
-    QSqlField field5("test2", QVariant::String, QString("ATable"));
-    QSqlField field6("test", QVariant::String, QString("BTable"));
+    QSqlField field1( "test", QMetaType(QMetaType::QString) );
+    QSqlField field2( "test2", QMetaType(QMetaType::QString) );
+    QSqlField field3( "test", QMetaType(QMetaType::Int) );
+    QSqlField field4("test", QMetaType(QMetaType::QString), QString("ATable"));
+    QSqlField field5("test2", QMetaType(QMetaType::QString), QString("ATable"));
+    QSqlField field6("test", QMetaType(QMetaType::QString), QString("BTable"));
 
     QVERIFY( !(field1 == field2) );
     QVERIFY( !(field1 == field3) );
@@ -265,7 +265,7 @@ void tst_QSqlField::setName_data()
 
 void tst_QSqlField::setName()
 {
-    QSqlField field( "test", QVariant::String );
+    QSqlField field( "test", QMetaType(QMetaType::QString) );
     QFETCH( QString, val );
     QCOMPARE(field.name(), QLatin1String("test"));
     field.setName( val );
@@ -274,7 +274,7 @@ void tst_QSqlField::setName()
 
 void tst_QSqlField::setNull()
 {
-    QSqlField field( "test", QVariant::String );
+    QSqlField field( "test", QMetaType(QMetaType::QString) );
     field.setValue( "test" );
     field.clear();
     QVERIFY( field.value() == QVariant().toString() );
@@ -283,7 +283,7 @@ void tst_QSqlField::setNull()
 
 void tst_QSqlField::setReadOnly()
 {
-    QSqlField field( "test", QVariant::String );
+    QSqlField field( "test", QMetaType(QMetaType::QString) );
     field.setValue( "test" );
     field.setReadOnly( true );
     field.setValue( "Harry" );
@@ -317,10 +317,10 @@ void tst_QSqlField::setValue_data()
 
 void tst_QSqlField::setValue()
 {
-    QSqlField field1 ( "test", QVariant::Int );
-    QSqlField field2 ( "test", QVariant::String );
-    QSqlField field3 ( "test", QVariant::Bool );
-    QSqlField field4 ( "test", QVariant::Double );
+    QSqlField field1 ( "test", QMetaType(QMetaType::Int) );
+    QSqlField field2 ( "test", QMetaType(QMetaType::QString) );
+    QSqlField field3 ( "test", QMetaType(QMetaType::Bool) );
+    QSqlField field4 ( "test", QMetaType(QMetaType::Double) );
     field1.clear();
     QFETCH( int, ival );
     QFETCH( QString, sval );
@@ -344,12 +344,12 @@ void tst_QSqlField::setValue()
 
 void tst_QSqlField::type()
 {
-    QSqlField field1( "string", QVariant::String );
-    QSqlField field2( "string", QVariant::Bool );
-    QSqlField field3( "string", QVariant::Double );
-    QVERIFY( field1.type() == QVariant::String );
-    QVERIFY( field2.type() == QVariant::Bool );
-    QVERIFY( field3.type() == QVariant::Double );
+    QSqlField field1( "string", QMetaType(QMetaType::QString) );
+    QSqlField field2( "string", QMetaType(QMetaType::Bool) );
+    QSqlField field3( "string", QMetaType(QMetaType::Double) );
+    QVERIFY( field1.metaType() == QMetaType(QMetaType::QString) );
+    QVERIFY( field2.metaType() == QMetaType(QMetaType::Bool) );
+    QVERIFY( field3.metaType() == QMetaType(QMetaType::Double) );
 }
 
 void tst_QSqlField::setTableName_data()
@@ -362,7 +362,7 @@ void tst_QSqlField::setTableName_data()
 
 void tst_QSqlField::setTableName()
 {
-    QSqlField field("test", QVariant::String, "test");
+    QSqlField field("test", QMetaType(QMetaType::QString), "test");
     QFETCH(QString, tableName);
     QCOMPARE(field.tableName(), QLatin1String("test"));
     field.setTableName(tableName);
diff --git a/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp b/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp
index 527a9ba647..23ebc1fbfd 100644
--- a/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp
+++ b/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp
@@ -1072,9 +1072,9 @@ void tst_QSqlQuery::record()
     QCOMPARE( q.record().fieldName( 0 ).toLower(), QString( "id" ) );
     QCOMPARE( q.record().fieldName( 1 ).toLower(), QString( "t_varchar" ) );
     QCOMPARE( q.record().fieldName( 2 ).toLower(), QString( "t_char" ) );
-    QCOMPARE(q.record().value(0), QVariant(q.record().field(0).type()));
-    QCOMPARE(q.record().value(1), QVariant(q.record().field(1).type()));
-    QCOMPARE(q.record().value(2), QVariant(q.record().field(2).type()));
+    QCOMPARE(q.record().value(0), QVariant(q.record().field(0).metaType()));
+    QCOMPARE(q.record().value(1), QVariant(q.record().field(1).metaType()));
+    QCOMPARE(q.record().value(2), QVariant(q.record().field(2).metaType()));
 
     QVERIFY( q.next() );
     QVERIFY( q.next() );
@@ -2694,18 +2694,18 @@ void tst_QSqlQuery::record_sqlite()
     QSqlRecord rec = db.record(qTableName("record_sqlite", __FILE__, db));
 
     QCOMPARE( rec.count(), 3 );
-    QCOMPARE( rec.field( 0 ).type(), QVariant::Int );
-    QCOMPARE( rec.field( 1 ).type(), QVariant::String );
-    QCOMPARE( rec.field( 2 ).type(), QVariant::Int );
+    QCOMPARE( rec.field( 0 ).metaType().id(), QVariant::Int );
+    QCOMPARE( rec.field( 1 ).metaType().id(), QVariant::String );
+    QCOMPARE( rec.field( 2 ).metaType().id(), QVariant::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 ).type(), QVariant::Int );
-    QCOMPARE( rec.field( 1 ).type(), QVariant::String );
-    QCOMPARE( rec.field( 2 ).type(), QVariant::Int );
+    QCOMPARE( rec.field( 0 ).metaType().id(), QVariant::Int );
+    QCOMPARE( rec.field( 1 ).metaType().id(), QVariant::String );
+    QCOMPARE( rec.field( 2 ).metaType().id(), QVariant::Int );
 }
 
 void tst_QSqlQuery::oraLong()
@@ -3092,7 +3092,7 @@ void tst_QSqlQuery::nextResult()
 
     QCOMPARE( q.record().field( 0 ).name().toUpper(), QString( "ID" ) );
 
-    QCOMPARE( q.record().field( 0 ).type(), QVariant::Int );
+    QCOMPARE( q.record().field( 0 ).metaType().id(), QVariant::Int );
 
     QVERIFY( q.nextResult() );          // Discards first result set and move to the next
 
@@ -3100,10 +3100,10 @@ void tst_QSqlQuery::nextResult()
 
     QCOMPARE( q.record().field( 0 ).name().toUpper(), QString( "TEXT" ) );
 
-    QCOMPARE( q.record().field( 0 ).type(), QVariant::String );
+    QCOMPARE( q.record().field( 0 ).metaType().id(), QVariant::String );
 
     QCOMPARE( q.record().field( 1 ).name().toUpper(), QString( "NUM" ) );
-    QCOMPARE(q.record().field(1).type(), QVariant::Double);
+    QCOMPARE(q.record().field(1).metaType().id(), QVariant::Double);
 
     QVERIFY( q.next() );                    // Move to first row of the second result set
 
@@ -3915,14 +3915,14 @@ void tst_QSqlQuery::QTBUG_23895()
     QVERIFY_SQL(q, exec(sql));
     QVERIFY_SQL(q, next());
 
-    QCOMPARE(q.record().field(0).type(), QVariant::Int);
-    QCOMPARE(q.value(0).type(), QVariant::LongLong);
+    QCOMPARE(q.record().field(0).metaType().id(), QVariant::Int);
+    QCOMPARE(q.value(0).metaType().id(), QVariant::LongLong);
     QCOMPARE(q.value(0).toInt(), 1);
-    QCOMPARE(q.record().field(1).type(), QVariant::Bool);
-    QCOMPARE(q.value(1).type(), QVariant::LongLong);
+    QCOMPARE(q.record().field(1).metaType().id(), QVariant::Bool);
+    QCOMPARE(q.value(1).metaType().id(), QVariant::LongLong);
     QCOMPARE(q.value(1).toBool(), true);
-    QCOMPARE(q.record().field(2).type(), QVariant::Bool);
-    QCOMPARE(q.value(2).type(), QVariant::LongLong);
+    QCOMPARE(q.record().field(2).metaType().id(), QVariant::Bool);
+    QCOMPARE(q.value(2).metaType().id(), QVariant::LongLong);
     QCOMPARE(q.value(2).toBool(), false);
 
     q.prepare("insert into " + tableName + "(id, val1, val2) values(?, ?, ?);");
@@ -3971,14 +3971,14 @@ void tst_QSqlQuery::QTBUG_14904()
     QVERIFY_SQL(q, next());
 
     QCOMPARE(q.record().indexOf("value1"), 0);
-    QCOMPARE(q.record().field(0).type(), QVariant::Bool);
+    QCOMPARE(q.record().field(0).metaType().id(), QVariant::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).type(), QVariant::Bool);
+    QCOMPARE(q.record().field(0).metaType().id(), QVariant::Bool);
     QCOMPARE(q.value(0).toBool(), true);
 }
 
@@ -4104,7 +4104,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).type(), QVariant::Type::ByteArray);
+    QCOMPARE(sqlQuery.record().field(0).metaType().id(), QVariant::Type::ByteArray);
     QVERIFY(sqlQuery.next());
 }
 
@@ -4250,7 +4250,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).type(), QVariant::Double);
+    QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
 
     q.prepare("INSERT INTO " + tableName + " (id, realVal) VALUES (?, ?)");
     QVariant var((double)5.6);
@@ -4292,9 +4292,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).type(), QVariant::Invalid);
+            QCOMPARE(q.record().field(0).metaType().id(), QVariant::Invalid);
         else
-            QCOMPARE(q.record().field(0).type(), sumType);
+            QCOMPARE(q.record().field(0).metaType().id(), sumType);
 
         QVERIFY_SQL(q, exec("INSERT INTO " + tableName + " (id) VALUES (1)"));
         QVERIFY_SQL(q, exec("INSERT INTO " + tableName + " (id) VALUES (2)"));
@@ -4302,33 +4302,33 @@ void tst_QSqlQuery::aggregateFunctionTypes()
         QVERIFY_SQL(q, exec("SELECT SUM(id) FROM " + tableName));
         QVERIFY(q.next());
         QCOMPARE(q.value(0).toInt(), 3);
-        QCOMPARE(q.record().field(0).type(), sumType);
+        QCOMPARE(q.record().field(0).metaType().id(), sumType);
 
         QVERIFY_SQL(q, exec("SELECT AVG(id) FROM " + tableName));
         QVERIFY(q.next());
         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).type(), QVariant::Double);
+            QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
         } else {
             QCOMPARE(q.value(0).toInt(), 1);
-            QCOMPARE(q.record().field(0).type(), QVariant::Int);
+            QCOMPARE(q.record().field(0).metaType().id(), QVariant::Int);
         }
 
         QVERIFY_SQL(q, exec("SELECT COUNT(id) FROM " + tableName));
         QVERIFY(q.next());
         QCOMPARE(q.value(0).toInt(), 2);
-        QCOMPARE(q.record().field(0).type(), countType);
+        QCOMPARE(q.record().field(0).metaType().id(), countType);
 
         QVERIFY_SQL(q, exec("SELECT MIN(id) FROM " + tableName));
         QVERIFY(q.next());
         QCOMPARE(q.value(0).toInt(), 1);
-        QCOMPARE(q.record().field(0).type(), intType);
+        QCOMPARE(q.record().field(0).metaType().id(), intType);
 
         QVERIFY_SQL(q, exec("SELECT MAX(id) FROM " + tableName));
         QVERIFY(q.next());
         QCOMPARE(q.value(0).toInt(), 2);
-        QCOMPARE(q.record().field(0).type(), intType);
+        QCOMPARE(q.record().field(0).metaType().id(), intType);
     }
     {
         const QString tableName(qTableName("numericFunctionsWithDoubleValues", __FILE__, db));
@@ -4341,9 +4341,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).type(), QVariant::Invalid);
+            QCOMPARE(q.record().field(0).metaType().id(), QVariant::Invalid);
         else
-            QCOMPARE(q.record().field(0).type(), QVariant::Double);
+            QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
 
         QVERIFY_SQL(q, exec("INSERT INTO " + tableName + " (id) VALUES (1.5)"));
         QVERIFY_SQL(q, exec("INSERT INTO " + tableName + " (id) VALUES (2.5)"));
@@ -4351,27 +4351,27 @@ 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).type(), QVariant::Double);
+        QCOMPARE(q.record().field(0).metaType().id(), QVariant::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).type(), QVariant::Double);
+        QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
 
         QVERIFY_SQL(q, exec("SELECT COUNT(id) FROM " + tableName));
         QVERIFY(q.next());
         QCOMPARE(q.value(0).toInt(), 2);
-        QCOMPARE(q.record().field(0).type(), countType);
+        QCOMPARE(q.record().field(0).metaType().id(), countType);
 
         QVERIFY_SQL(q, exec("SELECT MIN(id) FROM " + tableName));
         QVERIFY(q.next());
         QCOMPARE(q.value(0).toDouble(), 1.5);
-        QCOMPARE(q.record().field(0).type(), QVariant::Double);
+        QCOMPARE(q.record().field(0).metaType().id(), QVariant::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).type(), QVariant::Double);
+        QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
 
         QString field = "id";
 
@@ -4383,7 +4383,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).type(), QVariant::Double);
+        QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
 
         QVERIFY_SQL(q, exec("SELECT ROUND(" + field + ", 0) FROM " + tableName + " WHERE id=2.5"));
         QVERIFY(q.next());
@@ -4391,7 +4391,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).type(), QVariant::Double);
+        QCOMPARE(q.record().field(0).metaType().id(), QVariant::Double);
     }
     {
         const QString tableName(qTableName("stringFunctions", __FILE__, db));
@@ -4403,9 +4403,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).type(), QVariant::Invalid);
+            QCOMPARE(q.record().field(0).metaType().id(), QVariant::Invalid);
         else
-            QCOMPARE(q.record().field(0).type(), QVariant::String);
+            QCOMPARE(q.record().field(0).metaType().id(), QVariant::String);
 
         QVERIFY_SQL(q, exec("INSERT INTO " + tableName + " (id, txt) VALUES (1, 'lower')"));
         QVERIFY_SQL(q, exec("INSERT INTO " + tableName + " (id, txt) VALUES (2, 'upper')"));
@@ -4413,7 +4413,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).type(), QVariant::String);
+        QCOMPARE(q.record().field(0).metaType().id(), QVariant::String);
     }
 }
 
@@ -4456,9 +4456,9 @@ void runIntegralTypesMysqlTest(QSqlDatabase &db, const QString &tableName, const
         QVariant value = q.value(0);
         actualVariantValues << value;
         actualValues << value.value<T>();
-        QVERIFY(actualVariantValues.last().userType() != qMetaTypeId<char>());
-        QVERIFY(actualVariantValues.last().userType() != qMetaTypeId<signed char>());
-        QVERIFY(actualVariantValues.last().userType() != qMetaTypeId<unsigned char>());
+        QVERIFY(actualVariantValues.last().metaType().id() != qMetaTypeId<char>());
+        QVERIFY(actualVariantValues.last().metaType().id() != qMetaTypeId<signed char>());
+        QVERIFY(actualVariantValues.last().metaType().id() != qMetaTypeId<unsigned char>());
     }
     QCOMPARE(actualValues, values);
     QCOMPARE(actualVariantValues, variantValues);
diff --git a/tests/auto/sql/models/qsqlquerymodel/tst_qsqlquerymodel.cpp b/tests/auto/sql/models/qsqlquerymodel/tst_qsqlquerymodel.cpp
index 8a87f8bf15..88e052cd18 100644
--- a/tests/auto/sql/models/qsqlquerymodel/tst_qsqlquerymodel.cpp
+++ b/tests/auto/sql/models/qsqlquerymodel/tst_qsqlquerymodel.cpp
@@ -417,9 +417,9 @@ void tst_QSqlQueryModel::record()
     QCOMPARE(rec.fieldName(0), isToUpper ? QString("ID") : QString("id"));
     QCOMPARE(rec.fieldName(1), isToUpper ? QString("NAME") : QString("name"));
     QCOMPARE(rec.fieldName(2), isToUpper ? QString("TITLE") : QString("title"));
-    QCOMPARE(rec.value(0), QVariant(rec.field(0).type()));
-    QCOMPARE(rec.value(1), QVariant(rec.field(1).type()));
-    QCOMPARE(rec.value(2), QVariant(rec.field(2).type()));
+    QCOMPARE(rec.value(0), QVariant(rec.field(0).metaType()));
+    QCOMPARE(rec.value(1), QVariant(rec.field(1).metaType()));
+    QCOMPARE(rec.value(2), QVariant(rec.field(2).metaType()));
 
     rec = model.record(0);
     QCOMPARE(rec.fieldName(0), isToUpper ? QString("ID") : QString("id"));
diff --git a/tests/auto/sql/models/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp b/tests/auto/sql/models/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp
index 19d8430118..4fd4f1559d 100644
--- a/tests/auto/sql/models/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp
+++ b/tests/auto/sql/models/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp
@@ -468,10 +468,10 @@ void tst_QSqlRelationalTableModel::insertRecord()
     QVERIFY_SQL(model, select());
 
     QSqlRecord rec;
-    QSqlField f1("id", QVariant::Int);
-    QSqlField f2("name", QVariant::String);
-    QSqlField f3("title_key", QVariant::Int);
-    QSqlField f4("another_title_key", QVariant::Int);
+    QSqlField f1("id", QMetaType(QMetaType::Int));
+    QSqlField f2("name", QMetaType(QMetaType::QString));
+    QSqlField f3("title_key", QMetaType(QMetaType::Int));
+    QSqlField f4("another_title_key", QMetaType(QMetaType::Int));
 
     f1.setValue(7);
     f2.setValue("test");
@@ -518,10 +518,10 @@ void tst_QSqlRelationalTableModel::setRecord()
     QVERIFY_SQL(model, select());
 
     QSqlRecord rec;
-    QSqlField f1("id", QVariant::Int);
-    QSqlField f2("name", QVariant::String);
-    QSqlField f3("title_key", QVariant::Int);
-    QSqlField f4("another_title_key", QVariant::Int);
+    QSqlField f1("id", QMetaType(QMetaType::Int));
+    QSqlField f2("name", QMetaType(QMetaType::QString));
+    QSqlField f3("title_key", QMetaType(QMetaType::Int));
+    QSqlField f4("another_title_key", QMetaType(QMetaType::Int));
 
     f1.setValue(7);
     f2.setValue("tester");
@@ -1417,9 +1417,9 @@ void tst_QSqlRelationalTableModel::whiteSpaceInIdentifiers()
     QVERIFY_SQL(model, select());
 
     QSqlRecord rec;
-    QSqlField f1("id", QVariant::Int);
-    QSqlField f2(db.driver()->escapeIdentifier("city key", QSqlDriver::FieldName), QVariant::Int);
-    QSqlField f3(db.driver()->escapeIdentifier("extra field", QSqlDriver::FieldName), QVariant::Int);
+    QSqlField f1("id", QMetaType(QMetaType::Int));
+    QSqlField f2(db.driver()->escapeIdentifier("city key", QSqlDriver::FieldName), QMetaType(QMetaType::Int));
+    QSqlField f3(db.driver()->escapeIdentifier("extra field", QSqlDriver::FieldName), QMetaType(QMetaType::Int));
 
     f1.setValue(3);
     f2.setValue(2);
@@ -1445,9 +1445,9 @@ void tst_QSqlRelationalTableModel::whiteSpaceInIdentifiers()
     model.setEditStrategy(QSqlTableModel::OnManualSubmit);
 
     QSqlRecord recNew;
-    QSqlField f1New("id", QVariant::Int);
-    QSqlField f2New(db.driver()->escapeIdentifier("city key", QSqlDriver::FieldName), QVariant::Int);
-    QSqlField f3New(db.driver()->escapeIdentifier("extra field", QSqlDriver::FieldName), QVariant::Int);
+    QSqlField f1New("id", QMetaType(QMetaType::Int));
+    QSqlField f2New(db.driver()->escapeIdentifier("city key", QSqlDriver::FieldName), QMetaType(QMetaType::Int));
+    QSqlField f3New(db.driver()->escapeIdentifier("extra field", QSqlDriver::FieldName), QMetaType(QMetaType::Int));
 
     f1New.setValue(4);
     f2New.setValue(1);
diff --git a/tests/auto/sql/models/qsqltablemodel/tst_qsqltablemodel.cpp b/tests/auto/sql/models/qsqltablemodel/tst_qsqltablemodel.cpp
index f58fdc9bf9..a0aa011d0c 100644
--- a/tests/auto/sql/models/qsqltablemodel/tst_qsqltablemodel.cpp
+++ b/tests/auto/sql/models/qsqltablemodel/tst_qsqltablemodel.cpp
@@ -956,9 +956,9 @@ void tst_QSqlTableModel::insertMultiRecords()
 
     QVERIFY(model.insertRow(2));
 
-    QCOMPARE(model.data(model.index(2, 0)), QVariant(model.record().field(0).type()));
-    QCOMPARE(model.data(model.index(2, 1)), QVariant(model.record().field(1).type()));
-    QCOMPARE(model.data(model.index(2, 2)), QVariant(model.record().field(2).type()));
+    QCOMPARE(model.data(model.index(2, 0)), QVariant(model.record().field(0).metaType()));
+    QCOMPARE(model.data(model.index(2, 1)), QVariant(model.record().field(1).metaType()));
+    QCOMPARE(model.data(model.index(2, 2)), QVariant(model.record().field(2).metaType()));
 
     QVERIFY(model.insertRow(3));
     QVERIFY(model.insertRow(0));