remove ORowSetValue implicit conversion methods

in favour of the existing get*() methods.
The get*() methods 0 or false or empty in the case of "null", which
is exactly the same behaviour as the conversion methods.

These implicit conversion methods cause lookup problems when combined
with some upcoming OUString changes.
And the code looks cleaner this way too, and has less magic when calling
methods.

Change-Id: Ieb4756bf693e83b996a32667fc1b955f89193496
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/125690
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>

9 files changed, 95 insertions, 96 deletions

diff --git a/dbaccess/source/core/api/BookmarkSet.cxx b/dbaccess/source/core/api/BookmarkSet.cxx
index b21d7cbbb666..75dfc24f5869 100644
--- a/dbaccess/source/core/api/BookmarkSet.cxx
+++ b/dbaccess/source/core/api/BookmarkSet.cxx
@@ -142,56 +142,56 @@ void OBookmarkSet::updateColumn(sal_Int32 nPos, const Reference< XRowUpdate >& _
                 break;
             case DataType::CHAR:
             case DataType::VARCHAR:
-                _xParameter->updateString(nPos,_rValue);
+                _xParameter->updateString(nPos,_rValue.getString());
                 break;
             case DataType::BIGINT:
                 if ( _rValue.isSigned() )
-                    _xParameter->updateLong(nPos,_rValue);
+                    _xParameter->updateLong(nPos,_rValue.getLong());
                 else
-                    _xParameter->updateString(nPos,_rValue);
+                    _xParameter->updateString(nPos,_rValue.getString());
                 break;
             case DataType::BIT:
             case DataType::BOOLEAN:
-                _xParameter->updateBoolean(nPos,bool(_rValue));
+                _xParameter->updateBoolean(nPos,_rValue.getBool());
                 break;
             case DataType::TINYINT:
                 if ( _rValue.isSigned() )
-                    _xParameter->updateByte(nPos,_rValue);
+                    _xParameter->updateByte(nPos,_rValue.getInt8());
                 else
-                    _xParameter->updateShort(nPos,_rValue);
+                    _xParameter->updateShort(nPos,_rValue.getInt16());
                 break;
             case DataType::SMALLINT:
                 if ( _rValue.isSigned() )
-                    _xParameter->updateShort(nPos,_rValue);
+                    _xParameter->updateShort(nPos,_rValue.getInt16());
                 else
-                    _xParameter->updateInt(nPos,_rValue);
+                    _xParameter->updateInt(nPos,_rValue.getInt32());
                 break;
             case DataType::INTEGER:
                 if ( _rValue.isSigned() )
-                    _xParameter->updateInt(nPos,_rValue);
+                    _xParameter->updateInt(nPos,_rValue.getInt32());
                 else
-                    _xParameter->updateLong(nPos,_rValue);
+                    _xParameter->updateLong(nPos,_rValue.getLong());
                 break;
             case DataType::FLOAT:
-                _xParameter->updateFloat(nPos,_rValue);
+                _xParameter->updateFloat(nPos,_rValue.getFloat());
                 break;
             case DataType::DOUBLE:
             case DataType::REAL:
-                _xParameter->updateDouble(nPos,_rValue);
+                _xParameter->updateDouble(nPos,_rValue.getDouble());
                 break;
             case DataType::DATE:
-                _xParameter->updateDate(nPos,_rValue);
+                _xParameter->updateDate(nPos,_rValue.getDate());
                 break;
             case DataType::TIME:
-                _xParameter->updateTime(nPos,_rValue);
+                _xParameter->updateTime(nPos,_rValue.getTime());
                 break;
             case DataType::TIMESTAMP:
-                _xParameter->updateTimestamp(nPos,_rValue);
+                _xParameter->updateTimestamp(nPos,_rValue.getDateTime());
                 break;
             case DataType::BINARY:
             case DataType::VARBINARY:
             case DataType::LONGVARBINARY:
-                _xParameter->updateBytes(nPos,_rValue);
+                _xParameter->updateBytes(nPos,_rValue.getSequence());
                 break;
             case DataType::BLOB:
             case DataType::CLOB:
diff --git a/dbaccess/source/core/api/PrivateRow.cxx b/dbaccess/source/core/api/PrivateRow.cxx
index 22adc74f138a..9bf2709606bd 100644
--- a/dbaccess/source/core/api/PrivateRow.cxx
+++ b/dbaccess/source/core/api/PrivateRow.cxx
@@ -37,62 +37,62 @@ sal_Bool SAL_CALL OPrivateRow::wasNull(  )
     OUString SAL_CALL OPrivateRow::getString( ::sal_Int32 columnIndex )
     {
         m_nPos = columnIndex;
-        return m_aRow[m_nPos];
+        return m_aRow[m_nPos].getString();
     }
     sal_Bool SAL_CALL OPrivateRow::getBoolean( ::sal_Int32 columnIndex )
     {
         m_nPos = columnIndex;
-        return bool(m_aRow[m_nPos]);
+        return m_aRow[m_nPos].getBool();
     }
     ::sal_Int8 SAL_CALL OPrivateRow::getByte( ::sal_Int32 columnIndex )
     {
         m_nPos = columnIndex;
-        return m_aRow[m_nPos];
+        return m_aRow[m_nPos].getInt8();
     }
     ::sal_Int16 SAL_CALL OPrivateRow::getShort( ::sal_Int32 columnIndex )
     {
         m_nPos = columnIndex;
-        return m_aRow[m_nPos];
+        return m_aRow[m_nPos].getInt16();
     }
     ::sal_Int32 SAL_CALL OPrivateRow::getInt( ::sal_Int32 columnIndex )
     {
         m_nPos = columnIndex;
-        return m_aRow[m_nPos];
+        return m_aRow[m_nPos].getInt32();
     }
     ::sal_Int64 SAL_CALL OPrivateRow::getLong( ::sal_Int32 columnIndex )
     {
         m_nPos = columnIndex;
-        return m_aRow[m_nPos];
+        return m_aRow[m_nPos].getLong();
     }
     float SAL_CALL OPrivateRow::getFloat( ::sal_Int32 columnIndex )
     {
         m_nPos = columnIndex;
-        return m_aRow[m_nPos];
+        return m_aRow[m_nPos].getFloat();
     }
     double SAL_CALL OPrivateRow::getDouble( ::sal_Int32 columnIndex )
     {
         m_nPos = columnIndex;
-        return m_aRow[m_nPos];
+        return m_aRow[m_nPos].getDouble();
     }
     Sequence< ::sal_Int8 > SAL_CALL OPrivateRow::getBytes( ::sal_Int32 columnIndex )
     {
         m_nPos = columnIndex;
-        return m_aRow[m_nPos];
+        return m_aRow[m_nPos].getSequence();
     }
     css::util::Date SAL_CALL OPrivateRow::getDate( ::sal_Int32 columnIndex )
     {
         m_nPos = columnIndex;
-        return m_aRow[m_nPos];
+        return m_aRow[m_nPos].getDate();
     }
     css::util::Time SAL_CALL OPrivateRow::getTime( ::sal_Int32 columnIndex )
     {
         m_nPos = columnIndex;
-        return m_aRow[m_nPos];
+        return m_aRow[m_nPos].getTime();
     }
     css::util::DateTime SAL_CALL OPrivateRow::getTimestamp( ::sal_Int32 columnIndex )
     {
         m_nPos = columnIndex;
-        return m_aRow[m_nPos];
+        return m_aRow[m_nPos].getDateTime();
     }
     Reference< css::io::XInputStream > SAL_CALL OPrivateRow::getBinaryStream( ::sal_Int32 columnIndex )
     {
diff --git a/dbaccess/source/core/api/RowSet.cxx b/dbaccess/source/core/api/RowSet.cxx
index 4630bee25e94..e3885108f636 100644
--- a/dbaccess/source/core/api/RowSet.cxx
+++ b/dbaccess/source/core/api/RowSet.cxx
@@ -1300,74 +1300,73 @@ const ORowSetValue& ORowSet::getInsertValue(sal_Int32 columnIndex)
 OUString SAL_CALL ORowSet::getString( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getInsertValue(columnIndex);
+    return getInsertValue(columnIndex).getString();
 }
 
 sal_Bool SAL_CALL ORowSet::getBoolean( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    // the extra cast is to recognise the "true" or "false" strings
-    return static_cast<bool>(getInsertValue(columnIndex));
+    return getInsertValue(columnIndex).getBool();
 }
 
 sal_Int8 SAL_CALL ORowSet::getByte( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getInsertValue(columnIndex);
+    return getInsertValue(columnIndex).getInt8();
 }
 
 sal_Int16 SAL_CALL ORowSet::getShort( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getInsertValue(columnIndex);
+    return getInsertValue(columnIndex).getInt16();
 }
 
 sal_Int32 SAL_CALL ORowSet::getInt( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getInsertValue(columnIndex);
+    return getInsertValue(columnIndex).getInt32();
 }
 
 sal_Int64 SAL_CALL ORowSet::getLong( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getInsertValue(columnIndex);
+    return getInsertValue(columnIndex).getLong();
 }
 
 float SAL_CALL ORowSet::getFloat( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getInsertValue(columnIndex);
+    return getInsertValue(columnIndex).getFloat();
 }
 
 double SAL_CALL ORowSet::getDouble( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getInsertValue(columnIndex);
+    return getInsertValue(columnIndex).getDouble();
 }
 
 Sequence< sal_Int8 > SAL_CALL ORowSet::getBytes( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getInsertValue(columnIndex);
+    return getInsertValue(columnIndex).getSequence();
 }
 
 css::util::Date SAL_CALL ORowSet::getDate( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getInsertValue(columnIndex);
+    return getInsertValue(columnIndex).getDate();
 }
 
 css::util::Time SAL_CALL ORowSet::getTime( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getInsertValue(columnIndex);
+    return getInsertValue(columnIndex).getTime();
 }
 
 css::util::DateTime SAL_CALL ORowSet::getTimestamp( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getInsertValue(columnIndex);
+    return getInsertValue(columnIndex).getDateTime();
 }
 
 Reference< css::io::XInputStream > SAL_CALL ORowSet::getBinaryStream( sal_Int32 columnIndex )
diff --git a/dbaccess/source/core/api/RowSetBase.cxx b/dbaccess/source/core/api/RowSetBase.cxx
index d1feea15ae59..cae0d29eb3b7 100644
--- a/dbaccess/source/core/api/RowSetBase.cxx
+++ b/dbaccess/source/core/api/RowSetBase.cxx
@@ -250,73 +250,73 @@ const ORowSetValue& ORowSetBase::impl_getValue(sal_Int32 columnIndex)
 OUString SAL_CALL ORowSetBase::getString( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getValue(columnIndex);
+    return getValue(columnIndex).getString();
 }
 
 sal_Bool SAL_CALL ORowSetBase::getBoolean( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return bool(getValue(columnIndex));
+    return getValue(columnIndex).getBool();
 }
 
 sal_Int8 SAL_CALL ORowSetBase::getByte( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getValue(columnIndex);
+    return getValue(columnIndex).getInt8();
 }
 
 sal_Int16 SAL_CALL ORowSetBase::getShort( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getValue(columnIndex);
+    return getValue(columnIndex).getInt16();
 }
 
 sal_Int32 SAL_CALL ORowSetBase::getInt( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getValue(columnIndex);
+    return getValue(columnIndex).getInt32();
 }
 
 sal_Int64 SAL_CALL ORowSetBase::getLong( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getValue(columnIndex);
+    return getValue(columnIndex).getLong();
 }
 
 float SAL_CALL ORowSetBase::getFloat( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getValue(columnIndex);
+    return getValue(columnIndex).getFloat();
 }
 
 double SAL_CALL ORowSetBase::getDouble( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getValue(columnIndex);
+    return getValue(columnIndex).getDouble();
 }
 
 Sequence< sal_Int8 > SAL_CALL ORowSetBase::getBytes( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getValue(columnIndex);
+    return getValue(columnIndex).getSequence();
 }
 
 css::util::Date SAL_CALL ORowSetBase::getDate( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getValue(columnIndex);
+    return getValue(columnIndex).getDate();
 }
 
 css::util::Time SAL_CALL ORowSetBase::getTime( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getValue(columnIndex);
+    return getValue(columnIndex).getTime();
 }
 
 css::util::DateTime SAL_CALL ORowSetBase::getTimestamp( sal_Int32 columnIndex )
 {
     ::osl::MutexGuard aGuard( *m_pMutex );
-    return getValue(columnIndex);
+    return getValue(columnIndex).getDateTime();
 }
 
 Reference< css::io::XInputStream > SAL_CALL ORowSetBase::getBinaryStream( sal_Int32 columnIndex )
diff --git a/dbaccess/source/core/api/RowSetCache.cxx b/dbaccess/source/core/api/RowSetCache.cxx
index b588cc0320e6..1df68462a444 100644
--- a/dbaccess/source/core/api/RowSetCache.cxx
+++ b/dbaccess/source/core/api/RowSetCache.cxx
@@ -455,7 +455,7 @@ static Any lcl_getBookmark(ORowSetValue& i_aValue,OCacheSet* i_pCacheSet)
         case DataType::TINYINT:
         case DataType::SMALLINT:
         case DataType::INTEGER:
-            return makeAny(static_cast<sal_Int32>(i_aValue));
+            return makeAny(i_aValue.getInt32());
         default:
             if ( i_pCacheSet && i_aValue.isNull())
                 i_aValue = i_pCacheSet->getBookmark();
diff --git a/dbaccess/source/core/api/StaticSet.cxx b/dbaccess/source/core/api/StaticSet.cxx
index 61cfb0af736f..82948e6f1d4e 100644
--- a/dbaccess/source/core/api/StaticSet.cxx
+++ b/dbaccess/source/core/api/StaticSet.cxx
@@ -80,7 +80,7 @@ bool OStaticSet::fetchRow()
         m_aSet.push_back(new connectivity::ORowVector< connectivity::ORowSetValue >(m_xSetMetaData->getColumnCount()));
         m_aSetIter = m_aSet.end() - 1;
         (**m_aSetIter)[0] = getRow();
-        OCacheSet::fillValueRow(*m_aSetIter,(**m_aSetIter)[0]);
+        OCacheSet::fillValueRow(*m_aSetIter,(**m_aSetIter)[0].getInt32());
     }
     else
         m_bEnd = true;
@@ -99,7 +99,7 @@ void OStaticSet::fillAllRows()
         m_aSet.push_back(pRow);
         m_aSetIter = m_aSet.end() - 1;
         (*pRow)[0] = getRow();
-        OCacheSet::fillValueRow(pRow,(*pRow)[0]);
+        OCacheSet::fillValueRow(pRow,(*pRow)[0].getInt32());
     }
     m_bEnd = true;
 }
