/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <string.h>
#include <connectivity/FValue.hxx>
#include <connectivity/dbconversion.hxx>
#include <comphelper/extract.hxx>
#include <com/sun/star/io/XInputStream.hpp>
#include <com/sun/star/sdbc/XClob.hpp>
#include <com/sun/star/sdbc/XBlob.hpp>
#include <com/sun/star/sdb/XColumn.hpp>
#include <com/sun/star/sdbc/XRow.hpp>
#include <rtl/ustrbuf.hxx>
#include <sal/log.hxx>
#include <osl/diagnose.h>
using namespace ::dbtools;
using namespace ::com::sun::star::sdbc;
using namespace ::com::sun::star::sdb;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::util;
using namespace ::com::sun::star::io;
namespace connectivity
{
namespace {
bool isStorageCompatible(sal_Int32 _eType1, sal_Int32 _eType2)
{
bool bIsCompatible =
true;
if (_eType1 != _eType2)
{
SAL_INFO(
"connectivity.commontools",
"ORowSetValue::isStorageCompatible _eType1 != _eType2" );
switch (_eType1)
{
case DataType::
CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
bIsCompatible = (DataType::
CHAR == _eType2)
|| (DataType::VARCHAR == _eType2)
|| (DataType::DECIMAL == _eType2)
|| (DataType::NUMERIC == _eType2)
|| (DataType::LONGVARCHAR == _eType2);
break;
case DataType::
DOUBLE:
case DataType::REAL:
bIsCompatible = (DataType::
DOUBLE == _eType2)
|| (DataType::REAL == _eType2);
break;
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
bIsCompatible = (DataType::BINARY == _eType2)
|| (DataType::VARBINARY == _eType2)
|| (DataType::LONGVARBINARY == _eType2);
break;
case DataType::INTEGER:
bIsCompatible = (DataType::SMALLINT == _eType2)
|| (DataType::TINYINT == _eType2)
|| (DataType::BIT == _eType2)
|| (DataType::BOOLEAN == _eType2);
break;
case DataType::SMALLINT:
bIsCompatible = (DataType::TINYINT == _eType2)
|| (DataType::BIT == _eType2)
|| (DataType::BOOLEAN == _eType2);
break;
case DataType::TINYINT:
bIsCompatible = (DataType::BIT == _eType2)
|| (DataType::BOOLEAN == _eType2);
break;
case DataType::BLOB:
case DataType::CLOB:
case DataType::OBJECT:
bIsCompatible = (DataType::BLOB == _eType2)
|| (DataType::CLOB == _eType2)
|| (DataType::OBJECT == _eType2);
break;
default:
bIsCompatible =
false;
}
}
return bIsCompatible;
}
bool isStorageComparable(sal_Int32 _eType1, sal_Int32 _eType2)
{
bool bIsComparable =
true;
if (_eType1 != _eType2)
{
SAL_INFO(
"connectivity.commontools",
"ORowSetValue::isStorageCompatible _eType1 != _eType2" );
switch (_eType1)
{
case DataType::
CHAR:
case DataType::VARCHAR:
case DataType::LONGVARCHAR:
bIsComparable = (DataType::
CHAR == _eType2)
|| (DataType::VARCHAR == _eType2)
|| (DataType::LONGVARCHAR == _eType2);
break;
case DataType::DECIMAL:
case DataType::NUMERIC:
bIsComparable = (DataType::DECIMAL == _eType2)
|| (DataType::NUMERIC == _eType2);
break;
case DataType::
DOUBLE:
case DataType::REAL:
bIsComparable = (DataType::
DOUBLE == _eType2)
|| (DataType::REAL == _eType2);
break;
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
bIsComparable = (DataType::BINARY == _eType2)
|| (DataType::VARBINARY == _eType2)
|| (DataType::LONGVARBINARY == _eType2);
break;
case DataType::INTEGER:
bIsComparable = (DataType::SMALLINT == _eType2)
|| (DataType::TINYINT == _eType2)
|| (DataType::BIT == _eType2)
|| (DataType::BOOLEAN == _eType2);
break;
case DataType::SMALLINT:
bIsComparable = (DataType::TINYINT == _eType2)
|| (DataType::BIT == _eType2)
|| (DataType::BOOLEAN == _eType2);
break;
case DataType::TINYINT:
bIsComparable = (DataType::BIT == _eType2)
|| (DataType::BOOLEAN == _eType2);
break;
case DataType::BLOB:
case DataType::CLOB:
case DataType::OBJECT:
bIsComparable = (DataType::BLOB == _eType2)
|| (DataType::CLOB == _eType2)
|| (DataType::OBJECT == _eType2);
break;
default:
bIsComparable =
false;
}
}
return bIsComparable;
}
}
void ORowSetValue::setTypeKind(sal_Int32 _eType)
{
if ( !m_bNull && !isStorageCompatible(_eType, m_eTypeKind) )
{
switch(_eType)
{
case DataType::VARCHAR:
case DataType::
CHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
(*
this) = getString();
break;
case DataType::BIGINT:
{
sal_Int64 nVal(getLong());
sal_uInt64 nuVal(getULong());
if (nVal ==
0 && nuVal !=
0)
(*
this) = nuVal;
else
(*
this) = nVal;
break;
}
case DataType::
FLOAT:
(*
this) = getFloat();
break;
case DataType::
DOUBLE:
case DataType::REAL:
(*
this) = getDouble();
break;
case DataType::TINYINT:
(*
this) = getInt8();
break;
case DataType::SMALLINT:
(*
this) = getInt16();
break;
case DataType::INTEGER:
{
sal_Int32 nVal(getInt32());
sal_uInt32 nuVal(getUInt32());
if (nVal ==
0 && nuVal !=
0)
(*
this) = nuVal;
else
(*
this) = nVal;
break;
}
case DataType::BIT:
case DataType::BOOLEAN:
(*
this) = getBool();
break;
case DataType::DATE:
(*
this) = getDate();
break;
case DataType::TIME:
(*
this) = getTime();
break;
case DataType::TIMESTAMP:
(*
this) = getDateTime();
break;
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
(*
this) = getSequence();
break;
case DataType::BLOB:
case DataType::CLOB:
case DataType::OBJECT:
case DataType::OTHER:
(*
this) = makeAny();
break;
default:
(*
this) = makeAny();
SAL_WARN(
"connectivity.commontools",
"ORowSetValue::setTypeKind(): UNSUPPORTED TYPE!");
}
}
m_eTypeKind = _eType;
}
void ORowSetValue::free() noexcept
{
if(m_bNull)
return;
switch(m_eTypeKind)
{
case DataType::
CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
OSL_ENSURE(m_aValue.m_pString,
"String pointer is null!");
rtl_uString_release(m_aValue.m_pString);
m_aValue.m_pString = nullptr;
break;
case DataType::DATE:
delete static_cast<css::util::Date*>(m_aValue.m_pValue);
m_aValue.m_pValue = nullptr;
break;
case DataType::TIME:
delete static_cast<css::util::Time*>(m_aValue.m_pValue);
m_aValue.m_pValue = nullptr;
break;
case DataType::TIMESTAMP:
delete static_cast<css::util::DateTime*>(m_aValue.m_pValue);
m_aValue.m_pValue = nullptr;
break;
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
delete static_cast<Sequence<sal_Int8>*>(m_aValue.m_pValue);
m_aValue.m_pValue = nullptr;
break;
case DataType::BLOB:
case DataType::CLOB:
case DataType::OBJECT:
delete static_cast<Any*>(m_aValue.m_pValue);
m_aValue.m_pValue = nullptr;
break;
case DataType::BIT:
case DataType::TINYINT:
case DataType::SMALLINT:
case DataType::INTEGER:
case DataType::BIGINT:
case DataType::BOOLEAN:
case DataType::
FLOAT:
case DataType::
DOUBLE:
case DataType::REAL:
break;
default:
if ( m_aValue.m_pValue )
{
delete static_cast<Any*>(m_aValue.m_pValue);
m_aValue.m_pValue = nullptr;
}
break;
}
m_bNull =
true;
}
ORowSetValue& ORowSetValue::
operator=(
const ORowSetValue& _rRH)
{
if(&_rRH ==
this)
return *
this;
if ( m_eTypeKind != _rRH.m_eTypeKind || (_rRH.m_bNull && !m_bNull) || m_bSigned != _rRH.m_bSig
ned)
free();
m_bBound = _rRH.m_bBound;
m_eTypeKind = _rRH.m_eTypeKind;
m_bSigned = _rRH.m_bSigned;
if(m_bNull && !_rRH.m_bNull)
{
switch(_rRH.m_eTypeKind)
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
rtl_uString_acquire(_rRH.m_aValue.m_pString);
m_aValue.m_pString = _rRH.m_aValue.m_pString;
break;
case DataType::DATE:
m_aValue.m_pValue = new Date(*static_cast<Date*>(_rRH.m_aValue.m_pValue));
break;
case DataType::TIME:
m_aValue.m_pValue = new Time(*static_cast<Time*>(_rRH.m_aValue.m_pValue));
break;
case DataType::TIMESTAMP:
m_aValue.m_pValue = new DateTime(*static_cast<DateTime*>(_rRH.m_aValue.m_pValue));
break;
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
m_aValue.m_pValue = new Sequence<sal_Int8>(*static_cast<Sequence<sal_Int8>*>(_rRH.m_aValue.m_pValue));
break;
case DataType::BIT:
case DataType::BOOLEAN:
m_aValue.m_bBool = _rRH.m_aValue.m_bBool;
break;
case DataType::TINYINT:
if ( _rRH.m_bSigned )
m_aValue.m_nInt8 = _rRH.m_aValue.m_nInt8;
else
m_aValue.m_uInt8 = _rRH.m_aValue.m_uInt8;
break;
case DataType::SMALLINT:
if ( _rRH.m_bSigned )
m_aValue.m_nInt16 = _rRH.m_aValue.m_nInt16;
else
m_aValue.m_uInt16 = _rRH.m_aValue.m_uInt16;
break;
case DataType::INTEGER:
if ( _rRH.m_bSigned )
m_aValue.m_nInt32 = _rRH.m_aValue.m_nInt32;
else
m_aValue.m_uInt32 = _rRH.m_aValue.m_uInt32;
break;
case DataType::BIGINT:
if ( _rRH.m_bSigned )
m_aValue.m_nInt64 = _rRH.m_aValue.m_nInt64;
else
m_aValue.m_uInt64 = _rRH.m_aValue.m_uInt64;
break;
case DataType::FLOAT:
m_aValue.m_nFloat = _rRH.m_aValue.m_nFloat;
break;
case DataType::DOUBLE:
case DataType::REAL:
m_aValue.m_nDouble = _rRH.m_aValue.m_nDouble;
break;
default:
m_aValue.m_pValue = new Any(*static_cast<Any*>(_rRH.m_aValue.m_pValue));
}
}
else if(!_rRH.m_bNull)
{
switch(_rRH.m_eTypeKind)
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
(*this) = OUString(_rRH.m_aValue.m_pString);
break;
case DataType::DATE:
(*this) = *static_cast<Date*>(_rRH.m_aValue.m_pValue);
break;
case DataType::TIME:
(*this) = *static_cast<Time*>(_rRH.m_aValue.m_pValue);
break;
case DataType::TIMESTAMP:
(*this) = *static_cast<DateTime*>(_rRH.m_aValue.m_pValue);
break;
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
(*this) = *static_cast<Sequence<sal_Int8>*>(_rRH.m_aValue.m_pValue);
break;
case DataType::BIT:
case DataType::BOOLEAN:
m_aValue.m_bBool = _rRH.m_aValue.m_bBool;
break;
case DataType::TINYINT:
if ( _rRH.m_bSigned )
m_aValue.m_nInt8 = _rRH.m_aValue.m_nInt8;
else
m_aValue.m_uInt8 = _rRH.m_aValue.m_uInt8;
break;
case DataType::SMALLINT:
if ( _rRH.m_bSigned )
m_aValue.m_nInt16 = _rRH.m_aValue.m_nInt16;
else
m_aValue.m_uInt16 = _rRH.m_aValue.m_uInt16;
break;
case DataType::INTEGER:
if ( _rRH.m_bSigned )
m_aValue.m_nInt32 = _rRH.m_aValue.m_nInt32;
else
m_aValue.m_uInt32 = _rRH.m_aValue.m_uInt32;
break;
case DataType::BIGINT:
if ( _rRH.m_bSigned )
m_aValue.m_nInt64 = _rRH.m_aValue.m_nInt64;
else
m_aValue.m_uInt64 = _rRH.m_aValue.m_uInt64;
break;
case DataType::FLOAT:
m_aValue.m_nFloat = _rRH.m_aValue.m_nFloat;
break;
case DataType::DOUBLE:
case DataType::REAL:
m_aValue.m_nDouble = _rRH.m_aValue.m_nDouble;
break;
default:
*static_cast<Any*>(m_aValue.m_pValue) = *static_cast<Any*>(_rRH.m_aValue.m_pValue);
}
}
m_bNull = _rRH.m_bNull;
// OJ: BUGID: 96277
m_eTypeKind = _rRH.m_eTypeKind;
return *this;
}
ORowSetValue& ORowSetValue::operator=(ORowSetValue&& _rRH) noexcept
{
if ( m_eTypeKind != _rRH.m_eTypeKind || !m_bNull)
free();
if(!_rRH.m_bNull)
{
m_aValue = _rRH.m_aValue;
memset(&_rRH.m_aValue, 0, sizeof(_rRH.m_aValue));
}
m_bBound = _rRH.m_bBound;
m_eTypeKind = _rRH.m_eTypeKind;
m_bSigned = _rRH.m_bSigned;
m_bNull = _rRH.m_bNull;
_rRH.m_bNull = true;
return *this;
}
ORowSetValue& ORowSetValue::operator=(const Date& _rRH)
{
if(m_eTypeKind != DataType::DATE)
free();
if(m_bNull)
{
m_aValue.m_pValue = new Date(_rRH);
m_eTypeKind = DataType::DATE;
m_bNull = false;
}
else
*static_cast<Date*>(m_aValue.m_pValue) = _rRH;
return *this;
}
ORowSetValue& ORowSetValue::operator=(const css::util::Time& _rRH)
{
if(m_eTypeKind != DataType::TIME)
free();
if(m_bNull)
{
m_aValue.m_pValue = new Time(_rRH);
m_eTypeKind = DataType::TIME;
m_bNull = false;
}
else
*static_cast<Time*>(m_aValue.m_pValue) = _rRH;
return *this;
}
ORowSetValue& ORowSetValue::operator=(const DateTime& _rRH)
{
if(m_eTypeKind != DataType::TIMESTAMP)
free();
if(m_bNull)
{
m_aValue.m_pValue = new DateTime(_rRH);
m_eTypeKind = DataType::TIMESTAMP;
m_bNull = false;
}
else
*static_cast<DateTime*>(m_aValue.m_pValue) = _rRH;
return *this;
}
ORowSetValue& ORowSetValue::operator=(const OUString& _rRH)
{
if(m_eTypeKind != DataType::VARCHAR || m_aValue.m_pString != _rRH.pData)
{
free();
m_bNull = false;
m_aValue.m_pString = _rRH.pData;
rtl_uString_acquire(m_aValue.m_pString);
m_eTypeKind = DataType::VARCHAR;
}
return *this;
}
ORowSetValue& ORowSetValue::operator=(double _rRH)
{
if(m_eTypeKind != DataType::DOUBLE)
free();
m_aValue.m_nDouble = _rRH;
m_eTypeKind = DataType::DOUBLE;
m_bNull = false;
return *this;
}
ORowSetValue& ORowSetValue::operator=(float _rRH)
{
if(m_eTypeKind != DataType::FLOAT)
free();
m_aValue.m_nFloat = _rRH;
m_eTypeKind = DataType::FLOAT;
m_bNull = false;
return *this;
}
ORowSetValue& ORowSetValue::operator=(sal_Int8 _rRH)
{
if(m_eTypeKind != DataType::TINYINT )
free();
m_aValue.m_nInt8 = _rRH;
m_eTypeKind = DataType::TINYINT;
m_bNull = false;
m_bSigned = true;
return *this;
}
ORowSetValue& ORowSetValue::operator=(sal_Int16 _rRH)
{
if(m_eTypeKind != DataType::SMALLINT )
free();
m_aValue.m_nInt16 = _rRH;
m_eTypeKind = DataType::SMALLINT;
m_bNull = false;
m_bSigned = true;
return *this;
}
ORowSetValue& ORowSetValue::operator=(sal_uInt16 _rRH)
{
if(m_eTypeKind != DataType::SMALLINT )
free();
m_aValue.m_uInt16 = _rRH;
m_eTypeKind = DataType::SMALLINT;
m_bNull = false;
m_bSigned = false;
return *this;
}
ORowSetValue& ORowSetValue::operator=(sal_Int32 _rRH)
{
if(m_eTypeKind != DataType::INTEGER )
free();
m_aValue.m_nInt32 = _rRH;
m_eTypeKind = DataType::INTEGER;
m_bNull = false;
m_bSigned = true;
return *this;
}
ORowSetValue& ORowSetValue::operator=(sal_uInt32 _rRH)
{
if(m_eTypeKind != DataType::INTEGER )
free();
m_aValue.m_uInt32 = _rRH;
m_eTypeKind = DataType::INTEGER;
m_bNull = false;
m_bSigned = false;
return *this;
}
ORowSetValue& ORowSetValue::operator=(const bool _rRH)
{
if(m_eTypeKind != DataType::BIT && DataType::BOOLEAN != m_eTypeKind )
free();
m_aValue.m_bBool = _rRH;
m_eTypeKind = DataType::BOOLEAN;
m_bNull = false;
return *this;
}
ORowSetValue& ORowSetValue::operator=(sal_Int64 _rRH)
{
if ( DataType::BIGINT != m_eTypeKind)
free();
m_aValue.m_nInt64 = _rRH;
m_eTypeKind = DataType::BIGINT;
m_bNull = false;
m_bSigned = true;
return *this;
}
ORowSetValue& ORowSetValue::operator=(sal_uInt64 _rRH)
{
if ( DataType::BIGINT != m_eTypeKind)
free();
m_aValue.m_uInt64 = _rRH;
m_eTypeKind = DataType::BIGINT;
m_bNull = false;
m_bSigned = false;
return *this;
}
ORowSetValue& ORowSetValue::operator=(const Sequence<sal_Int8>& _rRH)
{
if (!isStorageCompatible(DataType::LONGVARBINARY,m_eTypeKind))
free();
if (m_bNull)
{
m_aValue.m_pValue = new Sequence<sal_Int8>(_rRH);
}
else
*static_cast< Sequence< sal_Int8 >* >(m_aValue.m_pValue) = _rRH;
m_eTypeKind = DataType::LONGVARBINARY;
m_bNull = false;
return *this;
}
ORowSetValue& ORowSetValue::operator=(const Any& _rAny)
{
if (!isStorageCompatible(DataType::OBJECT,m_eTypeKind))
free();
if ( m_bNull )
{
m_aValue.m_pValue = new Any(_rAny);
}
else
*static_cast<Any*>(m_aValue.m_pValue) = _rAny;
m_eTypeKind = DataType::OBJECT;
m_bNull = false;
return *this;
}
bool ORowSetValue::operator==(const ORowSetValue& _rRH) const
{
if ( m_bNull != _rRH.isNull() )
return false;
if(m_bNull && _rRH.isNull())
return true;
if ( !isStorageComparable(m_eTypeKind, _rRH.m_eTypeKind ))
{
switch(m_eTypeKind)
{
case DataType::FLOAT:
case DataType::DOUBLE:
case DataType::REAL:
return getDouble() == _rRH.getDouble();
default:
switch(_rRH.m_eTypeKind)
{
case DataType::FLOAT:
case DataType::DOUBLE:
case DataType::REAL:
return getDouble() == _rRH.getDouble();
default:
break;
}
break;
}
return false;
}
bool bRet = false;
OSL_ENSURE(!m_bNull,"Should not be null!");
switch(m_eTypeKind)
{
case DataType::VARCHAR:
case DataType::CHAR:
case DataType::LONGVARCHAR:
{
OUString aVal1(m_aValue.m_pString);
OUString aVal2(_rRH.m_aValue.m_pString);
return aVal1 == aVal2;
}
default:
if ( m_bSigned != _rRH.m_bSigned )
return false;
break;
}
switch(m_eTypeKind)
{
case DataType::DECIMAL:
case DataType::NUMERIC:
{
OUString aVal1(m_aValue.m_pString);
OUString aVal2(_rRH.m_aValue.m_pString);
bRet = aVal1 == aVal2;
}
break;
case DataType::FLOAT:
bRet = m_aValue.m_nFloat == _rRH.m_aValue.m_nFloat;
break;
case DataType::DOUBLE:
case DataType::REAL:
bRet = m_aValue.m_nDouble == _rRH.m_aValue.m_nDouble;
break;
case DataType::TINYINT:
bRet = m_bSigned ? ( m_aValue.m_nInt8 == _rRH.m_aValue.m_nInt8 ) : (m_aValue.m_uInt8 == _rRH.m_aValue.m_uInt8);
break;
case DataType::SMALLINT:
bRet = m_bSigned ? ( m_aValue.m_nInt16 == _rRH.m_aValue.m_nInt16 ) : (m_aValue.m_uInt16 == _rRH.m_aValue.m_uInt16);
break;
case DataType::INTEGER:
bRet = m_bSigned ? ( m_aValue.m_nInt32 == _rRH.m_aValue.m_nInt32 ) : (m_aValue.m_uInt32 == _rRH.m_aValue.m_uInt32);
break;
case DataType::BIGINT:
bRet = m_bSigned ? ( m_aValue.m_nInt64 == _rRH.m_aValue.m_nInt64 ) : (m_aValue.m_uInt64 == _rRH.m_aValue.m_uInt64);
break;
case DataType::BIT:
case DataType::BOOLEAN:
bRet = m_aValue.m_bBool == _rRH.m_aValue.m_bBool;
break;
case DataType::DATE:
bRet = *static_cast<Date*>(m_aValue.m_pValue) == *static_cast<Date*>(_rRH.m_aValue.m_pValue);
break;
case DataType::TIME:
bRet = *static_cast<Time*>(m_aValue.m_pValue) == *static_cast<Time*>(_rRH.m_aValue.m_pValue);
break;
case DataType::TIMESTAMP:
bRet = *static_cast<DateTime*>(m_aValue.m_pValue) == *static_cast<DateTime*>(_rRH.m_aValue.m_pValue);
break;
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
case DataType::BLOB:
case DataType::CLOB:
case DataType::OBJECT:
case DataType::OTHER:
bRet = false;
break;
default:
bRet = false;
SAL_WARN( "connectivity.commontools","ORowSetValue::operator==(): UNSUPPORTED TYPE!");
break;
}
return bRet;
}
Any ORowSetValue::makeAny() const
{
Any rValue;
if(isBound() && !isNull())
{
switch(getTypeKind())
{
case DataType::SQLNULL:
assert(rValue == Any());
break;
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
OSL_ENSURE(m_aValue.m_pString,"Value is null!");
rValue <<= OUString(m_aValue.m_pString);
break;
case DataType::FLOAT:
rValue <<= m_aValue.m_nFloat;
break;
case DataType::DOUBLE:
case DataType::REAL:
rValue <<= m_aValue.m_nDouble;
break;
case DataType::DATE:
assert(m_aValue.m_pValue && "Value is null!");
rValue <<= *static_cast<Date*>(m_aValue.m_pValue);
break;
case DataType::TIME:
assert(m_aValue.m_pValue && "Value is null!");
rValue <<= *static_cast<Time*>(m_aValue.m_pValue);
break;
case DataType::TIMESTAMP:
assert(m_aValue.m_pValue && "Value is null!");
rValue <<= *static_cast<DateTime*>(m_aValue.m_pValue);
break;
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
assert(m_aValue.m_pValue && "Value is null!");
rValue <<= *static_cast<Sequence<sal_Int8>*>(m_aValue.m_pValue);
break;
case DataType::BLOB:
case DataType::CLOB:
case DataType::OBJECT:
case DataType::OTHER:
rValue = getAny();
break;
case DataType::BIT:
case DataType::BOOLEAN:
rValue <<= m_aValue.m_bBool;
break;
case DataType::TINYINT:
if ( m_bSigned )
// TypeClass_BYTE
rValue <<= m_aValue.m_nInt8;
else
// There is no TypeClass_UNSIGNED_BYTE,
// so silently promote it to a 16-bit integer,
// that is TypeClass_UNSIGNED_SHORT
rValue <<= static_cast<sal_uInt16>(m_aValue.m_uInt8);
break;
case DataType::SMALLINT:
if ( m_bSigned )
// TypeClass_SHORT
rValue <<= m_aValue.m_nInt16;
else
// TypeClass_UNSIGNED_SHORT
rValue <<= m_aValue.m_uInt16;
break;
case DataType::INTEGER:
if ( m_bSigned )
// TypeClass_LONG
rValue <<= m_aValue.m_nInt32;
else
// TypeClass_UNSIGNED_LONG
rValue <<= m_aValue.m_uInt32;
break;
case DataType::BIGINT:
if ( m_bSigned )
// TypeClass_HYPER
rValue <<= m_aValue.m_nInt64;
else
// TypeClass_UNSIGNED_HYPER
rValue <<= m_aValue.m_uInt64;
break;
default:
SAL_WARN( "connectivity.commontools","ORowSetValue::makeAny(): UNSUPPORTED TYPE!");
rValue = getAny();
break;
}
}
return rValue;
}
OUString ORowSetValue::getString( ) const
{
OUString aRet;
if(!m_bNull)
{
switch(getTypeKind())
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
aRet = m_aValue.m_pString;
break;
case DataType::FLOAT:
aRet = OUString::number(getFloat());
break;
case DataType::DOUBLE:
case DataType::REAL:
aRet = OUString::number(getDouble());
break;
case DataType::DATE:
aRet = DBTypeConversion::toDateString(getDate());
break;
case DataType::TIME:
aRet = DBTypeConversion::toTimeString(getTime());
break;
case DataType::TIMESTAMP:
aRet = DBTypeConversion::toDateTimeString(getDateTime());
break;
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
{
OUStringBuffer sVal("0x");
for (sal_Int32 byte : getSequence())
sVal.append(byte, 16);
aRet = sVal.makeStringAndClear();
}
break;
case DataType::BIT:
aRet = OUString::number(int(getBool()));
break;
case DataType::BOOLEAN:
aRet = OUString::boolean(getBool());
break;
case DataType::TINYINT:
case DataType::SMALLINT:
case DataType::INTEGER:
if ( m_bSigned )
aRet = OUString::number(getInt32());
else
aRet = OUString::number(getUInt32());
break;
case DataType::BIGINT:
if ( m_bSigned )
aRet = OUString::number(getLong());
else
aRet = OUString::number(getULong());
break;
case DataType::CLOB:
{
Any aValue( getAny() );
Reference< XClob > xClob;
if ( (aValue >>= xClob) && xClob.is() )
{
aRet = xClob->getSubString(1,static_cast<sal_Int32>(xClob->length()) );
}
}
break;
default:
{
Any aValue = makeAny();
aValue >>= aRet;
break;
}
}
}
return aRet;
}
bool ORowSetValue::getBool() const
{
bool bRet = false;
if(!m_bNull)
{
switch(getTypeKind())
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::LONGVARCHAR:
{
const OUString sValue(m_aValue.m_pString);
if ( sValue.equalsIgnoreAsciiCase("true") || (sValue == "1") )
{
bRet = true;
break;
}
else if ( sValue.equalsIgnoreAsciiCase("false") || (sValue == "0") )
{
bRet = false;
break;
}
}
[[fallthrough]];
case DataType::DECIMAL:
case DataType::NUMERIC:
bRet = OUString::unacquired(&m_aValue.m_pString).toInt32() != 0;
break;
case DataType::FLOAT:
bRet = m_aValue.m_nFloat != 0.0;
break;
case DataType::DOUBLE:
case DataType::REAL:
bRet = m_aValue.m_nDouble != 0.0;
break;
case DataType::DATE:
case DataType::TIME:
case DataType::TIMESTAMP:
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
OSL_FAIL("getBool() for this type is not allowed!");
break;
case DataType::BIT:
case DataType::BOOLEAN:
bRet = m_aValue.m_bBool;
break;
case DataType::TINYINT:
bRet = m_bSigned ? (m_aValue.m_nInt8 != 0) : (m_aValue.m_uInt8 != 0);
break;
case DataType::SMALLINT:
bRet = m_bSigned ? (m_aValue.m_nInt16 != 0) : (m_aValue.m_uInt16 != 0);
break;
case DataType::INTEGER:
bRet = m_bSigned ? (m_aValue.m_nInt32 != 0) : (m_aValue.m_uInt32 != 0);
break;
case DataType::BIGINT:
bRet = m_bSigned ? (m_aValue.m_nInt64 != 0) : (m_aValue.m_uInt64 != 0);
break;
default:
{
Any aValue = makeAny();
aValue >>= bRet;
break;
}
}
}
return bRet;
}
sal_Int8 ORowSetValue::getInt8() const
{
sal_Int8 nRet = 0;
if(!m_bNull)
{
switch(getTypeKind())
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
nRet = sal_Int8(OUString::unacquired(&m_aValue.m_pString).toInt32());
break;
case DataType::FLOAT:
nRet = sal_Int8(m_aValue.m_nFloat);
break;
case DataType::DOUBLE:
case DataType::REAL:
nRet = sal_Int8(m_aValue.m_nDouble);
break;
case DataType::DATE:
case DataType::TIME:
case DataType::TIMESTAMP:
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
case DataType::BLOB:
case DataType::CLOB:
OSL_FAIL("getInt8() for this type is not allowed!");
break;
case DataType::BIT:
case DataType::BOOLEAN:
nRet = sal_Int8(m_aValue.m_bBool);
break;
case DataType::TINYINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt8;
else
nRet = static_cast<sal_Int8>(m_aValue.m_uInt8);
break;
case DataType::SMALLINT:
if ( m_bSigned )
nRet = static_cast<sal_Int8>(m_aValue.m_nInt16);
else
nRet = static_cast<sal_Int8>(m_aValue.m_uInt16);
break;
case DataType::INTEGER:
if ( m_bSigned )
nRet = static_cast<sal_Int8>(m_aValue.m_nInt32);
else
nRet = static_cast<sal_Int8>(m_aValue.m_uInt32);
break;
case DataType::BIGINT:
if ( m_bSigned )
nRet = static_cast<sal_Int8>(m_aValue.m_nInt64);
else
nRet = static_cast<sal_Int8>(m_aValue.m_uInt64);
break;
default:
{
Any aValue = makeAny();
aValue >>= nRet;
break;
}
}
}
return nRet;
}
sal_uInt8 ORowSetValue::getUInt8() const
{
sal_uInt8 nRet = 0;
if(!m_bNull)
{
switch(getTypeKind())
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
nRet = sal_uInt8(OUString::unacquired(&m_aValue.m_pString).toInt32());
break;
case DataType::FLOAT:
nRet = sal_uInt8(m_aValue.m_nFloat);
break;
case DataType::DOUBLE:
case DataType::REAL:
nRet = sal_uInt8(m_aValue.m_nDouble);
break;
case DataType::DATE:
case DataType::TIME:
case DataType::TIMESTAMP:
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
case DataType::BLOB:
case DataType::CLOB:
OSL_FAIL("getuInt8() for this type is not allowed!");
break;
case DataType::BIT:
case DataType::BOOLEAN:
nRet = int(m_aValue.m_bBool);
break;
case DataType::TINYINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt8;
else
nRet = m_aValue.m_uInt8;
break;
case DataType::SMALLINT:
if ( m_bSigned )
nRet = static_cast<sal_uInt8>(m_aValue.m_nInt16);
else
nRet = static_cast<sal_uInt8>(m_aValue.m_uInt16);
break;
case DataType::INTEGER:
if ( m_bSigned )
nRet = static_cast<sal_uInt8>(m_aValue.m_nInt32);
else
nRet = static_cast<sal_uInt8>(m_aValue.m_uInt32);
break;
case DataType::BIGINT:
if ( m_bSigned )
nRet = static_cast<sal_uInt8>(m_aValue.m_nInt64);
else
nRet = static_cast<sal_uInt8>(m_aValue.m_uInt64);
break;
default:
{
Any aValue = makeAny();
// Cf. "There is no TypeClass_UNSIGNED_BYTE" in makeAny:
sal_uInt16 n;
if (aValue >>= n) {
nRet = static_cast<sal_uInt8>(n);
}
break;
}
}
}
return nRet;
}
sal_Int16 ORowSetValue::getInt16() const
{
sal_Int16 nRet = 0;
if(!m_bNull)
{
switch(getTypeKind())
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
nRet = sal_Int16(OUString::unacquired(&m_aValue.m_pString).toInt32());
break;
case DataType::FLOAT:
nRet = sal_Int16(m_aValue.m_nFloat);
break;
case DataType::DOUBLE:
case DataType::REAL:
nRet = sal_Int16(m_aValue.m_nDouble);
break;
case DataType::DATE:
case DataType::TIME:
case DataType::TIMESTAMP:
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
case DataType::BLOB:
case DataType::CLOB:
OSL_FAIL("getInt16() for this type is not allowed!");
break;
case DataType::BIT:
case DataType::BOOLEAN:
nRet = sal_Int16(m_aValue.m_bBool);
break;
case DataType::TINYINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt8;
else
nRet = m_aValue.m_uInt8;
break;
case DataType::SMALLINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt16;
else
nRet = static_cast<sal_Int16>(m_aValue.m_uInt16);
break;
case DataType::INTEGER:
if ( m_bSigned )
nRet = static_cast<sal_Int16>(m_aValue.m_nInt32);
else
nRet = static_cast<sal_Int16>(m_aValue.m_uInt32);
break;
case DataType::BIGINT:
if ( m_bSigned )
nRet = static_cast<sal_Int16>(m_aValue.m_nInt64);
else
nRet = static_cast<sal_Int16>(m_aValue.m_uInt64);
break;
default:
{
Any aValue = makeAny();
aValue >>= nRet;
break;
}
}
}
return nRet;
}
sal_uInt16 ORowSetValue::getUInt16() const
{
sal_uInt16 nRet = 0;
if(!m_bNull)
{
switch(getTypeKind())
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
nRet = sal_uInt16(OUString::unacquired(&m_aValue.m_pString).toInt32());
break;
case DataType::FLOAT:
nRet = sal_uInt16(m_aValue.m_nFloat);
break;
case DataType::DOUBLE:
case DataType::REAL:
nRet = sal_uInt16(m_aValue.m_nDouble);
break;
case DataType::DATE:
case DataType::TIME:
case DataType::TIMESTAMP:
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
case DataType::BLOB:
case DataType::CLOB:
OSL_FAIL("getuInt16() for this type is not allowed!");
break;
case DataType::BIT:
case DataType::BOOLEAN:
nRet = sal_uInt16(m_aValue.m_bBool);
break;
case DataType::TINYINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt8;
else
nRet = m_aValue.m_uInt8;
break;
case DataType::SMALLINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt16;
else
nRet = m_aValue.m_uInt16;
break;
case DataType::INTEGER:
if ( m_bSigned )
nRet = static_cast<sal_uInt16>(m_aValue.m_nInt32);
else
nRet = static_cast<sal_uInt16>(m_aValue.m_uInt32);
break;
case DataType::BIGINT:
if ( m_bSigned )
nRet = static_cast<sal_uInt16>(m_aValue.m_nInt64);
else
nRet = static_cast<sal_uInt16>(m_aValue.m_uInt64);
break;
default:
{
Any aValue = makeAny();
aValue >>= nRet;
break;
}
}
}
return nRet;
}
sal_Int32 ORowSetValue::getInt32() const
{
sal_Int32 nRet = 0;
if(!m_bNull)
{
switch(getTypeKind())
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
nRet = OUString::unacquired(&m_aValue.m_pString).toInt32();
break;
case DataType::FLOAT:
nRet = sal_Int32(m_aValue.m_nFloat);
break;
case DataType::DOUBLE:
case DataType::REAL:
nRet = sal_Int32(m_aValue.m_nDouble);
break;
case DataType::DATE:
nRet = dbtools::DBTypeConversion::toDays(*static_cast<css::util::Date*>(m_aValue.m_pValue));
break;
case DataType::TIME:
case DataType::TIMESTAMP:
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
case DataType::BLOB:
case DataType::CLOB:
OSL_FAIL("getInt32() for this type is not allowed!");
break;
case DataType::BIT:
case DataType::BOOLEAN:
nRet = sal_Int32(m_aValue.m_bBool);
break;
case DataType::TINYINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt8;
else
nRet = m_aValue.m_uInt8;
break;
case DataType::SMALLINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt16;
else
nRet = m_aValue.m_uInt16;
break;
case DataType::INTEGER:
if ( m_bSigned )
nRet = m_aValue.m_nInt32;
else
nRet = static_cast<sal_Int32>(m_aValue.m_uInt32);
break;
case DataType::BIGINT:
if ( m_bSigned )
nRet = static_cast<sal_Int32>(m_aValue.m_nInt64);
else
nRet = static_cast<sal_Int32>(m_aValue.m_uInt64);
break;
default:
{
Any aValue = makeAny();
aValue >>= nRet;
break;
}
}
}
return nRet;
}
sal_uInt32 ORowSetValue::getUInt32() const
{
sal_uInt32 nRet = 0;
if(!m_bNull)
{
switch(getTypeKind())
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
nRet = OUString::unacquired(&m_aValue.m_pString).toUInt32();
break;
case DataType::FLOAT:
nRet = sal_uInt32(m_aValue.m_nFloat);
break;
case DataType::DOUBLE:
case DataType::REAL:
nRet = sal_uInt32(m_aValue.m_nDouble);
break;
case DataType::DATE:
nRet = dbtools::DBTypeConversion::toDays(*static_cast<css::util::Date*>(m_aValue.m_pValue));
break;
case DataType::TIME:
case DataType::TIMESTAMP:
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
case DataType::BLOB:
case DataType::CLOB:
OSL_FAIL("getuInt32() for this type is not allowed!");
break;
case DataType::BIT:
case DataType::BOOLEAN:
nRet = sal_uInt32(m_aValue.m_bBool);
break;
case DataType::TINYINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt8;
else
nRet = m_aValue.m_uInt8;
break;
case DataType::SMALLINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt16;
else
nRet = m_aValue.m_uInt16;
break;
case DataType::INTEGER:
if ( m_bSigned )
nRet = m_aValue.m_nInt32;
else
nRet = m_aValue.m_uInt32;
break;
case DataType::BIGINT:
if ( m_bSigned )
nRet = static_cast<sal_uInt32>(m_aValue.m_nInt64);
else
nRet = static_cast<sal_uInt32>(m_aValue.m_uInt64);
break;
default:
{
Any aValue = makeAny();
aValue >>= nRet;
break;
}
}
}
return nRet;
}
sal_Int64 ORowSetValue::getLong() const
{
sal_Int64 nRet = 0;
if(!m_bNull)
{
switch(getTypeKind())
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
nRet = OUString::unacquired(&m_aValue.m_pString).toInt64();
break;
case DataType::FLOAT:
nRet = sal_Int64(m_aValue.m_nFloat);
break;
case DataType::DOUBLE:
case DataType::REAL:
nRet = sal_Int64(m_aValue.m_nDouble);
break;
case DataType::DATE:
nRet = dbtools::DBTypeConversion::toDays(*static_cast<css::util::Date*>(m_aValue.m_pValue));
break;
case DataType::TIME:
case DataType::TIMESTAMP:
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
case DataType::BLOB:
case DataType::CLOB:
OSL_FAIL("getLong() for this type is not allowed!");
break;
case DataType::BIT:
case DataType::BOOLEAN:
nRet = sal_Int64(m_aValue.m_bBool);
break;
case DataType::TINYINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt8;
else
nRet = m_aValue.m_uInt8;
break;
case DataType::SMALLINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt16;
else
nRet = m_aValue.m_uInt16;
break;
case DataType::INTEGER:
if ( m_bSigned )
nRet = m_aValue.m_nInt32;
else
nRet = m_aValue.m_uInt32;
break;
case DataType::BIGINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt64;
else
nRet = static_cast<sal_Int64>(m_aValue.m_uInt64);
break;
default:
{
Any aValue = makeAny();
aValue >>= nRet;
break;
}
}
}
return nRet;
}
sal_uInt64 ORowSetValue::getULong() const
{
sal_uInt64 nRet = 0;
if(!m_bNull)
{
switch(getTypeKind())
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
nRet = OUString::unacquired(&m_aValue.m_pString).toUInt64();
break;
case DataType::FLOAT:
nRet = sal_uInt64(m_aValue.m_nFloat);
break;
case DataType::DOUBLE:
case DataType::REAL:
nRet = sal_uInt64(m_aValue.m_nDouble);
break;
case DataType::DATE:
nRet = dbtools::DBTypeConversion::toDays(*static_cast<css::util::Date*>(m_aValue.m_pValue));
break;
case DataType::TIME:
case DataType::TIMESTAMP:
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
case DataType::BLOB:
case DataType::CLOB:
OSL_FAIL("getULong() for this type is not allowed!");
break;
case DataType::BIT:
case DataType::BOOLEAN:
nRet = sal_uInt64(m_aValue.m_bBool);
break;
case DataType::TINYINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt8;
else
nRet = m_aValue.m_uInt8;
break;
case DataType::SMALLINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt16;
else
nRet = m_aValue.m_uInt16;
break;
case DataType::INTEGER:
if ( m_bSigned )
nRet = m_aValue.m_nInt32;
else
nRet = m_aValue.m_uInt32;
break;
case DataType::BIGINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt64;
else
nRet = m_aValue.m_uInt64;
break;
default:
{
Any aValue = makeAny();
aValue >>= nRet;
break;
}
}
}
return nRet;
}
float ORowSetValue::getFloat() const
{
float nRet = 0;
if(!m_bNull)
{
switch(getTypeKind())
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
nRet = OUString::unacquired(&m_aValue.m_pString).toFloat();
break;
case DataType::FLOAT:
nRet = m_aValue.m_nFloat;
break;
case DataType::DOUBLE:
case DataType::REAL:
nRet = static_cast<float>(m_aValue.m_nDouble);
break;
case DataType::DATE:
nRet = static_cast<float>(dbtools::DBTypeConversion::toDouble(*static_cast<css::util::Date*>(m_aValue.m_pValue)));
break;
case DataType::TIME:
nRet = static_cast<float>(dbtools::DBTypeConversion::toDouble(*static_cast<css::util::Time*>(m_aValue.m_pValue)));
break;
case DataType::TIMESTAMP:
nRet = static_cast<float>(dbtools::DBTypeConversion::toDouble(*static_cast<css::util::DateTime*>(m_aValue.m_pValue)));
break;
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
case DataType::BLOB:
case DataType::CLOB:
OSL_FAIL("getDouble() for this type is not allowed!");
break;
case DataType::BIT:
case DataType::BOOLEAN:
nRet = float(m_aValue.m_bBool);
break;
case DataType::TINYINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt8;
else
nRet = m_aValue.m_uInt8;
break;
case DataType::SMALLINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt16;
else
nRet = static_cast<float>(m_aValue.m_uInt16);
break;
case DataType::INTEGER:
if ( m_bSigned )
nRet = static_cast<float>(m_aValue.m_nInt32);
else
nRet = static_cast<float>(m_aValue.m_uInt32);
break;
case DataType::BIGINT:
if ( m_bSigned )
nRet = static_cast<float>(m_aValue.m_nInt64);
else
nRet = static_cast<float>(m_aValue.m_uInt64);
break;
default:
{
Any aValue = makeAny();
aValue >>= nRet;
break;
}
}
}
return nRet;
}
double ORowSetValue::getDouble() const
{
double nRet = 0;
if(!m_bNull)
{
switch(getTypeKind())
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
nRet = OUString::unacquired(&m_aValue.m_pString).toDouble();
break;
case DataType::FLOAT:
nRet = m_aValue.m_nFloat;
break;
case DataType::DOUBLE:
case DataType::REAL:
nRet = m_aValue.m_nDouble;
break;
case DataType::DATE:
nRet = dbtools::DBTypeConversion::toDouble(*static_cast<css::util::Date*>(m_aValue.m_pValue));
break;
case DataType::TIME:
nRet = dbtools::DBTypeConversion::toDouble(*static_cast<css::util::Time*>(m_aValue.m_pValue));
break;
case DataType::TIMESTAMP:
nRet = dbtools::DBTypeConversion::toDouble(*static_cast<css::util::DateTime*>(m_aValue.m_pValue));
break;
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
case DataType::BLOB:
case DataType::CLOB:
OSL_FAIL("getDouble() for this type is not allowed!");
break;
case DataType::BIT:
case DataType::BOOLEAN:
nRet = double(m_aValue.m_bBool);
break;
case DataType::TINYINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt8;
else
nRet = m_aValue.m_uInt8;
break;
case DataType::SMALLINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt16;
else
nRet = m_aValue.m_uInt16;
break;
case DataType::INTEGER:
if ( m_bSigned )
nRet = m_aValue.m_nInt32;
else
nRet = m_aValue.m_uInt32;
break;
case DataType::BIGINT:
if ( m_bSigned )
nRet = m_aValue.m_nInt64;
else
nRet = m_aValue.m_uInt64;
break;
default:
{
Any aValue = makeAny();
aValue >>= nRet;
break;
}
}
}
return nRet;
}
Sequence<sal_Int8> ORowSetValue::getSequence() const
{
Sequence<sal_Int8> aSeq;
if (!m_bNull)
{
switch(m_eTypeKind)
{
case DataType::OBJECT:
case DataType::CLOB:
case DataType::BLOB:
{
Reference<XInputStream> xStream;
const Any aValue = makeAny();
if(aValue.hasValue())
{
Reference<XBlob> xBlob(aValue,UNO_QUERY);
if ( xBlob.is() )
xStream = xBlob->getBinaryStream();
else
{
Reference<XClob> xClob(aValue,UNO_QUERY);
if ( xClob.is() )
xStream = xClob->getCharacterStream();
}
if(xStream.is())
{
const sal_uInt32 nBytesToRead = 65535;
sal_uInt32 nRead;
do
{
css::uno::Sequence< sal_Int8 > aReadSeq;
nRead = xStream->readSomeBytes( aReadSeq, nBytesToRead );
if( nRead )
{
const sal_uInt32 nOldLength = aSeq.getLength();
aSeq.realloc( nOldLength + nRead );
memcpy( aSeq.getArray() + nOldLength, aReadSeq.getConstArray(), aReadSeq.getLength() );
}
}
while( nBytesToRead == nRead );
xStream->closeInput();
}
}
}
break;
case DataType::VARCHAR:
case DataType::LONGVARCHAR:
{
aSeq = Sequence<sal_Int8>(reinterpret_cast<const sal_Int8*>(m_aValue.m_pString->buffer),
sizeof(sal_Unicode) * m_aValue.m_pString->length);
}
break;
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
aSeq = *static_cast< Sequence<sal_Int8>*>(m_aValue.m_pValue);
break;
default:
{
Any aValue = makeAny();
aValue >>= aSeq;
break;
}
}
}
return aSeq;
}
css::util::Date ORowSetValue::getDate() const
{
css::util::Date aValue;
if(!m_bNull)
{
switch(m_eTypeKind)
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::LONGVARCHAR:
aValue = DBTypeConversion::toDate(getString());
break;
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::FLOAT:
case DataType::DOUBLE:
case DataType::REAL:
aValue = DBTypeConversion::toDate(getDouble());
break;
case DataType::DATE:
aValue = *static_cast< css::util::Date*>(m_aValue.m_pValue);
break;
case DataType::TIMESTAMP:
{
css::util::DateTime* pDateTime = static_cast< css::util::DateTime*>(m_aValue.m_pValue);
aValue.Day = pDateTime->Day;
aValue.Month = pDateTime->Month;
aValue.Year = pDateTime->Year;
}
break;
case DataType::BIT:
case DataType::BOOLEAN:
case DataType::TINYINT:
case DataType::SMALLINT:
case DataType::INTEGER:
case DataType::BIGINT:
aValue = DBTypeConversion::toDate( double( getLong() ) );
break;
case DataType::BLOB:
case DataType::CLOB:
case DataType::OBJECT:
default:
OSL_ENSURE( false, "ORowSetValue::getDate: cannot retrieve the data!" );
[[fallthrough]];
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
case DataType::TIME:
aValue = DBTypeConversion::toDate( double(0) );
break;
}
}
return aValue;
}
css::util::Time ORowSetValue::getTime() const
{
css::util::Time aValue;
if(!m_bNull)
{
switch(m_eTypeKind)
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::LONGVARCHAR:
aValue = DBTypeConversion::toTime(getString());
break;
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::FLOAT:
case DataType::DOUBLE:
case DataType::REAL:
aValue = DBTypeConversion::toTime(getDouble());
break;
case DataType::TIMESTAMP:
{
css::util::DateTime* pDateTime = static_cast< css::util::DateTime*>(m_aValue.m_pValue);
aValue.NanoSeconds = pDateTime->NanoSeconds;
aValue.Seconds = pDateTime->Seconds;
aValue.Minutes = pDateTime->Minutes;
aValue.Hours = pDateTime->Hours;
}
break;
case DataType::TIME:
aValue = *static_cast< css::util::Time*>(m_aValue.m_pValue);
break;
default:
{
Any aAnyValue = makeAny();
aAnyValue >>= aValue;
break;
}
}
}
return aValue;
}
css::util::DateTime ORowSetValue::getDateTime() const
{
css::util::DateTime aValue;
if(!m_bNull)
{
switch(m_eTypeKind)
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::LONGVARCHAR:
aValue = DBTypeConversion::toDateTime(getString());
break;
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::FLOAT:
case DataType::DOUBLE:
case DataType::REAL:
aValue = DBTypeConversion::toDateTime(getDouble());
break;
case DataType::DATE:
{
css::util::Date* pDate = static_cast< css::util::Date*>(m_aValue.m_pValue);
aValue.Day = pDate->Day;
aValue.Month = pDate->Month;
aValue.Year = pDate->Year;
}
break;
case DataType::TIME:
{
css::util::Time* pTime = static_cast< css::util::Time*>(m_aValue.m_pValue);
aValue.NanoSeconds = pTime->NanoSeconds;
aValue.Seconds = pTime->Seconds;
aValue.Minutes = pTime->Minutes;
aValue.Hours = pTime->Hours;
}
break;
case DataType::TIMESTAMP:
aValue = *static_cast< css::util::DateTime*>(m_aValue.m_pValue);
break;
default:
{
Any aAnyValue = makeAny();
aAnyValue >>= aValue;
break;
}
}
}
return aValue;
}
void ORowSetValue::setSigned(bool _bMod)
{
if ( m_bSigned == _bMod )
return;
m_bSigned = _bMod;
if ( m_bNull )
return;
sal_Int32 nType = m_eTypeKind;
switch(m_eTypeKind)
{
case DataType::TINYINT:
if ( m_bSigned )
(*this) = getInt8();
else
{
m_bSigned = !m_bSigned;
(*this) = getInt16();
m_bSigned = !m_bSigned;
}
break;
case DataType::SMALLINT:
if ( m_bSigned )
(*this) = getInt16();
else
{
m_bSigned = !m_bSigned;
(*this) = getInt32();
m_bSigned = !m_bSigned;
}
break;
case DataType::INTEGER:
if ( m_bSigned )
(*this) = getInt32();
else
{
m_bSigned = !m_bSigned;
(*this) = getLong();
m_bSigned = !m_bSigned;
}
break;
case DataType::BIGINT:
{
if ( m_bSigned )
{
auto nTmp = static_cast<sal_Int64>(m_aValue.m_uInt64);
m_aValue.m_nInt64 = nTmp;
}
else
{
auto nTmp = static_cast<sal_uInt64>(m_aValue.m_nInt64);
m_aValue.m_uInt64 = nTmp;
}
break;
}
}
m_eTypeKind = nType;
}
namespace detail
{
class SAL_NO_VTABLE IValueSource
{
public:
virtual OUString getString() const = 0;
virtual bool getBoolean() const = 0;
virtual sal_Int8 getByte() const = 0;
virtual sal_Int16 getShort() const = 0;
virtual sal_Int32 getInt() const = 0;
virtual sal_Int64 getLong() const = 0;
virtual float getFloat() const = 0;
virtual double getDouble() const = 0;
virtual Date getDate() const = 0;
virtual css::util::Time getTime() const = 0;
virtual DateTime getTimestamp() const = 0;
virtual Sequence< sal_Int8 > getBytes() const = 0;
virtual Reference< XBlob > getBlob() const = 0;
virtual Reference< XClob > getClob() const = 0;
virtual Any getObject() const = 0;
virtual bool wasNull() const = 0;
virtual ~IValueSource() { }
};
namespace {
class RowValue : public IValueSource
{
public:
RowValue( const Reference< XRow >& _xRow, const sal_Int32 _nPos )
:m_xRow( _xRow )
,m_nPos( _nPos )
{
}
// IValueSource
virtual OUString getString() const override { return m_xRow->getString( m_nPos ); };
virtual bool getBoolean() const override { return m_xRow->getBoolean( m_nPos ); };
virtual sal_Int8 getByte() const override { return m_xRow->getByte( m_nPos ); };
virtual sal_Int16 getShort() const override { return m_xRow->getShort( m_nPos ); }
virtual sal_Int32 getInt() const override { return m_xRow->getInt( m_nPos ); }
virtual sal_Int64 getLong() const override { return m_xRow->getLong( m_nPos ); }
virtual float getFloat() const override { return m_xRow->getFloat( m_nPos ); };
virtual double getDouble() const override { return m_xRow->getDouble( m_nPos ); };
virtual Date getDate() const override { return m_xRow->getDate( m_nPos ); };
virtual css::util::Time getTime() const override { return m_xRow->getTime( m_nPos ); };
virtual DateTime getTimestamp() const override { return m_xRow->getTimestamp( m_nPos ); };
virtual Sequence< sal_Int8 > getBytes() const override { return m_xRow->getBytes( m_nPos ); };
virtual Reference< XBlob > getBlob() const override { return m_xRow->getBlob( m_nPos ); };
virtual Reference< XClob > getClob() const override { return m_xRow->getClob( m_nPos ); };
virtual Any getObject() const override { return m_xRow->getObject( m_nPos ,nullptr); };
virtual bool wasNull() const override { return m_xRow->wasNull( ); };
private:
const Reference< XRow > m_xRow;
const sal_Int32 m_nPos;
};
class ColumnValue : public IValueSource
{
public:
explicit ColumnValue( const Reference< XColumn >& _rxColumn )
:m_xColumn( _rxColumn )
{
}
// IValueSource
virtual OUString getString() const override { return m_xColumn->getString(); };
virtual bool getBoolean() const override { return m_xColumn->getBoolean(); };
virtual sal_Int8 getByte() const override { return m_xColumn->getByte(); };
virtual sal_Int16 getShort() const override { return m_xColumn->getShort(); }
virtual sal_Int32 getInt() const override { return m_xColumn->getInt(); }
virtual sal_Int64 getLong() const override { return m_xColumn->getLong(); }
virtual float getFloat() const override { return m_xColumn->getFloat(); };
virtual double getDouble() const override { return m_xColumn->getDouble(); };
virtual Date getDate() const override { return m_xColumn->getDate(); };
virtual css::util::Time getTime() const override { return m_xColumn->getTime(); };
virtual DateTime getTimestamp() const override { return m_xColumn->getTimestamp(); };
virtual Sequence< sal_Int8 > getBytes() const override { return m_xColumn->getBytes(); };
virtual Reference< XBlob > getBlob() const override { return m_xColumn->getBlob(); };
virtual Reference< XClob > getClob() const override { return m_xColumn->getClob(); };
virtual Any getObject() const override { return m_xColumn->getObject( nullptr ); };
virtual bool wasNull() const override { return m_xColumn->wasNull( ); };
private:
const Reference< XColumn > m_xColumn;
};
}
}
void ORowSetValue::fill( const sal_Int32 _nType, const Reference< XColumn >& _rxColumn )
{
detail::ColumnValue aColumnValue( _rxColumn );
impl_fill( _nType, true, aColumnValue );
}
void ORowSetValue::fill( sal_Int32 _nPos, sal_Int32 _nType, bool _bNullable, const Reference< XRow>& _xRow )
{
detail::RowValue aRowValue( _xRow, _nPos );
impl_fill( _nType, _bNullable, aRowValue );
}
void ORowSetValue::fill(sal_Int32 _nPos,
sal_Int32 _nType,
const css::uno::Reference< css::sdbc::XRow>& _xRow)
{
fill(_nPos,_nType,true,_xRow);
}
void ORowSetValue::impl_fill( const sal_Int32 _nType, bool _bNullable, const detail::IValueSource& _rValueSource )
{
switch(_nType)
{
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::LONGVARCHAR:
(*this) = _rValueSource.getString();
break;
case DataType::BIGINT:
if ( isSigned() )
(*this) = _rValueSource.getLong();
else
// TODO: this is rather horrible performance-wise
// but fixing it needs extending the css::sdbc::XRow API
// to have a getULong(), and needs updating all drivers :-|
// When doing that, add getUByte, getUShort, getUInt for symmetry/completeness
(*this) = _rValueSource.getString().toUInt64();
break;
case DataType::FLOAT:
(*this) = _rValueSource.getFloat();
break;
case DataType::DOUBLE:
case DataType::REAL:
(*this) = _rValueSource.getDouble();
break;
case DataType::DATE:
(*this) = _rValueSource.getDate();
break;
case DataType::TIME:
(*this) = _rValueSource.getTime();
break;
case DataType::TIMESTAMP:
(*this) = _rValueSource.getTimestamp();
break;
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
(*this) = _rValueSource.getBytes();
break;
case DataType::BIT:
case DataType::BOOLEAN:
(*this) = _rValueSource.getBoolean();
break;
case DataType::TINYINT:
if ( isSigned() )
(*this) = _rValueSource.getByte();
else
(*this) = _rValueSource.getShort();
break;
case DataType::SMALLINT:
if ( isSigned() )
(*this) = _rValueSource.getShort();
else
(*this) = _rValueSource.getInt();
break;
case DataType::INTEGER:
if ( isSigned() )
(*this) = _rValueSource.getInt();
else
(*this) = _rValueSource.getLong();
break;
case DataType::CLOB:
(*this) = css::uno::Any(_rValueSource.getClob());
setTypeKind(DataType::CLOB);
break;
case DataType::BLOB:
(*this) = css::uno::Any(_rValueSource.getBlob());
setTypeKind(DataType::BLOB);
break;
case DataType::OTHER:
(*this) = _rValueSource.getObject();
setTypeKind(DataType::OTHER);
break;
default:
SAL_WARN( "connectivity.commontools", "ORowSetValue::fill: unsupported type!" );
(*this) = _rValueSource.getObject();
break;
}
if ( _bNullable && _rValueSource.wasNull() )
setNull();
setTypeKind(_nType);
}
void ORowSetValue::fill(const Any& _rValue)
{
switch (_rValue.getValueTypeClass())
{
case TypeClass_VOID:
setNull(); break;
case TypeClass_BOOLEAN:
{
bool bValue( false );
_rValue >>= bValue;
(*this) = bValue;
break;
}
case TypeClass_CHAR:
{
sal_Unicode aDummy(0);
_rValue >>= aDummy;
(*this) = OUString(aDummy);
break;
}
case TypeClass_STRING:
{
OUString sDummy;
_rValue >>= sDummy;
(*this) = sDummy;
break;
}
case TypeClass_FLOAT:
{
float aDummy(0.0);
_rValue >>= aDummy;
(*this) = aDummy;
break;
}
case TypeClass_DOUBLE:
{
double aDummy(0.0);
_rValue >>= aDummy;
(*this) = aDummy;
break;
}
case TypeClass_BYTE:
{
sal_Int8 aDummy(0);
_rValue >>= aDummy;
(*this) = aDummy;
break;
}
case TypeClass_SHORT:
{
sal_Int16 aDummy(0);
_rValue >>= aDummy;
(*this) = aDummy;
break;
}
case TypeClass_UNSIGNED_SHORT:
{
sal_uInt16 nValue(0);
_rValue >>= nValue;
(*this) = nValue;
break;
}
case TypeClass_LONG:
{
sal_Int32 aDummy(0);
_rValue >>= aDummy;
(*this) = aDummy;
break;
}
case TypeClass_UNSIGNED_LONG:
{
sal_uInt32 nValue(0);
_rValue >>= nValue;
(*this) = static_cast<sal_Int64>(nValue);
setSigned(false);
break;
}
case TypeClass_HYPER:
{
sal_Int64 nValue(0);
_rValue >>= nValue;
(*this) = nValue;
break;
}
case TypeClass_UNSIGNED_HYPER:
{
sal_uInt64 nValue(0);
_rValue >>= nValue;
(*this) = nValue;
setSigned(false);
break;
}
case TypeClass_ENUM:
{
sal_Int32 enumValue( 0 );
::cppu::enum2int( enumValue, _rValue );
(*this) = enumValue;
}
break;
case TypeClass_SEQUENCE:
{
Sequence<sal_Int8> aDummy;
if ( _rValue >>= aDummy )
(*this) = aDummy;
else
SAL_WARN( "connectivity.commontools", "ORowSetValue::fill: unsupported sequence type!" );
break;
}
case TypeClass_STRUCT:
{
css::util::Date aDate;
css::util::Time aTime;
css::util::DateTime aDateTime;
if ( _rValue >>= aDate )
{
(*this) = aDate;
}
else if ( _rValue >>= aTime )
{
(*this) = aTime;
}
else if ( _rValue >>= aDateTime )
{
(*this) = aDateTime;
}
else
SAL_WARN( "connectivity.commontools", "ORowSetValue::fill: unsupported structure!" );
break;
}
case TypeClass_INTERFACE:
{
Reference< XClob > xClob;
if ( _rValue >>= xClob )
{
(*this) = _rValue;
setTypeKind(DataType::CLOB);
}
else
{
Reference< XBlob > xBlob;
if ( _rValue >>= xBlob )
{
(*this) = _rValue;
setTypeKind(DataType::BLOB);
}
else
{
(*this) = _rValue;
}
}
}
break;
default:
SAL_WARN( "connectivity.commontools","Unknown type");
break;
}
}
} // namespace connectivity
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
