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>

5 files changed, 56 insertions, 56 deletions

diff --git a/src/plugins/sqldrivers/db2/qsql_db2.cpp b/src/plugins/sqldrivers/db2/qsql_db2.cpp
index 02cb15348b..e644a556e6 100644
--- a/src/plugins/sqldrivers/db2/qsql_db2.cpp
+++ b/src/plugins/sqldrivers/db2/qsql_db2.cpp
@@ -702,7 +702,7 @@ bool QDB2Result::exec()
         if (bindValueType(i) & QSql::Out)
             values[i].detach();
 
-        switch (values.at(i).type()) {
+        switch (values.at(i).metaType().id()) {
             case QVariant::Date: {
                 QByteArray ba;
                 ba.resize(sizeof(DATE_STRUCT));
@@ -894,7 +894,7 @@ bool QDB2Result::exec()
         return true;
 
     for (i = 0; i < values.count(); ++i) {
-        switch (values[i].type()) {
+        switch (values[i].metaType().id()) {
             case QVariant::Date: {
                 DATE_STRUCT ds = *((DATE_STRUCT *)tmpStorage.takeFirst().constData());
                 values[i] = QVariant(QDate(ds.year, ds.month, ds.day));
@@ -921,7 +921,7 @@ bool QDB2Result::exec()
                 break; }
         }
         if (indicators[i] == SQL_NULL_DATA)
-            values[i] = QVariant(values[i].type());
+            values[i] = QVariant(values[i].metaType());
     }
     return true;
 }
@@ -1053,7 +1053,7 @@ QVariant QDB2Result::data(int field)
 
 
     QVariant* v = 0;
-    switch (info.type()) {
+    switch (info.metaType().id()) {
         case QVariant::LongLong:
             v = new QVariant((qint64) qGetBigIntData(d->hStmt, field, isNull));
             break;
@@ -1135,7 +1135,7 @@ QVariant QDB2Result::data(int field)
             break;
     }
     if (isNull)
-        *v = QVariant(info.type());
+        *v = QVariant(info.metaType());
     d->valueCache[field] = v;
     return *v;
 }
@@ -1687,7 +1687,7 @@ QString QDB2Driver::formatValue(const QSqlField &field, bool trimStrings) const
     if (field.isNull())
         return QLatin1String("NULL");
 
-    switch (field.type()) {
+    switch (field.metaType().id()) {
         case QVariant::DateTime: {
             // Use an escape sequence for the datetime fields
             if (field.value().toDateTime().isValid()) {
diff --git a/src/plugins/sqldrivers/mysql/qsql_mysql.cpp b/src/plugins/sqldrivers/mysql/qsql_mysql.cpp
index 93c9a4841f..733e949a98 100644
--- a/src/plugins/sqldrivers/mysql/qsql_mysql.cpp
+++ b/src/plugins/sqldrivers/mysql/qsql_mysql.cpp
@@ -173,7 +173,7 @@ public:
     {
         char *outField = nullptr;
         MYSQL_FIELD *myField = nullptr;
-        QMetaType::Type type = QMetaType::UnknownType;
+        QMetaType type = QMetaType();
         my_bool nullIndicator = false;
         ulong bufLength = 0ul;
     };
@@ -201,7 +201,7 @@ static QSqlError qMakeError(const QString& err, QSqlError::ErrorType type,
 }
 
 
-static QMetaType::Type qDecodeMYSQLType(int mysqltype, uint flags)
+static QMetaType qDecodeMYSQLType(int mysqltype, uint flags)
 {
     QMetaType::Type type;
     switch (mysqltype) {
@@ -256,13 +256,13 @@ static QMetaType::Type qDecodeMYSQLType(int mysqltype, uint flags)
         type = QMetaType::QString;
         break;
     }
-    return type;
+    return QMetaType(type);
 }
 
 static QSqlField qToField(MYSQL_FIELD *field)
 {
     QSqlField f(QString::fromUtf8(field->name),
-                QVariant::Type(qDecodeMYSQLType(int(field->type), field->flags)),
+                qDecodeMYSQLType(int(field->type), field->flags),
                 QString::fromUtf8(field->table));
     f.setRequired(IS_NOT_NULL(field->flags));
     f.setLength(field->length);
@@ -344,7 +344,7 @@ bool QMYSQLResultPrivate::bindInValues()
             // after mysql_stmt_exec() in QMYSQLResult::exec()
             fieldInfo->length = 0;
             hasBlobs = true;
-        } else if (qIsInteger(f.type)) {
+        } else if (qIsInteger(f.type.id())) {
             fieldInfo->length = 8;
         } else {
             fieldInfo->type = MYSQL_TYPE_STRING;
@@ -541,33 +541,33 @@ QVariant QMYSQLResult::data(int field)
     QString val;
     if (d->preparedQuery) {
         if (f.nullIndicator)
-            return QVariant(QVariant::Type(f.type));
+            return QVariant(f.type);
 
-        if (qIsInteger(f.type)) {
-            QVariant variant(QMetaType(f.type), f.outField);
+        if (qIsInteger(f.type.id())) {
+            QVariant variant(f.type, f.outField);
             // we never want to return char variants here, see QTBUG-53397
-            if (static_cast<int>(f.type) == QMetaType::UChar)
+            if (f.type.id() == QMetaType::UChar)
                 return variant.toUInt();
-            else if (static_cast<int>(f.type) == QMetaType::Char)
+            else if (f.type.id() == QMetaType::Char)
                 return variant.toInt();
             return variant;
         }
 
-        if (f.type != QMetaType::QByteArray)
+        if (f.type.id() != QMetaType::QByteArray)
             val = QString::fromUtf8(f.outField, f.bufLength);
     } else {
         if (d->row[field] == NULL) {
             // NULL value
-            return QVariant(QVariant::Type(f.type));
+            return QVariant(f.type);
         }
 
         fieldLength = mysql_fetch_lengths(d->result)[field];
 
-        if (f.type != QMetaType::QByteArray)
+        if (f.type.id() != QMetaType::QByteArray)
             val = QString::fromUtf8(d->row[field], fieldLength);
     }
 
-    switch (static_cast<int>(f.type)) {
+    switch (f.type.id()) {
     case QMetaType::LongLong:
         return QVariant(val.toLongLong());
     case QMetaType::ULongLong:
@@ -1447,7 +1447,7 @@ QString QMYSQLDriver::formatValue(const QSqlField &field, bool trimStrings) cons
     if (field.isNull()) {
         r = QStringLiteral("NULL");
     } else {
-        switch (+field.type()) {
+        switch (field.metaType().id()) {
         case QMetaType::Double:
             r = QString::number(field.value().toDouble(), 'g', field.precision());
             break;
diff --git a/src/plugins/sqldrivers/odbc/qsql_odbc.cpp b/src/plugins/sqldrivers/odbc/qsql_odbc.cpp
index ffd8b5dc6e..a58c782b60 100644
--- a/src/plugins/sqldrivers/odbc/qsql_odbc.cpp
+++ b/src/plugins/sqldrivers/odbc/qsql_odbc.cpp
@@ -341,49 +341,49 @@ static QSqlError qMakeError(const QString& err, QSqlError::ErrorType type,
                      nativeCode != -1 ? QString::number(nativeCode) : QString());
 }
 
-static QVariant::Type qDecodeODBCType(SQLSMALLINT sqltype, bool isSigned = true)
+static QMetaType qDecodeODBCType(SQLSMALLINT sqltype, bool isSigned = true)
 {
-    QVariant::Type type = QVariant::Invalid;
+    int type = QMetaType::UnknownType;
     switch (sqltype) {
     case SQL_DECIMAL:
     case SQL_NUMERIC:
     case SQL_REAL:
     case SQL_FLOAT:
     case SQL_DOUBLE:
-        type = QVariant::Double;
+        type = QMetaType::Double;
         break;
     case SQL_SMALLINT:
     case SQL_INTEGER:
     case SQL_BIT:
-        type = isSigned ? QVariant::Int : QVariant::UInt;
+        type = isSigned ? QMetaType::Int : QMetaType::UInt;
         break;
     case SQL_TINYINT:
-        type = QVariant::UInt;
+        type = QMetaType::UInt;
         break;
     case SQL_BIGINT:
-        type = isSigned ? QVariant::LongLong : QVariant::ULongLong;
+        type = isSigned ? QMetaType::LongLong : QMetaType::ULongLong;
         break;
     case SQL_BINARY:
     case SQL_VARBINARY:
     case SQL_LONGVARBINARY:
-        type = QVariant::ByteArray;
+        type = QMetaType::QByteArray;
         break;
     case SQL_DATE:
     case SQL_TYPE_DATE:
-        type = QVariant::Date;
+        type = QMetaType::QDate;
         break;
     case SQL_TIME:
     case SQL_TYPE_TIME:
-        type = QVariant::Time;
+        type = QMetaType::QTime;
         break;
     case SQL_TIMESTAMP:
     case SQL_TYPE_TIMESTAMP:
-        type = QVariant::DateTime;
+        type = QMetaType::QDateTime;
         break;
     case SQL_WCHAR:
     case SQL_WVARCHAR:
     case SQL_WLONGVARCHAR:
-        type = QVariant::String;
+        type = QMetaType::QString;
         break;
     case SQL_CHAR:
     case SQL_VARCHAR:
@@ -391,13 +391,13 @@ static QVariant::Type qDecodeODBCType(SQLSMALLINT sqltype, bool isSigned = true)
     case SQL_GUID:
 #endif
     case SQL_LONGVARCHAR:
-        type = QVariant::String;
+        type = QMetaType::QString;
         break;
     default:
-        type = QVariant::ByteArray;
+        type = QMetaType::QByteArray;
         break;
     }
-    return type;
+    return QMetaType(type);
 }
 
 static QString qGetStringData(SQLHANDLE hStmt, int column, int colSize, bool unicode = false)
@@ -554,7 +554,7 @@ static QVariant qGetBinaryData(SQLHANDLE hStmt, int column)
         if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO)
             break;
         if (lengthIndicator == SQL_NULL_DATA)
-            return QVariant(QVariant::ByteArray);
+            return QVariant(QMetaType(QVariant::ByteArray));
         if (lengthIndicator > SQLLEN(colSize) || lengthIndicator == SQL_NO_TOTAL) {
             read += colSize;
             colSize = 65536;
@@ -581,9 +581,9 @@ static QVariant qGetIntData(SQLHANDLE hStmt, int column, bool isSigned = true)
                               sizeof(intbuf),
                               &lengthIndicator);
     if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO)
-        return QVariant(QVariant::Invalid);
+        return QVariant();
     if (lengthIndicator == SQL_NULL_DATA)
-        return QVariant(QVariant::Int);
+        return QVariant(QMetaType::fromType<int>());
     if (isSigned)
         return int(intbuf);
     else
@@ -601,10 +601,10 @@ static QVariant qGetDoubleData(SQLHANDLE hStmt, int column)
                               0,
                               &lengthIndicator);
     if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
-        return QVariant(QVariant::Invalid);
+        return QVariant();
     }
     if(lengthIndicator == SQL_NULL_DATA)
-        return QVariant(QVariant::Double);
+        return QVariant(QMetaType::fromType<double>());
 
     return (double) dblbuf;
 }
@@ -621,9 +621,9 @@ static QVariant qGetBigIntData(SQLHANDLE hStmt, int column, bool isSigned = true
                               sizeof(lngbuf),
                               &lengthIndicator);
     if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO)
-        return QVariant(QVariant::Invalid);
+        return QVariant();
     if (lengthIndicator == SQL_NULL_DATA)
-        return QVariant(QVariant::LongLong);
+        return QVariant(QMetaType::fromType<qlonglong>());
 
     if (isSigned)
         return qint64(lngbuf);
@@ -717,7 +717,7 @@ static QSqlField qMakeFieldInfo(const SQLHANDLE hStmt, int i, QString *errorMess
 
     const QString qColName(fromSQLTCHAR(colName, colNameLen));
     // nullable can be SQL_NO_NULLS, SQL_NULLABLE or SQL_NULLABLE_UNKNOWN
-    QVariant::Type type = qDecodeODBCType(colType, unsignedFlag == SQL_FALSE);
+    QMetaType type = qDecodeODBCType(colType, unsignedFlag == SQL_FALSE);
     QSqlField f(qColName, type);
     f.setSqlType(colType);
     f.setLength(colSize == 0 ? -1 : int(colSize));
@@ -1212,7 +1212,7 @@ QVariant QODBCResult::data(int field)
         // some servers do not support fetching column n after we already
         // fetched column n+1, so cache all previous columns here
         const QSqlField info = d->rInf.field(i);
-        switch (info.type()) {
+        switch (info.metaType().id()) {
         case QVariant::LongLong:
             d->fieldCache[i] = qGetBigIntData(d->hStmt, i);
         break;
@@ -1236,7 +1236,7 @@ QVariant QODBCResult::data(int field)
             if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && (lengthIndicator != SQL_NULL_DATA))
                 d->fieldCache[i] = QVariant(QDate(dbuf.year, dbuf.month, dbuf.day));
             else
-                d->fieldCache[i] = QVariant(QVariant::Date);
+                d->fieldCache[i] = QVariant(QMetaType::fromType<QDate>());
         break;
         case QVariant::Time:
             TIME_STRUCT tbuf;
@@ -1249,7 +1249,7 @@ QVariant QODBCResult::data(int field)
             if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && (lengthIndicator != SQL_NULL_DATA))
                 d->fieldCache[i] = QVariant(QTime(tbuf.hour, tbuf.minute, tbuf.second));
             else
-                d->fieldCache[i] = QVariant(QVariant::Time);
+                d->fieldCache[i] = QVariant(QMetaType::fromType<QTime>());
         break;
         case QVariant::DateTime:
             TIMESTAMP_STRUCT dtbuf;
@@ -1263,7 +1263,7 @@ QVariant QODBCResult::data(int field)
                 d->fieldCache[i] = QVariant(QDateTime(QDate(dtbuf.year, dtbuf.month, dtbuf.day),
                        QTime(dtbuf.hour, dtbuf.minute, dtbuf.second, dtbuf.fraction / 1000000)));
             else
-                d->fieldCache[i] = QVariant(QVariant::DateTime);
+                d->fieldCache[i] = QVariant(QMetaType::fromType<QDateTime>());
             break;
         case QVariant::ByteArray:
             d->fieldCache[i] = qGetBinaryData(d->hStmt, i);
@@ -1730,7 +1730,7 @@ bool QODBCResult::exec()
                 break; }
         }
         if (indicators[i] == SQL_NULL_DATA)
-            values[i] = QVariant(QVariant::Type(values[i].userType()));
+            values[i] = QVariant(values[i].metaType());
     }
     return true;
 }
@@ -2583,7 +2583,7 @@ QString QODBCDriver::formatValue(const QSqlField &field,
     QString r;
     if (field.isNull()) {
         r = QLatin1String("NULL");
-    } else if (field.type() == QVariant::DateTime) {
+    } else if (field.metaType().id() == QVariant::DateTime) {
         // Use an escape sequence for the datetime fields
         if (field.value().toDateTime().isValid()){
             QDate dt = field.value().toDateTime().date();
@@ -2599,7 +2599,7 @@ QString QODBCDriver::formatValue(const QSqlField &field,
                 QLatin1String("' }");
         } else
             r = QLatin1String("NULL");
-    } else if (field.type() == QVariant::ByteArray) {
+    } else if (field.metaType().id() == QVariant::ByteArray) {
         QByteArray ba = field.value().toByteArray();
         QString res;
         static const char hexchars[] = "0123456789abcdef";
diff --git a/src/plugins/sqldrivers/psql/qsql_psql.cpp b/src/plugins/sqldrivers/psql/qsql_psql.cpp
index b477f701e2..60729840e2 100644
--- a/src/plugins/sqldrivers/psql/qsql_psql.cpp
+++ b/src/plugins/sqldrivers/psql/qsql_psql.cpp
@@ -634,7 +634,7 @@ QVariant QPSQLResult::data(int i)
     int ptype = PQftype(d->result, i);
     QVariant::Type type = qDecodePSQLType(ptype);
     if (PQgetisnull(d->result, currentRow, i))
-        return QVariant(type);
+        return QVariant(QMetaType(type), nullptr);
     const char *val = PQgetvalue(d->result, currentRow, i);
     switch (type) {
     case QVariant::Bool:
@@ -805,8 +805,8 @@ QSqlRecord QPSQLResult::record() const
             f.setTableName(QString());
         }
         int ptype = PQftype(d->result, i);
-        f.setType(qDecodePSQLType(ptype));
-        f.setValue(QVariant(f.type())); // only set in setType() when it's invalid before
+        f.setMetaType(QMetaType(qDecodePSQLType(ptype)));
+        f.setValue(QVariant(f.metaType())); // only set in setType() when it's invalid before
         int len = PQfsize(d->result, i);
         int precision = PQfmod(d->result, i);
 
@@ -856,7 +856,7 @@ static QString qCreateParamString(const QList<QVariant> &boundValues, const QSql
     QString params;
     QSqlField f;
     for (const QVariant &val : boundValues) {
-        f.setType(val.type());
+        f.setMetaType(val.metaType());
         if (val.isNull())
             f.clear();
         else
@@ -1476,7 +1476,7 @@ QString QPSQLDriver::formatValue(const QSqlField &field, bool trimStrings) const
     if (field.isNull()) {
         r = nullStr();
     } else {
-        switch (int(field.type())) {
+        switch (field.metaType().id()) {
         case QVariant::DateTime:
 #if QT_CONFIG(datestring)
             if (field.value().toDateTime().isValid()) {
diff --git a/src/plugins/sqldrivers/sqlite/qsql_sqlite.cpp b/src/plugins/sqldrivers/sqlite/qsql_sqlite.cpp
index f507e44d32..9edf94abd2 100644
--- a/src/plugins/sqldrivers/sqlite/qsql_sqlite.cpp
+++ b/src/plugins/sqldrivers/sqlite/qsql_sqlite.cpp
@@ -309,7 +309,7 @@ bool QSQLiteResultPrivate::fetchNext(QSqlCachedResult::ValueCache &values, int i
                 };
                 break;
             case SQLITE_NULL:
-                values[i + idx] = QVariant(QVariant::String);
+                values[i + idx] = QVariant(QMetaType::fromType<QString>());
                 break;
             default:
                 values[i + idx] = QString(reinterpret_cast<const QChar *>(