diff --git a/dbaccess/source/core/api/WrappedResultSet.cxx b/dbaccess/source/core/api/WrappedResultSet.cxx
index a0999e5f32aa..b97fb4182d68 100644
--- a/dbaccess/source/core/api/WrappedResultSet.cxx
+++ b/dbaccess/source/core/api/WrappedResultSet.cxx
@@ -122,56 +122,56 @@ void WrappedResultSet::updateColumn(sal_Int32 nPos, const Reference< XRowUpdate
                 break;
             case DataType::CHAR:
             case DataType::VARCHAR:
-                _xParameter->updateString(nPos,_rValue);
+                _xParameter->updateString(nPos,_rValue.getString());
                 break;
             case DataType::BIGINT:
                 if ( _rValue.isSigned() )
-                    _xParameter->updateLong(nPos,_rValue);
+                    _xParameter->updateLong(nPos,_rValue.getLong());
                 else
-                    _xParameter->updateString(nPos,_rValue);
+                    _xParameter->updateString(nPos,_rValue.getString());
                 break;
             case DataType::BIT:
             case DataType::BOOLEAN:
-                _xParameter->updateBoolean(nPos,static_cast<bool>(_rValue));
+                _xParameter->updateBoolean(nPos,_rValue.getBool());
                 break;
             case DataType::TINYINT:
                 if ( _rValue.isSigned() )
-                    _xParameter->updateByte(nPos,_rValue);
+                    _xParameter->updateByte(nPos,_rValue.getInt8());
                 else
-                    _xParameter->updateShort(nPos,_rValue);
+                    _xParameter->updateShort(nPos,_rValue.getInt16());
                 break;
             case DataType::SMALLINT:
                 if ( _rValue.isSigned() )
-                    _xParameter->updateShort(nPos,_rValue);
+                    _xParameter->updateShort(nPos,_rValue.getInt16());
                 else
-                    _xParameter->updateInt(nPos,_rValue);
+                    _xParameter->updateInt(nPos,_rValue.getInt32());
                 break;
             case DataType::INTEGER:
                 if ( _rValue.isSigned() )
-                    _xParameter->updateInt(nPos,_rValue);
+                    _xParameter->updateInt(nPos,_rValue.getInt32());
                 else
-                    _xParameter->updateLong(nPos,_rValue);
+                    _xParameter->updateLong(nPos,_rValue.getLong());
                 break;
             case DataType::FLOAT:
-                _xParameter->updateFloat(nPos,_rValue);
+                _xParameter->updateFloat(nPos,_rValue.getFloat());
                 break;
             case DataType::DOUBLE:
             case DataType::REAL:
-                _xParameter->updateDouble(nPos,_rValue);
+                _xParameter->updateDouble(nPos,_rValue.getDouble());
                 break;
             case DataType::DATE:
-                _xParameter->updateDate(nPos,_rValue);
+                _xParameter->updateDate(nPos,_rValue.getDate());
                 break;
             case DataType::TIME:
-                _xParameter->updateTime(nPos,_rValue);
+                _xParameter->updateTime(nPos,_rValue.getTime());
                 break;
             case DataType::TIMESTAMP:
-                _xParameter->updateTimestamp(nPos,_rValue);
+                _xParameter->updateTimestamp(nPos,_rValue.getDateTime());
                 break;
             case DataType::BINARY:
             case DataType::VARBINARY:
             case DataType::LONGVARBINARY:
-                _xParameter->updateBytes(nPos,_rValue);
+                _xParameter->updateBytes(nPos,_rValue.getSequence());
                 break;
             case DataType::BLOB:
             case DataType::CLOB:
diff --git a/dbaccess/source/ui/misc/DExport.cxx b/dbaccess/source/ui/misc/DExport.cxx
index e899af729f2f..114c793b0af7 100644
--- a/dbaccess/source/ui/misc/DExport.cxx
+++ b/dbaccess/source/ui/misc/DExport.cxx
@@ -189,11 +189,11 @@ ODatabaseExport::ODatabaseExport(const SharedConnection& _rxConnection,
             sal_Int32 nPos = 1;
             OSL_ENSURE((nPos) < static_cast<sal_Int32>(aTypes.size()),"aTypes: Illegal index for vector");
             aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-            OUString sTypeName = aValue;
+            OUString sTypeName = aValue.getString();
             ++nPos;
             OSL_ENSURE((nPos) < static_cast<sal_Int32>(aTypes.size()),"aTypes: Illegal index for vector");
             aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-            sal_Int32 nType = aValue;
+            sal_Int32 nType = aValue.getInt32();
             ++nPos;
 
             if( nType == DataType::VARCHAR )
@@ -205,44 +205,44 @@ ODatabaseExport::ODatabaseExport(const SharedConnection& _rxConnection,
 
                 OSL_ENSURE((nPos) < static_cast<sal_Int32>(aTypes.size()),"aTypes: Illegal index for vector");
                 aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-                m_pTypeInfo->nPrecision     = aValue;
+                m_pTypeInfo->nPrecision     = aValue.getInt32();
                 ++nPos;
                 aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow); //LiteralPrefix
                 ++nPos;
                 aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow); //LiteralSuffix
                 ++nPos;
                 aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-                m_pTypeInfo->aCreateParams  = aValue;
+                m_pTypeInfo->aCreateParams  = aValue.getString();
                 ++nPos;
                 aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-                m_pTypeInfo->bNullable      = static_cast<sal_Int32>(aValue) == ColumnValue::NULLABLE;
+                m_pTypeInfo->bNullable      = aValue.getInt32() == ColumnValue::NULLABLE;
                 ++nPos;
                 aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
                 // bCaseSensitive
                 ++nPos;
                 aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-                m_pTypeInfo->nSearchType    = aValue;
+                m_pTypeInfo->nSearchType    = aValue.getInt16();
                 ++nPos;
                 aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
                 // bUnsigned
                 ++nPos;
                 aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-                m_pTypeInfo->bCurrency      = aValue;
+                m_pTypeInfo->bCurrency      = aValue.getBool();
                 ++nPos;
                 aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-                m_pTypeInfo->bAutoIncrement = aValue;
+                m_pTypeInfo->bAutoIncrement = aValue.getBool();
                 ++nPos;
                 aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-                m_pTypeInfo->aLocalTypeName = aValue;
+                m_pTypeInfo->aLocalTypeName = aValue.getString();
                 ++nPos;
                 aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-                m_pTypeInfo->nMinimumScale  = aValue;
+                m_pTypeInfo->nMinimumScale  = aValue.getInt16();
                 ++nPos;
                 aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-                m_pTypeInfo->nMaximumScale  = aValue;
+                m_pTypeInfo->nMaximumScale  = aValue.getInt16();
                 nPos = 18;
                 aValue.fill(nPos,aTypes[nPos],xRow);
-                m_pTypeInfo->nNumPrecRadix  = aValue;
+                m_pTypeInfo->nNumPrecRadix  = aValue.getInt32();
 
                 // check if values are less than zero like it happens in a oracle jdbc driver
                 if( m_pTypeInfo->nPrecision < 0)
diff --git a/dbaccess/source/ui/misc/UITools.cxx b/dbaccess/source/ui/misc/UITools.cxx
index 7c9a09cc8484..038f03ce1cf2 100644
--- a/dbaccess/source/ui/misc/UITools.cxx
+++ b/dbaccess/source/ui/misc/UITools.cxx
@@ -432,52 +432,52 @@ void fillTypeInfo(  const Reference< css::sdbc::XConnection>& _rxConnection,
         }
 
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-        pInfo->aTypeName        = aValue;
+        pInfo->aTypeName        = aValue.getString();
         ++nPos;
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-        pInfo->nType            = aValue;
+        pInfo->nType            = aValue.getInt32();
         ++nPos;
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-        pInfo->nPrecision       = aValue;
+        pInfo->nPrecision       = aValue.getInt32();
         ++nPos;
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow); // LiteralPrefix
         ++nPos;
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow); //LiteralSuffix
         ++nPos;
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-        pInfo->aCreateParams    = aValue;
+        pInfo->aCreateParams    = aValue.getString();
         ++nPos;
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-        pInfo->bNullable        = static_cast<sal_Int32>(aValue) == ColumnValue::NULLABLE;
+        pInfo->bNullable        = aValue.getInt32() == ColumnValue::NULLABLE;
         ++nPos;
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
         // bCaseSensitive
         ++nPos;
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-        pInfo->nSearchType      = aValue;
+        pInfo->nSearchType      = aValue.getInt16();
         ++nPos;
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
         // bUnsigned
         ++nPos;
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-        pInfo->bCurrency        = static_cast<bool>(aValue);
+        pInfo->bCurrency        = aValue.getBool();
         ++nPos;
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-        pInfo->bAutoIncrement   = static_cast<bool>(aValue);
+        pInfo->bAutoIncrement   = aValue.getBool();
         ++nPos;
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-        pInfo->aLocalTypeName   = aValue;
+        pInfo->aLocalTypeName   = aValue.getString();
         ++nPos;
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-        pInfo->nMinimumScale    = aValue;
+        pInfo->nMinimumScale    = aValue.getInt16();
         ++nPos;
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-        pInfo->nMaximumScale    = aValue;
+        pInfo->nMaximumScale    = aValue.getInt16();
         assert(nPos == 15);
         // 16 and 17 are unused
         nPos = 18;
         aValue.fill(nPos,aTypes[nPos],aNullable[nPos],xRow);
-        pInfo->nNumPrecRadix    = aValue;
+        pInfo->nNumPrecRadix    = aValue.getInt32();
 
         // check if values are less than zero like it happens in a oracle jdbc driver
         if( pInfo->nPrecision < 0)