From 2732231182d9bcfdd613cc86f70e578e82b7c2aa Mon Sep 17 00:00:00 2001 From: Lars Knoll Date: Thu, 10 Sep 2020 20:03:42 +0200 Subject: [PATCH] Cleanup remaining QVariant::Type uses in Qt Sql MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Change-Id: Ibcaa678cd9f9c957392a75b477fa6821f9a69127 Reviewed-by: Mårten Nordheim --- src/plugins/sqldrivers/sqlite/qsql_sqlite.cpp | 46 +-- src/sql/kernel/qsqlfield.h | 6 +- .../kernel/qsqldatabase/tst_qsqldatabase.cpp | 292 +++++++++--------- .../sql/kernel/qsqlquery/tst_qsqlquery.cpp | 96 +++--- .../sql/kernel/qsqlrecord/tst_qsqlrecord.cpp | 52 ++-- .../sql/kernel/qsqlresult/testsqldriver.h | 28 +- .../qsqltablemodel/tst_qsqltablemodel.cpp | 18 +- 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 60e871a25af..d6a0f319f9d 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(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(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 3a133c4e6b3..27ad47ca356 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 @@ class Q_SQL_EXPORT QSqlField 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 e412b6f3edb..4e6664faa02 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(QMetaType::Char), 127), - FieldDef("tinyint unsigned", static_cast(QMetaType::UChar), 255), - FieldDef("smallint", static_cast(QMetaType::Short), 32767), - FieldDef("smallint unsigned", static_cast(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 322c1b3b847..352687a3691 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 83a61b91d7c..ed259f3cde8 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 b4fb65bf7da..d9c5a411bac 100644 --- a/tests/auto/sql/kernel/qsqlresult/testsqldriver.h +++ b/tests/auto/sql/kernel/qsqlresult/testsqldriver.h @@ -41,7 +41,7 @@ class TestSqlDriverResult : public QSqlResult : QSqlResult(driver) {} ~TestSqlDriverResult() {} - bool savePrepare(const QString& sqlquery) + bool savePrepare(const QString& sqlquery) override { return QSqlResult::savePrepare(sqlquery); } @@ -49,15 +49,15 @@ class TestSqlDriverResult : public QSqlResult QList 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 @@ class TestSqlDriver : public QSqlDriver 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 @@ class TestSqlDriver : public QSqlDriver } 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 53f1b195a9d..2ceba66bf8a 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);