Deprecate QVariant::Type

It's been obsolete for a long time already. Make sure
the compiler now warns about it and remove all remaining
uses in qtbase.

Change-Id: I0ff80311184dba52d2ba5f4e2fabe0d47fdc59d7
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>

1 files changed, 171 insertions, 173 deletions

diff --git a/src/plugins/sqldrivers/oci/qsql_oci.cpp b/src/plugins/sqldrivers/oci/qsql_oci.cpp
index 5bf9400180..28b419e6a1 100644
--- a/src/plugins/sqldrivers/oci/qsql_oci.cpp
+++ b/src/plugins/sqldrivers/oci/qsql_oci.cpp
@@ -364,8 +364,8 @@ int QOCIResultPrivate::bindValue(OCIStmt *sql, OCIBind **hbnd, OCIError *err, in
     int r = OCI_SUCCESS;
     void *data = const_cast<void *>(val.constData());
 
-    switch (val.type()) {
-    case QVariant::ByteArray:
+    switch (val.typeId()) {
+    case QMetaType::QByteArray:
         r = OCIBindByPos(sql, hbnd, err,
                          pos + 1,
                          isOutValue(pos)
@@ -374,9 +374,9 @@ int QOCIResultPrivate::bindValue(OCIStmt *sql, OCIBind **hbnd, OCIError *err, in
                          reinterpret_cast<QByteArray *>(data)->size(),
                          SQLT_BIN, indPtr, 0, 0, 0, 0, OCI_DEFAULT);
         break;
-    case QVariant::Time:
-    case QVariant::Date:
-    case QVariant::DateTime: {
+    case QMetaType::QTime:
+    case QMetaType::QDate:
+    case QMetaType::QDateTime: {
         QOCIDateTime *ptr = new QOCIDateTime(env, err, val.toDateTime());
         r = OCIBindByPos(sql, hbnd, err,
                          pos + 1,
@@ -386,7 +386,7 @@ int QOCIResultPrivate::bindValue(OCIStmt *sql, OCIBind **hbnd, OCIError *err, in
         tmpStorage.dateTimes.append(ptr);
         break;
     }
-    case QVariant::Int:
+    case QMetaType::Int:
         r = OCIBindByPos(sql, hbnd, err,
                          pos + 1,
                          // if it's an out value, the data is already detached
@@ -395,7 +395,7 @@ int QOCIResultPrivate::bindValue(OCIStmt *sql, OCIBind **hbnd, OCIError *err, in
                          sizeof(int),
                          SQLT_INT, indPtr, 0, 0, 0, 0, OCI_DEFAULT);
         break;
-    case QVariant::UInt:
+    case QMetaType::UInt:
         r = OCIBindByPos(sql, hbnd, err,
                          pos + 1,
                          // if it's an out value, the data is already detached
@@ -404,7 +404,7 @@ int QOCIResultPrivate::bindValue(OCIStmt *sql, OCIBind **hbnd, OCIError *err, in
                          sizeof(uint),
                          SQLT_UIN, indPtr, 0, 0, 0, 0, OCI_DEFAULT);
         break;
-    case QVariant::LongLong:
+    case QMetaType::LongLong:
     {
         QByteArray ba = qMakeOCINumber(val.toLongLong(), err);
         r = OCIBindByPos(sql, hbnd, err,
@@ -415,7 +415,7 @@ int QOCIResultPrivate::bindValue(OCIStmt *sql, OCIBind **hbnd, OCIError *err, in
         tmpStorage.rawData.append(ba);
         break;
     }
-    case QVariant::ULongLong:
+    case QMetaType::ULongLong:
     {
         QByteArray ba = qMakeOCINumber(val.toULongLong(), err);
         r = OCIBindByPos(sql, hbnd, err,
@@ -426,7 +426,7 @@ int QOCIResultPrivate::bindValue(OCIStmt *sql, OCIBind **hbnd, OCIError *err, in
         tmpStorage.rawData.append(ba);
         break;
     }
-    case QVariant::Double:
+    case QMetaType::Double:
         r = OCIBindByPos(sql, hbnd, err,
                          pos + 1,
                          // if it's an out value, the data is already detached
@@ -435,22 +435,7 @@ int QOCIResultPrivate::bindValue(OCIStmt *sql, OCIBind **hbnd, OCIError *err, in
                          sizeof(double),
                          SQLT_FLT, indPtr, 0, 0, 0, 0, OCI_DEFAULT);
         break;
-    case QVariant::UserType:
-        if (val.canConvert<QOCIRowIdPointer>() && !isOutValue(pos)) {
-            // use a const pointer to prevent a detach
-            const QOCIRowIdPointer rptr = qvariant_cast<QOCIRowIdPointer>(val);
-            r = OCIBindByPos(sql, hbnd, err,
-                             pos + 1,
-                             // it's an IN value, so const_cast is ok
-                             const_cast<OCIRowid **>(&rptr->id),
-                             -1,
-                             SQLT_RDD, indPtr, 0, 0, 0, 0, OCI_DEFAULT);
-        } else {
-            qWarning("Unknown bind variable");
-            r = OCI_ERROR;
-        }
-        break;
-    case QVariant::String: {
+    case QMetaType::QString: {
         const QString s = val.toString();
         if (isBinaryValue(pos)) {
             r = OCIBindByPos(sql, hbnd, err,
@@ -473,27 +458,43 @@ int QOCIResultPrivate::bindValue(OCIStmt *sql, OCIBind **hbnd, OCIError *err, in
         }
     } // fall through for OUT values
     default: {
-        const QString s = val.toString();
-        // create a deep-copy
-        QByteArray ba(reinterpret_cast<const char *>(s.utf16()), (s.length() + 1) * sizeof(QChar));
-        if (isOutValue(pos)) {
-            ba.reserve((s.capacity() + 1) * sizeof(QChar));
-            *tmpSize = ba.size();
-            r = OCIBindByPos(sql, hbnd, err,
-                             pos + 1,
-                             ba.data(),
-                             ba.capacity(),
-                             SQLT_STR, indPtr, tmpSize, 0, 0, 0, OCI_DEFAULT);
+        if (val.typeId() >= QMetaType::User) {
+            if (val.canConvert<QOCIRowIdPointer>() && !isOutValue(pos)) {
+                // use a const pointer to prevent a detach
+                const QOCIRowIdPointer rptr = qvariant_cast<QOCIRowIdPointer>(val);
+                r = OCIBindByPos(sql, hbnd, err,
+                                 pos + 1,
+                                 // it's an IN value, so const_cast is ok
+                                 const_cast<OCIRowid **>(&rptr->id),
+                                 -1,
+                                 SQLT_RDD, indPtr, 0, 0, 0, 0, OCI_DEFAULT);
+            } else {
+                qWarning("Unknown bind variable");
+                r = OCI_ERROR;
+            }
         } else {
-            r = OCIBindByPos(sql, hbnd, err,
-                             pos + 1,
-                             ba.data(),
-                             ba.size(),
-                             SQLT_STR, indPtr, 0, 0, 0, 0, OCI_DEFAULT);
+            const QString s = val.toString();
+            // create a deep-copy
+            QByteArray ba(reinterpret_cast<const char *>(s.utf16()), (s.length() + 1) * sizeof(QChar));
+            if (isOutValue(pos)) {
+                ba.reserve((s.capacity() + 1) * sizeof(QChar));
+                *tmpSize = ba.size();
+                r = OCIBindByPos(sql, hbnd, err,
+                                 pos + 1,
+                                 ba.data(),
+                                 ba.capacity(),
+                                 SQLT_STR, indPtr, tmpSize, 0, 0, 0, OCI_DEFAULT);
+            } else {
+                r = OCIBindByPos(sql, hbnd, err,
+                                 pos + 1,
+                                 ba.data(),
+                                 ba.size(),
+                                 SQLT_STR, indPtr, 0, 0, 0, 0, OCI_DEFAULT);
+            }
+            if (r == OCI_SUCCESS)
+                setCharset(*hbnd, OCI_HTYPE_BIND);
+            tmpStorage.rawData.append(ba);
         }
-        if (r == OCI_SUCCESS)
-            setCharset(*hbnd, OCI_HTYPE_BIND);
-        tmpStorage.rawData.append(ba);
         break;
     } // default case
     } // switch
@@ -523,26 +524,26 @@ int QOCIResultPrivate::bindValues(QVariantList &values, IndicatorArray &indicato
 // will assign out value and remove its temp storage.
 static void qOraOutValue(QVariant &value, TempStorage &tmpStorage, OCIEnv *env, OCIError* err)
 {
-    switch (value.type()) {
-    case QVariant::Time:
+    switch (value.typeId()) {
+    case QMetaType::QTime:
         value = QOCIDateTime::fromOCIDateTime(env, err,
                                               tmpStorage.dateTimes.takeFirst()->dateTime).time();
         break;
-    case QVariant::Date:
+    case QMetaType::QDate:
         value = QOCIDateTime::fromOCIDateTime(env, err,
                                               tmpStorage.dateTimes.takeFirst()->dateTime).date();
         break;
-    case QVariant::DateTime:
+    case QMetaType::QDateTime:
         value = QOCIDateTime::fromOCIDateTime(env, err,
                                               tmpStorage.dateTimes.takeFirst()->dateTime);
         break;
-    case QVariant::LongLong:
+    case QMetaType::LongLong:
         value = qMakeLongLong(tmpStorage.rawData.takeFirst(), err);
         break;
-    case QVariant::ULongLong:
+    case QMetaType::ULongLong:
         value = qMakeULongLong(tmpStorage.rawData.takeFirst(), err);
         break;
-    case QVariant::String:
+    case QMetaType::String:
         value = QString(
                 reinterpret_cast<const QChar *>(tmpStorage.rawData.takeFirst().constData()));
         break;
@@ -591,7 +592,7 @@ void QOCIDriverPrivate::allocErrorHandle()
 struct OraFieldInfo
 {
     QString name;
-    QVariant::Type type;
+    QMetaType type;
     ub1 oraIsNull;
     ub4 oraType;
     sb1 oraScale;
@@ -650,53 +651,53 @@ QSqlError qMakeError(const QString& errString, QSqlError::ErrorType type, OCIErr
                      errorCode != -1 ? QString::number(errorCode) : QString());
 }
 
-QVariant::Type qDecodeOCIType(const QString& ocitype, QSql::NumericalPrecisionPolicy precisionPolicy)
+QMetaType qDecodeOCIType(const QString& ocitype, QSql::NumericalPrecisionPolicy precisionPolicy)
 {
-    QVariant::Type type = QVariant::Invalid;
+    int type = QMetaType::UnknownType;
     if (ocitype == QLatin1String("VARCHAR2") || ocitype == QLatin1String("VARCHAR")
          || ocitype.startsWith(QLatin1String("INTERVAL"))
          || ocitype == QLatin1String("CHAR") || ocitype == QLatin1String("NVARCHAR2")
          || ocitype == QLatin1String("NCHAR"))
-        type = QVariant::String;
+        type = QMetaType::QString;
     else if (ocitype == QLatin1String("NUMBER")
              || ocitype == QLatin1String("FLOAT")
              || ocitype == QLatin1String("BINARY_FLOAT")
              || ocitype == QLatin1String("BINARY_DOUBLE")) {
         switch(precisionPolicy) {
             case QSql::LowPrecisionInt32:
-                type = QVariant::Int;
+                type = QMetaType::Int;
                 break;
             case QSql::LowPrecisionInt64:
-                type = QVariant::LongLong;
+                type = QMetaType::LongLong;
                 break;
             case QSql::LowPrecisionDouble:
-                type = QVariant::Double;
+                type = QMetaType::Double;
                 break;
             case QSql::HighPrecision:
             default:
-                type = QVariant::String;
+                type = QMetaType::QString;
                 break;
         }
     }
     else if (ocitype == QLatin1String("LONG") || ocitype == QLatin1String("NCLOB")
              || ocitype == QLatin1String("CLOB"))
-        type = QVariant::ByteArray;
+        type = QMetaType::QByteArray;
     else if (ocitype == QLatin1String("RAW") || ocitype == QLatin1String("LONG RAW")
              || ocitype == QLatin1String("ROWID") || ocitype == QLatin1String("BLOB")
              || ocitype == QLatin1String("CFILE") || ocitype == QLatin1String("BFILE"))
-        type = QVariant::ByteArray;
+        type = QMetaType::QByteArray;
     else if (ocitype == QLatin1String("DATE") ||  ocitype.startsWith(QLatin1String("TIME")))
-        type = QVariant::DateTime;
+        type = QMetaType::QDateTime;
     else if (ocitype == QLatin1String("UNDEFINED"))
-        type = QVariant::Invalid;
-    if (type == QVariant::Invalid)
+        type = QMetaType::UnknownType;
+    if (type == QMetaType::UnknownType)
         qWarning("qDecodeOCIType: unknown type: %s", ocitype.toLocal8Bit().constData());
-    return type;
+    return QMetaType(type);
 }
 
-QVariant::Type qDecodeOCIType(int ocitype, QSql::NumericalPrecisionPolicy precisionPolicy)
+QMetaType qDecodeOCIType(int ocitype, QSql::NumericalPrecisionPolicy precisionPolicy)
 {
-    QVariant::Type type = QVariant::Invalid;
+    int type = QMetaType::UnknownType;
     switch (ocitype) {
     case SQLT_STR:
     case SQLT_VST:
@@ -712,10 +713,10 @@ QVariant::Type qDecodeOCIType(int ocitype, QSql::NumericalPrecisionPolicy precis
 #ifdef SQLT_INTERVAL_DS
     case SQLT_INTERVAL_DS:
 #endif
-        type = QVariant::String;
+        type = QMetaType::QString;
         break;
     case SQLT_INT:
-        type = QVariant::Int;
+        type = QMetaType::Int;
         break;
     case SQLT_FLT:
     case SQLT_NUM:
@@ -723,17 +724,17 @@ QVariant::Type qDecodeOCIType(int ocitype, QSql::NumericalPrecisionPolicy precis
     case SQLT_UIN:
         switch(precisionPolicy) {
             case QSql::LowPrecisionInt32:
-                type = QVariant::Int;
+                type = QMetaType::Int;
                 break;
             case QSql::LowPrecisionInt64:
-                type = QVariant::LongLong;
+                type = QMetaType::LongLong;
                 break;
             case QSql::LowPrecisionDouble:
-                type = QVariant::Double;
+                type = QMetaType::Double;
                 break;
             case QSql::HighPrecision:
             default:
-                type = QVariant::String;
+                type = QMetaType::QString;
                 break;
         }
         break;
@@ -748,21 +749,20 @@ QVariant::Type qDecodeOCIType(int ocitype, QSql::NumericalPrecisionPolicy precis
     case SQLT_NTY:
     case SQLT_REF:
     case SQLT_RID:
-        type = QVariant::ByteArray;
+        type = QMetaType::QByteArray;
         break;
     case SQLT_DAT:
     case SQLT_ODT:
     case SQLT_TIMESTAMP:
     case SQLT_TIMESTAMP_TZ:
     case SQLT_TIMESTAMP_LTZ:
-        type = QVariant::DateTime;
+        type = QMetaType::QDateTime;
         break;
     default:
-        type = QVariant::Invalid;
         qWarning("qDecodeOCIType: unknown OCI datatype: %d", ocitype);
         break;
     }
-        return type;
+        return QMetaType(type);
 }
 
 static QSqlField qFromOraInf(const OraFieldInfo &ofi)
@@ -770,7 +770,7 @@ static QSqlField qFromOraInf(const OraFieldInfo &ofi)
     QSqlField f(ofi.name, ofi.type);
     f.setRequired(ofi.oraIsNull == 0);
 
-    if (ofi.type == QVariant::String && ofi.oraType != SQLT_NUM && ofi.oraType != SQLT_VNU)
+    if (ofi.type.id() == QMetaType::QString && ofi.oraType != SQLT_NUM && ofi.oraType != SQLT_VNU)
         f.setLength(ofi.oraFieldLength);
     else
         f.setLength(ofi.oraPrecision == 0 ? 38 : int(ofi.oraPrecision));
@@ -852,13 +852,13 @@ private:
     class OraFieldInf
     {
     public:
-        OraFieldInf() : data(0), len(0), ind(0), typ(QVariant::Invalid), oraType(0), def(0), lob(0), dataPtr(nullptr)
+        OraFieldInf() : data(0), len(0), ind(0), oraType(0), def(0), lob(0), dataPtr(nullptr)
         {}
         ~OraFieldInf();
         char *data;
         int len;
         sb2 ind;
-        QVariant::Type typ;
+        QMetaType typ;
         ub4 oraType;
         OCIDefine *def;
         OCILobLocator *lob;
@@ -879,9 +879,9 @@ QOCICols::OraFieldInf::~OraFieldInf()
     }
     if (dataPtr) {
         switch (typ) {
-        case QVariant::Date:
-        case QVariant::Time:
-        case QVariant::DateTime: {
+        case QMetaType::QDate:
+        case QMetaType::QTime:
+        case QMetaType::QDateTime: {
             int r = OCIDescriptorFree(dataPtr, OCI_DTYPE_TIMESTAMP_TZ);
             if (r != OCI_SUCCESS)
                 qWarning("QOCICols: Cannot free OCIDateTime descriptor");
@@ -935,8 +935,8 @@ QOCICols::QOCICols(int size, QOCIResultPrivate* dp)
         fieldInf[idx].oraType = ofi.oraType;
         rec.append(qFromOraInf(ofi));
 
-        switch (ofi.type) {
-        case QVariant::DateTime:
+        switch (ofi.type.id()) {
+        case QMetaType::QDateTime:
             r = OCIDescriptorAlloc(d->env, (void **)&fieldInf[idx].dataPtr, OCI_DTYPE_TIMESTAMP_TZ, 0, 0);
             if (r != OCI_SUCCESS) {
                 qWarning("QOCICols: Unable to allocate the OCIDateTime descriptor");
@@ -952,7 +952,7 @@ QOCICols::QOCICols(int size, QOCIResultPrivate* dp)
                                &(fieldInf[idx].ind),
                                0, 0, OCI_DEFAULT);
             break;
-        case QVariant::Double:
+        case QMetaType::Double:
             r = OCIDefineByPos(d->sql,
                                &dfn,
                                d->err,
@@ -963,7 +963,7 @@ QOCICols::QOCICols(int size, QOCIResultPrivate* dp)
                                &(fieldInf[idx].ind),
                                0, 0, OCI_DEFAULT);
             break;
-        case QVariant::Int:
+        case QMetaType::Int:
             r = OCIDefineByPos(d->sql,
                                &dfn,
                                d->err,
@@ -974,7 +974,7 @@ QOCICols::QOCICols(int size, QOCIResultPrivate* dp)
                                &(fieldInf[idx].ind),
                                0, 0, OCI_DEFAULT);
             break;
-        case QVariant::LongLong:
+        case QMetaType::LongLong:
             r = OCIDefineByPos(d->sql,
                                &dfn,
                                d->err,
@@ -985,7 +985,7 @@ QOCICols::QOCICols(int size, QOCIResultPrivate* dp)
                                &(fieldInf[idx].ind),
                                0, 0, OCI_DEFAULT);
             break;
-        case QVariant::ByteArray:
+        case QMetaType::QByteArray:
             // RAW and LONG RAW fields can't be bound to LOB locators
             if (ofi.oraType == SQLT_BIN) {
 //                                qDebug("binding SQLT_BIN");
@@ -1032,7 +1032,7 @@ QOCICols::QOCICols(int size, QOCIResultPrivate* dp)
                                    0, 0, OCI_DEFAULT);
             }
             break;
-        case QVariant::String:
+        case QMetaType::QString:
             if (ofi.oraType == SQLT_LNG) {
                 r = OCIDefineByPos(d->sql,
                         &dfn,
@@ -1192,7 +1192,6 @@ OraFieldInfo QOCICols::qMakeOraField(const QOCIResultPrivate* p, OCIParam* param
     sb2 colPrecision(0);
     ub1 colIsNull(0);
     int r(0);
-    QVariant::Type type(QVariant::Invalid);
 
     r = OCIAttrGet(param,
                    OCI_DTYPE_PARAM,
@@ -1269,28 +1268,26 @@ OraFieldInfo QOCICols::qMakeOraField(const QOCIResultPrivate* p, OCIParam* param
     if (r != 0)
         qOraWarning("qMakeOraField:", p->err);
 
-    type = qDecodeOCIType(colType, p->q_func()->numericalPrecisionPolicy());
+    QMetaType type = qDecodeOCIType(colType, p->q_func()->numericalPrecisionPolicy());
 
-    if (type == QVariant::Int) {
-        if (colLength == 22 && colPrecision == 0 && colScale == 0)
-            type = QVariant::String;
-        if (colScale > 0)
-            type = QVariant::String;
+    if (type.id() == QMetaType::Int) {
+        if ((colLength == 22 && colPrecision == 0 && colScale == 0) || colScale > 0)
+            type = QMetaType(QMetaType::QString);
     }
 
     // bind as double if the precision policy asks for it
     if (((colType == SQLT_FLT) || (colType == SQLT_NUM))
             && (p->q_func()->numericalPrecisionPolicy() == QSql::LowPrecisionDouble)) {
-        type = QVariant::Double;
+        type = QMetaType(QMetaType::Double);
     }
 
     // bind as int32 or int64 if the precision policy asks for it
     if ((colType == SQLT_NUM) || (colType == SQLT_VNU) || (colType == SQLT_UIN)
             || (colType == SQLT_INT)) {
         if (p->q_func()->numericalPrecisionPolicy() == QSql::LowPrecisionInt64)
-            type = QVariant::LongLong;
+            type = QMetaType(QMetaType::LongLong);
         else if (p->q_func()->numericalPrecisionPolicy() == QSql::LowPrecisionInt32)
-            type = QVariant::Int;
+            type = QMetaType(QMetaType::Int);
     }
 
     if (colType == SQLT_BLOB)
@@ -1357,11 +1354,10 @@ bool QOCICols::execBatch(QOCIResultPrivate *d, QVariantList &boundValues, bool a
     int i;
     sword r;
 
-    QVarLengthArray<QVariant::Type> fieldTypes;
+    QVarLengthArray<QMetaType> fieldTypes;
     for (i = 0; i < columnCount; ++i) {
-        QVariant::Type tp = boundValues.at(i).type();
-        fieldTypes.append(tp == QVariant::List ? boundValues.at(i).toList().value(0).type()
-                                               : tp);
+        QMetaType tp = boundValues.at(i).metaType();
+        fieldTypes.append(tp.id() == QMetaType::QVariantList ? boundValues.at(i).toList().value(0).metaType() : tp);
     }
     SizeArray tmpSizes(columnCount);
     QList<QOCIBatchColumn> columns(columnCount);
@@ -1371,7 +1367,7 @@ bool QOCICols::execBatch(QOCIResultPrivate *d, QVariantList &boundValues, bool a
     // figuring out buffer sizes
     for (i = 0; i < columnCount; ++i) {
 
-        if (boundValues.at(i).type() != QVariant::List) {
+        if (boundValues.at(i).typeId() != QMetaType::QVariantList) {
 
             // not a list - create a deep-copy of the single value
             QOCIBatchColumn &singleCol = columns[i];
@@ -1399,45 +1395,40 @@ bool QOCICols::execBatch(QOCIResultPrivate *d, QVariantList &boundValues, bool a
         col.maxarr_len = col.recordCount;
         col.curelep = col.recordCount;
 
-        switch (fieldTypes[i]) {
-            case QVariant::Time:
-            case QVariant::Date:
-            case QVariant::DateTime:
+        switch (fieldTypes[i].id()) {
+            case QMetaType::QTime:
+            case QMetaType::QDate:
+            case QMetaType::QDateTime:
                 col.bindAs = SQLT_TIMESTAMP_TZ;
                 col.maxLen = sizeof(OCIDateTime *);
                 break;
 
-            case QVariant::Int:
+            case QMetaType::Int:
                 col.bindAs = SQLT_INT;
                 col.maxLen = sizeof(int);
                 break;
 
-            case QVariant::UInt:
+            case QMetaType::UInt:
                 col.bindAs = SQLT_UIN;
                 col.maxLen = sizeof(uint);
                 break;
 
-            case QVariant::LongLong:
+            case QMetaType::LongLong:
                 col.bindAs = SQLT_VNU;
                 col.maxLen = sizeof(OCINumber);
                 break;
 
-            case QVariant::ULongLong:
+            case QMetaType::ULongLong:
                 col.bindAs = SQLT_VNU;
                 col.maxLen = sizeof(OCINumber);
                 break;
 
-            case QVariant::Double:
+            case QMetaType::Double:
                 col.bindAs = SQLT_FLT;
                 col.maxLen = sizeof(double);
                 break;
 
-            case QVariant::UserType:
-                col.bindAs = SQLT_RDD;
-                col.maxLen = sizeof(OCIRowid*);
-                break;
-
-            case QVariant::String: {
+            case QMetaType::QString: {
                 col.bindAs = SQLT_STR;
                 for (uint j = 0; j < col.recordCount; ++j) {
                     uint len;
@@ -1451,18 +1442,23 @@ bool QOCICols::execBatch(QOCIResultPrivate *d, QVariantList &boundValues, bool a
                 col.maxLen *= sizeof(QChar);
                 break; }
 
-            case QVariant::ByteArray:
+            case QMetaType::QByteArray:
             default: {
-                col.bindAs = SQLT_LBI;
-                for (uint j = 0; j < col.recordCount; ++j) {
-                    if(d->isOutValue(i))
-                        col.lengths[j] = boundValues.at(i).toList().at(j).toByteArray().capacity();
-                    else
-                        col.lengths[j] = boundValues.at(i).toList().at(j).toByteArray().size();
-                    if (col.lengths[j] > col.maxLen)
-                        col.maxLen = col.lengths[j];
+                if (fieldTypes[i].typeId() >= QMetaType::User) {
+                    col.bindAs = SQLT_RDD;
+                    col.maxLen = sizeof(OCIRowid*);
+                } else {
+                    col.bindAs = SQLT_LBI;
+                    for (uint j = 0; j < col.recordCount; ++j) {
+                        if (d->isOutValue(i))
+                            col.lengths[j] = boundValues.at(i).toList().at(j).toByteArray().capacity();
+                        else
+                            col.lengths[j] = boundValues.at(i).toList().at(j).toByteArray().size();
+                        if (col.lengths[j] > col.maxLen)
+                            col.maxLen = col.lengths[j];
+                    }
                 }
-                break; }
+                break;
         }
 
         col.data = new char[col.maxLen * col.recordCount];
@@ -1478,26 +1474,26 @@ bool QOCICols::execBatch(QOCIResultPrivate *d, QVariantList &boundValues, bool a
             } else {
                 columns[i].indicators[row] = 0;
                 char *dataPtr = columns[i].data + (columns[i].maxLen * row);
-                switch (fieldTypes[i]) {
-                    case QVariant::Time:
-                    case QVariant::Date:
-                    case QVariant::DateTime:{
+                switch (fieldTypes[i].id()) {
+                    case QMetaType::QTime:
+                    case QMetaType::QDate:
+                    case QMetaType::QDateTime:{
                         columns[i].lengths[row] = columns[i].maxLen;
                         QOCIDateTime *date = new QOCIDateTime(d->env, d->err, val.toDateTime());
                         *reinterpret_cast<OCIDateTime**>(dataPtr) = date->dateTime;
                         break;
                     }
-                    case QVariant::Int:
+                    case QMetaType::Int:
                         columns[i].lengths[row] = columns[i].maxLen;
                         *reinterpret_cast<int*>(dataPtr) = val.toInt();
                         break;
 
-                    case QVariant::UInt:
+                    case QMetaType::UInt:
                         columns[i].lengths[row] = columns[i].maxLen;
                         *reinterpret_cast<uint*>(dataPtr) = val.toUInt();
                         break;
 
-                    case QVariant::LongLong:
+                    case QMetaType::LongLong:
                     {
                         columns[i].lengths[row] = columns[i].maxLen;
                         const QByteArray ba = qMakeOCINumber(val.toLongLong(), d->err);
@@ -1505,7 +1501,7 @@ bool QOCICols::execBatch(QOCIResultPrivate *d, QVariantList &boundValues, bool a
                         memcpy(dataPtr, ba.constData(), columns[i].maxLen);
                         break;
                     }
-                    case QVariant::ULongLong:
+                    case QMetaType::ULongLong:
                     {
                         columns[i].lengths[row] = columns[i].maxLen;
                         const QByteArray ba = qMakeOCINumber(val.toULongLong(), d->err);
@@ -1513,29 +1509,31 @@ bool QOCICols::execBatch(QOCIResultPrivate *d, QVariantList &boundValues, bool a
                         memcpy(dataPtr, ba.constData(), columns[i].maxLen);
                         break;
                     }
-                    case QVariant::Double:
+                    case QMetaType::Double:
                          columns[i].lengths[row] = columns[i].maxLen;
                          *reinterpret_cast<double*>(dataPtr) = val.toDouble();
                          break;
 
-                    case QVariant::String: {
+                    case QMetaType::QString: {
                         const QString s = val.toString();
                         columns[i].lengths[row] = (s.length() + 1) * sizeof(QChar);
                         memcpy(dataPtr, s.utf16(), columns[i].lengths[row]);
                         break;
                     }
-                    case QVariant::UserType:
-                        if (val.canConvert<QOCIRowIdPointer>()) {
-                            const QOCIRowIdPointer rptr = qvariant_cast<QOCIRowIdPointer>(val);
-                            *reinterpret_cast<OCIRowid**>(dataPtr) = rptr->id;
-                            columns[i].lengths[row] = 0;
-                            break;
-                        }
-                    case QVariant::ByteArray:
+                    case QMetaType::QByteArray:
                     default: {
-                        const QByteArray ba = val.toByteArray();
-                        columns[i].lengths[row] = ba.size();
-                        memcpy(dataPtr, ba.constData(), ba.size());
+                        if (fieldTypes[i].id() >= QMetaType::User) {
+                            if (val.canConvert<QOCIRowIdPointer>()) {
+                                const QOCIRowIdPointer rptr = qvariant_cast<QOCIRowIdPointer>(val);
+                                *reinterpret_cast<OCIRowid**>(dataPtr) = rptr->id;
+                                columns[i].lengths[row] = 0;
+                                break;
+                            }
+                        } else {
+                            const QByteArray ba = val.toByteArray();
+                            columns[i].lengths[row] = ba.size();
+                            memcpy(dataPtr, ba.constData(), ba.size());
+                        }
                         break;
                     }
                 }
@@ -1618,7 +1616,7 @@ bool QOCICols::execBatch(QOCIResultPrivate *d, QVariantList &boundValues, bool a
         if (!d->isOutValue(i))
             continue;
 
-        if (auto tp = boundValues.at(i).metaType(); tp.id() != QVariant::List) {
+        if (auto tp = boundValues.at(i).metaType(); tp.id() != QMetaType::QVariantList) {
             qOraOutValue(boundValues[i], tmpStorage, d->env, d->err);
             if (*columns[i].indicators == -1)
                 boundValues[i] = QVariant(tp);
@@ -1651,11 +1649,11 @@ bool QOCICols::execBatch(QOCIResultPrivate *d, QVariantList &boundValues, bool a
 
                 case SQLT_VNU:
                 {
-                    switch (boundValues.at(i).type()) {
-                    case QVariant::LongLong:
+                    switch (boundValues.at(i).typeId()) {
+                    case QMetaType::LongLong:
                         (*list)[r] =  qMakeLongLong(data + r * columns[i].maxLen, d->err);
                         break;
-                    case QVariant::ULongLong:
+                    case QMetaType::ULongLong:
                         (*list)[r] =  qMakeULongLong(data + r * columns[i].maxLen, d->err);
                         break;
                     default:
@@ -1791,21 +1789,21 @@ void QOCICols::getValues(QVariantList &v, int index)
         if (fld.oraType == SQLT_BIN || fld.oraType == SQLT_LBI || fld.oraType == SQLT_LNG)
             continue; // already fetched piecewise
 
-        switch (fld.typ) {
-        case QVariant::DateTime:
+        switch (fld.typ.id()) {
+        case QMetaType::QDateTime:
             v[index + i] = QVariant(QOCIDateTime::fromOCIDateTime(d->env, d->err,
                                         reinterpret_cast<OCIDateTime *>(fld.dataPtr)));
             break;
-        case QVariant::Double:
-        case QVariant::Int:
-        case QVariant::LongLong:
+        case QMetaType::Double:
+        case QMetaType::Int:
+        case QMetaType::LongLong:
             if (d->q_func()->numericalPrecisionPolicy() != QSql::HighPrecision) {
                 if ((d->q_func()->numericalPrecisionPolicy() == QSql::LowPrecisionDouble)
-                        && (fld.typ == QVariant::Double)) {
+                        && (fld.typ.id() == QMetaType::Double)) {
                     v[index + i] = *reinterpret_cast<double *>(fld.data);
                     break;
                 } else if ((d->q_func()->numericalPrecisionPolicy() == QSql::LowPrecisionInt64)
-                        && (fld.typ == QVariant::LongLong)) {
+                        && (fld.typ.id() == QMetaType::LongLong)) {
                     qint64 qll = 0;
                     int r = OCINumberToInt(d->err, reinterpret_cast<OCINumber *>(fld.data), sizeof(qint64),
                                    OCI_NUMBER_SIGNED, &qll);
@@ -1815,20 +1813,20 @@ void QOCICols::getValues(QVariantList &v, int index)
                         v[index + i] = QVariant();
                     break;
                 } else if ((d->q_func()->numericalPrecisionPolicy() == QSql::LowPrecisionInt32)
-                        && (fld.typ == QVariant::Int)) {
+                        && (fld.typ.id() == QMetaType::Int)) {
                     v[index + i] = *reinterpret_cast<int *>(fld.data);
                     break;
                 }
             }
             // else fall through
-        case QVariant::String:
+        case QMetaType::QString:
             v[index + i] = QString(reinterpret_cast<const QChar *>(fld.data));
             break;
-        case QVariant::ByteArray:
+        case QMetaType::QByteArray:
             if (fld.len > 0)
                 v[index + i] = QByteArray(fld.data, fld.len);
             else
-                v[index + i] = QVariant(QVariant::ByteArray);
+                v[index + i] = QVariant(QMetaType::QByteArray);
             break;
         default:
             qWarning("QOCICols::value: unknown data type");
@@ -2617,11 +2615,11 @@ QSqlRecord QOCIDriver::record(const QString& tablename) const
               << QLatin1String("BINARY_DOUBLE");
     if (buildRecordInfo) {
         do {
-            QVariant::Type ty = qDecodeOCIType(t.value(1).toString(), t.numericalPrecisionPolicy());
+            QMetaType ty = qDecodeOCIType(t.value(1).toString(), t.numericalPrecisionPolicy());
             QSqlField f(t.value(0).toString(), ty);
             f.setRequired(t.value(5).toString() == QLatin1String("N"));
             f.setPrecision(t.value(4).toInt());
-            if (d->serverVersion >= 9 && (ty == QVariant::String) && !t.isNull(3) && !keywords.contains(t.value(1).toString())) {
+            if (d->serverVersion >= 9 && (ty.id() == QMetaType::QString) && !t.isNull(3) && !keywords.contains(t.value(1).toString())) {
                 // Oracle9: data_length == size in bytes, char_length == amount of characters
                 f.setLength(t.value(7).toInt());
             } else {
@@ -2704,8 +2702,8 @@ QSqlIndex QOCIDriver::primaryIndex(const QString& tablename) const
 
 QString QOCIDriver::formatValue(const QSqlField &field, bool trimStrings) const
 {
-    switch (field.type()) {
-    case QVariant::DateTime: {
+    switch (field.typeId()) {
+    case QMetaType::QDateTime: {
         QDateTime datetime = field.value().toDateTime();
         QString datestring;
         if (datetime.isValid()) {
@@ -2722,7 +2720,7 @@ QString QOCIDriver::formatValue(const QSqlField &field, bool trimStrings) const
         }
         return datestring;
     }
-    case QVariant::Time: {
+    case QMetaType::QTime: {
         QDateTime datetime = field.value().toDateTime();
         QString datestring;
         if (datetime.isValid()) {
@@ -2736,7 +2734,7 @@ QString QOCIDriver::formatValue(const QSqlField &field, bool trimStrings) const
         }
         return datestring;
     }
-    case QVariant::Date: {
+    case QMetaType::QDate: {
         QDate date = field.value().toDate();
         QString datestring;
         if (date.isValid()) {