From 67f04fa060be1b75b8ea60ac6eb45d1577d1fdaf Mon Sep 17 00:00:00 2001 From: Lars Knoll Date: Mon, 15 Jun 2020 09:31:31 +0200 Subject: 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 --- .../sql/kernel/qsqldatabase/tst_qsqldatabase.cpp | 66 ++++++++-------- tests/auto/sql/kernel/qsqlfield/tst_qsqlfield.cpp | 60 +++++++-------- tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp | 90 +++++++++++----------- 3 files changed, 108 insertions(+), 108 deletions(-) (limited to 'tests/auto/sql/kernel') 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(); - QVERIFY(actualVariantValues.last().userType() != qMetaTypeId()); - QVERIFY(actualVariantValues.last().userType() != qMetaTypeId()); - QVERIFY(actualVariantValues.last().userType() != qMetaTypeId()); + QVERIFY(actualVariantValues.last().metaType().id() != qMetaTypeId()); + QVERIFY(actualVariantValues.last().metaType().id() != qMetaTypeId()); + QVERIFY(actualVariantValues.last().metaType().id() != qMetaTypeId()); } QCOMPARE(actualValues, values); QCOMPARE(actualVariantValues, variantValues); -- cgit v1.2.3