| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_connectivity.hxx" |
| |
| #include <stdio.h> |
| #include "connectivity/FValue.hxx" |
| #include "connectivity/CommonTools.hxx" |
| #include <connectivity/dbconversion.hxx> |
| #include <comphelper/extract.hxx> |
| #include <com/sun/star/io/XInputStream.hpp> |
| #include <rtl/ustrbuf.hxx> |
| #include <rtl/logfile.hxx> |
| |
| 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 { |
| static sal_Bool isStorageCompatible(sal_Int32 _eType1, sal_Int32 _eType2) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::isStorageCompatible" ); |
| sal_Bool bIsCompatible = sal_True; |
| |
| if (_eType1 != _eType2) |
| { |
| RTL_LOGFILE_CONTEXT_TRACE( aLogger, "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 = sal_False; |
| } |
| } |
| return bIsCompatible; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| #ifdef DBG_UTIL |
| |
| #include <vector> |
| #include <rtl/string.h> |
| |
| namespace tracing |
| { |
| struct AllocationType |
| { |
| const sal_Char* pName; |
| sal_Int32 nAllocatedUnits; |
| |
| AllocationType( ) : pName( NULL ), nAllocatedUnits( 0 ) { } |
| }; |
| |
| // ============================================================================= |
| class AllocationTracer |
| { |
| public: |
| typedef ::std::vector< AllocationType > AllocationState; |
| static AllocationState s_aAllocated; |
| static ::osl::Mutex s_aMutex; |
| |
| public: |
| static void registerUnit( const sal_Char* _pName ); |
| static void revokeUnit( const sal_Char* _pName ); |
| |
| private: |
| static AllocationState::iterator getLocation( const sal_Char* _pName ); |
| }; |
| |
| // ============================================================================= |
| AllocationTracer::AllocationState::iterator AllocationTracer::getLocation( const sal_Char* _pName ) |
| { |
| AllocationState::iterator aLookFor = s_aAllocated.begin(); |
| for ( ; |
| aLookFor != s_aAllocated.end(); |
| ++aLookFor |
| ) |
| { |
| if ( 0 == rtl_str_compare( aLookFor->pName, _pName ) ) |
| // found |
| return aLookFor; |
| } |
| // not found |
| s_aAllocated.push_back( AllocationType() ); |
| aLookFor = s_aAllocated.end(); --aLookFor; |
| aLookFor->pName = _pName; // note that this assumes that _pName is a constant string .... |
| return aLookFor; |
| } |
| |
| // ============================================================================= |
| AllocationTracer::AllocationState AllocationTracer::s_aAllocated; |
| ::osl::Mutex AllocationTracer::s_aMutex; |
| |
| // ============================================================================= |
| void AllocationTracer::registerUnit( const sal_Char* _pName ) |
| { |
| ::osl::MutexGuard aGuard( s_aMutex ); |
| |
| AllocationState::iterator aPos = getLocation( _pName ); |
| ++aPos->nAllocatedUnits; |
| } |
| |
| // ============================================================================= |
| void AllocationTracer::revokeUnit( const sal_Char* _pName ) |
| { |
| ::osl::MutexGuard aGuard( s_aMutex ); |
| |
| AllocationState::iterator aPos = getLocation( _pName ); |
| --aPos->nAllocatedUnits; |
| } |
| |
| #define TRACE_ALLOC( type ) tracing::AllocationTracer::registerUnit( #type ); |
| #define TRACE_FREE( type ) tracing::AllocationTracer::revokeUnit( #type ); |
| } |
| #else |
| #define TRACE_ALLOC( type ) |
| #define TRACE_FREE( type ) |
| #endif |
| |
| // ----------------------------------------------------------------------------- |
| void ORowSetValue::setTypeKind(sal_Int32 _eType) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::setTypeKind" ); |
| 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: |
| (*this) = getLong(); |
| 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: |
| (*this) = getInt32(); |
| 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) = getAny(); |
| break; |
| default: |
| (*this) = getAny(); |
| OSL_ENSURE(0,"ORowSetValue:operator==(): UNSPUPPORTED TYPE!"); |
| } |
| } |
| |
| m_eTypeKind = _eType; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ORowSetValue::free() |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::free" ); |
| if(!m_bNull) |
| { |
| 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 = NULL; |
| break; |
| case DataType::INTEGER: |
| if ( !m_bSigned ) |
| { |
| delete (sal_Int64*)m_aValue.m_pValue; |
| TRACE_FREE( sal_Int64 ) |
| m_aValue.m_pValue = NULL; |
| } |
| break; |
| case DataType::BIGINT: |
| if ( m_bSigned ) |
| { |
| delete (sal_Int64*)m_aValue.m_pValue; |
| TRACE_FREE( sal_Int64 ) |
| m_aValue.m_pValue = NULL; |
| } |
| else |
| { |
| OSL_ENSURE(m_aValue.m_pString,"String pointer is null!"); |
| rtl_uString_release(m_aValue.m_pString); |
| m_aValue.m_pString = NULL; |
| } |
| break; |
| case DataType::FLOAT: |
| delete (float*)m_aValue.m_pValue; |
| TRACE_FREE( float ) |
| m_aValue.m_pValue = NULL; |
| break; |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| delete (double*)m_aValue.m_pValue; |
| TRACE_FREE( double ) |
| m_aValue.m_pValue = NULL; |
| break; |
| case DataType::DATE: |
| delete (::com::sun::star::util::Date*)m_aValue.m_pValue; |
| TRACE_FREE( Date ) |
| m_aValue.m_pValue = NULL; |
| break; |
| case DataType::TIME: |
| delete (::com::sun::star::util::Time*)m_aValue.m_pValue; |
| TRACE_FREE( Time ) |
| m_aValue.m_pValue = NULL; |
| break; |
| case DataType::TIMESTAMP: |
| delete (::com::sun::star::util::DateTime*)m_aValue.m_pValue; |
| TRACE_FREE( DateTime ) |
| m_aValue.m_pValue = NULL; |
| break; |
| case DataType::BINARY: |
| case DataType::VARBINARY: |
| case DataType::LONGVARBINARY: |
| delete (Sequence<sal_Int8>*)m_aValue.m_pValue; |
| TRACE_FREE( Sequence_sal_Int8 ) |
| m_aValue.m_pValue = NULL; |
| break; |
| case DataType::BLOB: |
| case DataType::CLOB: |
| case DataType::OBJECT: |
| delete (Any*)m_aValue.m_pValue; |
| TRACE_FREE( Any ) |
| m_aValue.m_pValue = NULL; |
| break; |
| case DataType::BIT: |
| case DataType::TINYINT: |
| case DataType::SMALLINT: |
| case DataType::BOOLEAN: |
| break; |
| default: |
| if ( m_aValue.m_pValue ) |
| { |
| delete (Any*)m_aValue.m_pValue; |
| TRACE_FREE( Any ) |
| m_aValue.m_pValue = NULL; |
| } |
| break; |
| |
| } |
| m_bNull = sal_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_bSigned) |
| 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::BIGINT: |
| if ( _rRH.m_bSigned ) |
| { |
| m_aValue.m_pValue = new sal_Int64(*(sal_Int64*)_rRH.m_aValue.m_pValue); |
| TRACE_ALLOC( sal_Int64 ) |
| } |
| else |
| { |
| rtl_uString_acquire(_rRH.m_aValue.m_pString); |
| m_aValue.m_pString = _rRH.m_aValue.m_pString; |
| } |
| break; |
| case DataType::FLOAT: |
| m_aValue.m_pValue = new float(*(float*)_rRH.m_aValue.m_pValue); |
| TRACE_ALLOC( float ) |
| break; |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| m_aValue.m_pValue = new double(*(double*)_rRH.m_aValue.m_pValue); |
| TRACE_ALLOC( double ) |
| break; |
| case DataType::DATE: |
| m_aValue.m_pValue = new Date(*(Date*)_rRH.m_aValue.m_pValue); |
| TRACE_ALLOC( Date ) |
| break; |
| case DataType::TIME: |
| m_aValue.m_pValue = new Time(*(Time*)_rRH.m_aValue.m_pValue); |
| TRACE_ALLOC( Time ) |
| break; |
| case DataType::TIMESTAMP: |
| m_aValue.m_pValue = new DateTime(*(DateTime*)_rRH.m_aValue.m_pValue); |
| TRACE_ALLOC( DateTime ) |
| break; |
| case DataType::BINARY: |
| case DataType::VARBINARY: |
| case DataType::LONGVARBINARY: |
| m_aValue.m_pValue = new Sequence<sal_Int8>(*(Sequence<sal_Int8>*)_rRH.m_aValue.m_pValue); |
| TRACE_ALLOC( Sequence_sal_Int8 ) |
| 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_nInt16 = _rRH.m_aValue.m_nInt16; |
| break; |
| case DataType::SMALLINT: |
| if ( _rRH.m_bSigned ) |
| m_aValue.m_nInt16 = _rRH.m_aValue.m_nInt16; |
| else |
| m_aValue.m_nInt32 = _rRH.m_aValue.m_nInt32; |
| break; |
| case DataType::INTEGER: |
| if ( _rRH.m_bSigned ) |
| m_aValue.m_nInt32 = _rRH.m_aValue.m_nInt32; |
| else |
| { |
| m_aValue.m_pValue = new sal_Int64(*(sal_Int64*)_rRH.m_aValue.m_pValue); |
| TRACE_ALLOC( sal_Int64 ) |
| } |
| break; |
| default: |
| m_aValue.m_pValue = new Any(*(Any*)_rRH.m_aValue.m_pValue); |
| TRACE_ALLOC( Any ) |
| } |
| } |
| 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) = ::rtl::OUString(_rRH.m_aValue.m_pString); |
| break; |
| case DataType::BIGINT: |
| if ( _rRH.m_bSigned ) |
| (*this) = *(sal_Int64*)_rRH.m_aValue.m_pValue; |
| else |
| (*this) = ::rtl::OUString(_rRH.m_aValue.m_pString); |
| break; |
| case DataType::FLOAT: |
| (*this) = *(float*)_rRH.m_aValue.m_pValue; |
| break; |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| (*this) = *(double*)_rRH.m_aValue.m_pValue; |
| break; |
| case DataType::DATE: |
| (*this) = *(Date*)_rRH.m_aValue.m_pValue; |
| break; |
| case DataType::TIME: |
| (*this) = *(Time*)_rRH.m_aValue.m_pValue; |
| break; |
| case DataType::TIMESTAMP: |
| (*this) = *(DateTime*)_rRH.m_aValue.m_pValue; |
| break; |
| case DataType::BINARY: |
| case DataType::VARBINARY: |
| case DataType::LONGVARBINARY: |
| (*this) = *(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_nInt16 = _rRH.m_aValue.m_nInt16; |
| break; |
| case DataType::SMALLINT: |
| if ( _rRH.m_bSigned ) |
| m_aValue.m_nInt16 = _rRH.m_aValue.m_nInt16; |
| else |
| m_aValue.m_nInt32 = _rRH.m_aValue.m_nInt32; |
| break; |
| case DataType::INTEGER: |
| if ( _rRH.m_bSigned ) |
| m_aValue.m_nInt32 = _rRH.m_aValue.m_nInt32; |
| else |
| *static_cast<sal_Int64*>(m_aValue.m_pValue) = *(sal_Int64*)_rRH.m_aValue.m_pValue; |
| break; |
| default: |
| (*(Any*)m_aValue.m_pValue) = (*(Any*)_rRH.m_aValue.m_pValue); |
| } |
| } |
| |
| m_bNull = _rRH.m_bNull; |
| // OJ: BUGID: 96277 |
| m_eTypeKind = _rRH.m_eTypeKind; |
| |
| return *this; |
| } |
| // ------------------------------------------------------------------------- |
| |
| ORowSetValue& ORowSetValue::operator=(const Date& _rRH) |
| { |
| if(m_eTypeKind != DataType::DATE) |
| free(); |
| |
| if(m_bNull) |
| { |
| m_aValue.m_pValue = new Date(_rRH); |
| TRACE_ALLOC( Date ) |
| m_eTypeKind = DataType::DATE; |
| m_bNull = sal_False; |
| } |
| else |
| *(Date*)m_aValue.m_pValue = _rRH; |
| |
| return *this; |
| } |
| // ------------------------------------------------------------------------- |
| ORowSetValue& ORowSetValue::operator=(const Time& _rRH) |
| { |
| if(m_eTypeKind != DataType::TIME) |
| free(); |
| |
| if(m_bNull) |
| { |
| m_aValue.m_pValue = new Time(_rRH); |
| TRACE_ALLOC( Time ) |
| m_eTypeKind = DataType::TIME; |
| m_bNull = sal_False; |
| } |
| else |
| *(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); |
| TRACE_ALLOC( DateTime ) |
| m_eTypeKind = DataType::TIMESTAMP; |
| m_bNull = sal_False; |
| } |
| else |
| *(DateTime*)m_aValue.m_pValue = _rRH; |
| |
| return *this; |
| } |
| // ------------------------------------------------------------------------- |
| |
| ORowSetValue& ORowSetValue::operator=(const ::rtl::OUString& _rRH) |
| { |
| if(m_eTypeKind != DataType::VARCHAR || m_aValue.m_pString != _rRH.pData) |
| { |
| free(); |
| m_bNull = sal_False; |
| |
| m_aValue.m_pString = _rRH.pData; |
| rtl_uString_acquire(m_aValue.m_pString); |
| m_eTypeKind = DataType::VARCHAR; |
| } |
| |
| return *this; |
| } |
| // ------------------------------------------------------------------------- |
| |
| ORowSetValue& ORowSetValue::operator=(const double& _rRH) |
| { |
| if( !isStorageCompatible(m_eTypeKind,DataType::DOUBLE) ) |
| free(); |
| |
| if(m_bNull) |
| { |
| m_aValue.m_pValue = new double(_rRH); |
| TRACE_ALLOC( double ) |
| m_eTypeKind = DataType::DOUBLE; |
| m_bNull = sal_False; |
| } |
| else |
| *(double*)m_aValue.m_pValue = _rRH; |
| |
| return *this; |
| } |
| // ----------------------------------------------------------------------------- |
| ORowSetValue& ORowSetValue::operator=(const float& _rRH) |
| { |
| if(m_eTypeKind != DataType::FLOAT) |
| free(); |
| |
| if(m_bNull) |
| { |
| m_aValue.m_pValue = new float(_rRH); |
| TRACE_ALLOC( float ) |
| m_eTypeKind = DataType::FLOAT; |
| m_bNull = sal_False; |
| } |
| else |
| *(float*)m_aValue.m_pValue = _rRH; |
| |
| return *this; |
| } |
| // ------------------------------------------------------------------------- |
| |
| ORowSetValue& ORowSetValue::operator=(const sal_Int8& _rRH) |
| { |
| if(m_eTypeKind != DataType::TINYINT ) |
| free(); |
| |
| m_aValue.m_nInt8 = _rRH; |
| m_eTypeKind = DataType::TINYINT; |
| m_bNull = sal_False; |
| return *this; |
| } |
| // ------------------------------------------------------------------------- |
| |
| ORowSetValue& ORowSetValue::operator=(const sal_Int16& _rRH) |
| { |
| if(m_eTypeKind != DataType::SMALLINT ) |
| free(); |
| |
| m_aValue.m_nInt16 = _rRH; |
| m_eTypeKind = DataType::SMALLINT; |
| m_bNull = sal_False; |
| |
| return *this; |
| } |
| // ------------------------------------------------------------------------- |
| |
| ORowSetValue& ORowSetValue::operator=(const sal_Int32& _rRH) |
| { |
| if(m_eTypeKind != DataType::INTEGER ) |
| free(); |
| |
| if ( m_bSigned ) |
| m_aValue.m_nInt32 = _rRH; |
| else |
| { |
| if ( m_bNull ) |
| { |
| m_aValue.m_pValue = new sal_Int64(_rRH); |
| TRACE_ALLOC( sal_Int64 ) |
| } |
| else |
| *static_cast<sal_Int64*>(m_aValue.m_pValue) = static_cast<sal_Int64>(_rRH); |
| } |
| |
| m_eTypeKind = DataType::INTEGER; |
| m_bNull = sal_False; |
| |
| return *this; |
| } |
| // ------------------------------------------------------------------------- |
| |
| ORowSetValue& ORowSetValue::operator=(const sal_Bool _rRH) |
| { |
| if(m_eTypeKind != DataType::BIT && DataType::BOOLEAN != m_eTypeKind ) |
| free(); |
| |
| m_aValue.m_bBool = _rRH; |
| m_eTypeKind = DataType::BIT; |
| m_bNull = sal_False; |
| |
| return *this; |
| } |
| // ------------------------------------------------------------------------- |
| ORowSetValue& ORowSetValue::operator=(const sal_Int64& _rRH) |
| { |
| if ( DataType::BIGINT != m_eTypeKind || !m_bSigned ) |
| free(); |
| |
| if ( m_bSigned ) |
| { |
| if(m_bNull) |
| { |
| m_aValue.m_pValue = new sal_Int64(_rRH); |
| TRACE_ALLOC( sal_Int64 ) |
| } |
| else |
| *static_cast<sal_Int64*>(m_aValue.m_pValue) = _rRH; |
| } |
| else |
| { |
| ::rtl::OUString aVal = ::rtl::OUString::valueOf(_rRH); |
| m_aValue.m_pString = aVal.pData; |
| rtl_uString_acquire(m_aValue.m_pString); |
| } |
| |
| m_eTypeKind = DataType::BIGINT; |
| m_bNull = sal_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); |
| TRACE_ALLOC( Sequence_sal_Int8 ) |
| } |
| else |
| *static_cast< Sequence< sal_Int8 >* >(m_aValue.m_pValue) = _rRH; |
| |
| m_eTypeKind = DataType::LONGVARBINARY; |
| m_bNull = sal_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); |
| TRACE_ALLOC( Any ) |
| } |
| else |
| *static_cast<Any*>(m_aValue.m_pValue) = _rAny; |
| |
| m_eTypeKind = DataType::OBJECT; |
| m_bNull = sal_False; |
| |
| return *this; |
| } |
| // ------------------------------------------------------------------------- |
| |
| sal_Bool operator==(const Date& _rLH,const Date& _rRH) |
| { |
| return _rLH.Day == _rRH.Day && _rLH.Month == _rRH.Month && _rLH.Year == _rRH.Year; |
| } |
| // ------------------------------------------------------------------------- |
| |
| sal_Bool operator==(const Time& _rLH,const Time& _rRH) |
| { |
| return _rLH.Minutes == _rRH.Minutes && _rLH.Hours == _rRH.Hours && _rLH.Seconds == _rRH.Seconds && _rLH.HundredthSeconds == _rRH.HundredthSeconds; |
| } |
| // ------------------------------------------------------------------------- |
| |
| sal_Bool operator==(const DateTime& _rLH,const DateTime& _rRH) |
| { |
| return _rLH.Day == _rRH.Day && _rLH.Month == _rRH.Month && _rLH.Year == _rRH.Year && |
| _rLH.Minutes == _rRH.Minutes && _rLH.Hours == _rRH.Hours && _rLH.Seconds == _rRH.Seconds && _rLH.HundredthSeconds == _rRH.HundredthSeconds; |
| } |
| // ------------------------------------------------------------------------- |
| |
| bool ORowSetValue::operator==(const ORowSetValue& _rRH) const |
| { |
| if ( m_bNull != _rRH.isNull() ) |
| return false; |
| |
| if(m_bNull && _rRH.isNull()) |
| return true; |
| |
| if ( 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: |
| { |
| ::rtl::OUString aVal1(m_aValue.m_pString); |
| ::rtl::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: |
| { |
| ::rtl::OUString aVal1(m_aValue.m_pString); |
| ::rtl::OUString aVal2(_rRH.m_aValue.m_pString); |
| bRet = aVal1 == aVal2; |
| } |
| break; |
| case DataType::FLOAT: |
| bRet = *(float*)m_aValue.m_pValue == *(float*)_rRH.m_aValue.m_pValue; |
| break; |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| bRet = *(double*)m_aValue.m_pValue == *(double*)_rRH.m_aValue.m_pValue; |
| break; |
| case DataType::TINYINT: |
| bRet = m_bSigned ? ( m_aValue.m_nInt8 == _rRH.m_aValue.m_nInt8 ) : (m_aValue.m_nInt16 == _rRH.m_aValue.m_nInt16); |
| break; |
| case DataType::SMALLINT: |
| bRet = m_bSigned ? ( m_aValue.m_nInt16 == _rRH.m_aValue.m_nInt16 ) : (m_aValue.m_nInt32 == _rRH.m_aValue.m_nInt32); |
| break; |
| case DataType::INTEGER: |
| bRet = m_bSigned ? ( m_aValue.m_nInt32 == _rRH.m_aValue.m_nInt32 ) : (*(sal_Int64*)m_aValue.m_pValue == *(sal_Int64*)_rRH.m_aValue.m_pValue); |
| break; |
| case DataType::BIGINT: |
| if ( m_bSigned ) |
| bRet = *(sal_Int64*)m_aValue.m_pValue == *(sal_Int64*)_rRH.m_aValue.m_pValue; |
| else |
| { |
| ::rtl::OUString aVal1(m_aValue.m_pString); |
| ::rtl::OUString aVal2(_rRH.m_aValue.m_pString); |
| bRet = aVal1 == aVal2; |
| } |
| break; |
| case DataType::BIT: |
| case DataType::BOOLEAN: |
| bRet = m_aValue.m_bBool == _rRH.m_aValue.m_bBool; |
| break; |
| case DataType::DATE: |
| bRet = *(Date*)m_aValue.m_pValue == *(Date*)_rRH.m_aValue.m_pValue; |
| break; |
| case DataType::TIME: |
| bRet = *(Time*)m_aValue.m_pValue == *(Time*)_rRH.m_aValue.m_pValue; |
| break; |
| case DataType::TIMESTAMP: |
| bRet = *(DateTime*)m_aValue.m_pValue == *(DateTime*)_rRH.m_aValue.m_pValue; |
| break; |
| case DataType::BINARY: |
| case DataType::VARBINARY: |
| case DataType::LONGVARBINARY: |
| bRet = false; |
| break; |
| case DataType::BLOB: |
| case DataType::CLOB: |
| case DataType::OBJECT: |
| case DataType::OTHER: |
| bRet = false; |
| break; |
| default: |
| bRet = false; |
| OSL_ENSURE(0,"ORowSetValue::operator==(): UNSPUPPORTED TYPE!"); |
| break; |
| } |
| return bRet; |
| } |
| // ------------------------------------------------------------------------- |
| Any ORowSetValue::makeAny() const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::makeAny" ); |
| Any rValue; |
| if(isBound() && !isNull()) |
| { |
| switch(getTypeKind()) |
| { |
| 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 <<= (::rtl::OUString)m_aValue.m_pString; |
| break; |
| case DataType::BIGINT: |
| if ( m_bSigned ) |
| { |
| OSL_ENSURE(m_aValue.m_pValue,"Value is null!"); |
| rValue <<= *(sal_Int64*)m_aValue.m_pValue; |
| } |
| else |
| { |
| OSL_ENSURE(m_aValue.m_pString,"Value is null!"); |
| rValue <<= (::rtl::OUString)m_aValue.m_pString; |
| } |
| break; |
| case DataType::FLOAT: |
| OSL_ENSURE(m_aValue.m_pValue,"Value is null!"); |
| rValue <<= *(float*)m_aValue.m_pValue; |
| break; |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| OSL_ENSURE(m_aValue.m_pValue,"Value is null!"); |
| rValue <<= *(double*)m_aValue.m_pValue; |
| break; |
| case DataType::DATE: |
| OSL_ENSURE(m_aValue.m_pValue,"Value is null!"); |
| rValue <<= *(Date*)m_aValue.m_pValue; |
| break; |
| case DataType::TIME: |
| OSL_ENSURE(m_aValue.m_pValue,"Value is null!"); |
| rValue <<= *(Time*)m_aValue.m_pValue; |
| break; |
| case DataType::TIMESTAMP: |
| OSL_ENSURE(m_aValue.m_pValue,"Value is null!"); |
| rValue <<= *(DateTime*)m_aValue.m_pValue; |
| break; |
| case DataType::BINARY: |
| case DataType::VARBINARY: |
| case DataType::LONGVARBINARY: |
| OSL_ENSURE(m_aValue.m_pValue,"Value is null!"); |
| rValue <<= *(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.setValue( &m_aValue.m_bBool, ::getCppuBooleanType() ); |
| break; |
| case DataType::TINYINT: |
| if ( m_bSigned ) |
| rValue <<= m_aValue.m_nInt8; |
| else |
| rValue <<= m_aValue.m_nInt16; |
| break; |
| case DataType::SMALLINT: |
| if ( m_bSigned ) |
| rValue <<= m_aValue.m_nInt16; |
| else |
| rValue <<= m_aValue.m_nInt32; |
| break; |
| case DataType::INTEGER: |
| if ( m_bSigned ) |
| rValue <<= m_aValue.m_nInt32; |
| else |
| { |
| OSL_ENSURE(m_aValue.m_pValue,"Value is null!"); |
| rValue <<= *(sal_Int64*)m_aValue.m_pValue; |
| } |
| break; |
| default: |
| OSL_ENSURE(0,"ORowSetValue::makeAny(): UNSPUPPORTED TYPE!"); |
| rValue = getAny(); |
| break; |
| } |
| } |
| return rValue; |
| } |
| // ------------------------------------------------------------------------- |
| ::rtl::OUString ORowSetValue::getString( ) const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getString" ); |
| ::rtl::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::BIGINT: |
| if ( m_bSigned ) |
| aRet = ::rtl::OUString::valueOf((sal_Int64)*this); |
| else |
| aRet = m_aValue.m_pString; |
| break; |
| case DataType::FLOAT: |
| aRet = ::rtl::OUString::valueOf((float)*this); |
| break; |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| aRet = ::rtl::OUString::valueOf((double)*this); |
| break; |
| case DataType::DATE: |
| aRet = connectivity::toDateString(*this); |
| break; |
| case DataType::TIME: |
| aRet = connectivity::toTimeString(*this); |
| break; |
| case DataType::TIMESTAMP: |
| aRet = connectivity::toDateTimeString(*this); |
| break; |
| case DataType::BINARY: |
| case DataType::VARBINARY: |
| case DataType::LONGVARBINARY: |
| { |
| ::rtl::OUStringBuffer sVal = ::rtl::OUString::createFromAscii("0x"); |
| Sequence<sal_Int8> aSeq(getSequence()); |
| const sal_Int8* pBegin = aSeq.getConstArray(); |
| const sal_Int8* pEnd = pBegin + aSeq.getLength(); |
| for(;pBegin != pEnd;++pBegin) |
| sVal.append((sal_Int32)*pBegin,16); |
| aRet = sVal.makeStringAndClear(); |
| } |
| break; |
| case DataType::BIT: |
| case DataType::BOOLEAN: |
| aRet = ::rtl::OUString::valueOf((sal_Int32)(sal_Bool)*this); |
| break; |
| case DataType::TINYINT: |
| if ( m_bSigned ) |
| aRet = ::rtl::OUString::valueOf((sal_Int32)(sal_Int8)*this); |
| else |
| aRet = ::rtl::OUString::valueOf((sal_Int32)(sal_Int16)*this); |
| break; |
| case DataType::SMALLINT: |
| if ( m_bSigned ) |
| aRet = ::rtl::OUString::valueOf((sal_Int32)(sal_Int16)*this); |
| else |
| aRet = ::rtl::OUString::valueOf((sal_Int32)*this); |
| break; |
| case DataType::INTEGER: |
| if ( m_bSigned ) |
| aRet = ::rtl::OUString::valueOf((sal_Int32)*this); |
| else |
| aRet = ::rtl::OUString::valueOf((sal_Int64)*this); |
| break; |
| case DataType::CLOB: |
| { |
| Any aValue( getAny() ); |
| Reference< XClob > xClob; |
| if ( aValue >>= xClob ) |
| { |
| if ( xClob.is() ) |
| { |
| aRet = xClob->getSubString(1,(sal_Int32)xClob->length() ); |
| } |
| } |
| } |
| break; |
| default: |
| { |
| Any aValue = getAny(); |
| aValue >>= aRet; |
| break; |
| } |
| } |
| } |
| return aRet; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool ORowSetValue::getBool() const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getBool" ); |
| sal_Bool bRet = sal_False; |
| if(!m_bNull) |
| { |
| switch(getTypeKind()) |
| { |
| case DataType::CHAR: |
| case DataType::VARCHAR: |
| case DataType::LONGVARCHAR: |
| { |
| const ::rtl::OUString sValue(m_aValue.m_pString); |
| const static ::rtl::OUString s_sTrue(RTL_CONSTASCII_USTRINGPARAM("true")); |
| const static ::rtl::OUString s_sFalse(RTL_CONSTASCII_USTRINGPARAM("false")); |
| if ( sValue.equalsIgnoreAsciiCase(s_sTrue) ) |
| { |
| bRet = sal_True; |
| break; |
| } |
| else if ( sValue.equalsIgnoreAsciiCase(s_sFalse) ) |
| { |
| bRet = sal_False; |
| break; |
| } |
| } |
| // run through |
| case DataType::DECIMAL: |
| case DataType::NUMERIC: |
| |
| bRet = ::rtl::OUString(m_aValue.m_pString).toInt32() != 0; |
| break; |
| case DataType::BIGINT: |
| if ( m_bSigned ) |
| bRet = *(sal_Int64*)m_aValue.m_pValue != 0; |
| else |
| bRet = ::rtl::OUString(m_aValue.m_pString).toInt64() != 0; |
| break; |
| case DataType::FLOAT: |
| bRet = *(float*)m_aValue.m_pValue != 0.0; |
| break; |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| bRet = *(double*)m_aValue.m_pValue != 0.0; |
| break; |
| case DataType::DATE: |
| case DataType::TIME: |
| case DataType::TIMESTAMP: |
| case DataType::BINARY: |
| case DataType::VARBINARY: |
| case DataType::LONGVARBINARY: |
| OSL_ASSERT(!"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_nInt16 != 0); |
| break; |
| case DataType::SMALLINT: |
| bRet = m_bSigned ? (m_aValue.m_nInt16 != 0) : (m_aValue.m_nInt32 != 0); |
| break; |
| case DataType::INTEGER: |
| bRet = m_bSigned ? (m_aValue.m_nInt32 != 0) : (*static_cast<sal_Int64*>(m_aValue.m_pValue) != sal_Int64(0)); |
| break; |
| default: |
| { |
| Any aValue = getAny(); |
| aValue >>= bRet; |
| break; |
| } |
| } |
| } |
| return bRet; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int8 ORowSetValue::getInt8() const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getInt8" ); |
| |
| |
| 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(::rtl::OUString(m_aValue.m_pString).toInt32()); |
| break; |
| case DataType::BIGINT: |
| if ( m_bSigned ) |
| nRet = sal_Int8(*(sal_Int64*)m_aValue.m_pValue); |
| else |
| nRet = sal_Int8(::rtl::OUString(m_aValue.m_pString).toInt32()); |
| break; |
| case DataType::FLOAT: |
| nRet = sal_Int8(*(float*)m_aValue.m_pValue); |
| break; |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| nRet = sal_Int8(*(double*)m_aValue.m_pValue); |
| 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_ASSERT(!"getInt8() for this type is not allowed!"); |
| break; |
| case DataType::BIT: |
| case DataType::BOOLEAN: |
| nRet = 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_nInt16); |
| 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_nInt32); |
| break; |
| case DataType::INTEGER: |
| if ( m_bSigned ) |
| nRet = static_cast<sal_Int8>(m_aValue.m_nInt32); |
| else |
| nRet = static_cast<sal_Int8>(*static_cast<sal_Int64*>(m_aValue.m_pValue)); |
| break; |
| default: |
| { |
| Any aValue = getAny(); |
| aValue >>= nRet; |
| break; |
| } |
| } |
| } |
| return nRet; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int16 ORowSetValue::getInt16() const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getInt16" ); |
| |
| |
| 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(::rtl::OUString(m_aValue.m_pString).toInt32()); |
| break; |
| case DataType::BIGINT: |
| if ( m_bSigned ) |
| nRet = sal_Int16(*(sal_Int64*)m_aValue.m_pValue); |
| else |
| nRet = sal_Int16(::rtl::OUString(m_aValue.m_pString).toInt32()); |
| break; |
| case DataType::FLOAT: |
| nRet = sal_Int16(*(float*)m_aValue.m_pValue); |
| break; |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| nRet = sal_Int16(*(double*)m_aValue.m_pValue); |
| 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_ASSERT(!"getInt16() for this type is not allowed!"); |
| break; |
| case DataType::BIT: |
| case DataType::BOOLEAN: |
| nRet = m_aValue.m_bBool; |
| break; |
| case DataType::TINYINT: |
| if ( m_bSigned ) |
| nRet = m_aValue.m_nInt8; |
| else |
| nRet = m_aValue.m_nInt16; |
| break; |
| case DataType::SMALLINT: |
| if ( m_bSigned ) |
| nRet = m_aValue.m_nInt16; |
| else |
| nRet = static_cast<sal_Int16>(m_aValue.m_nInt32); |
| break; |
| case DataType::INTEGER: |
| if ( m_bSigned ) |
| nRet = static_cast<sal_Int16>(m_aValue.m_nInt32); |
| else |
| nRet = static_cast<sal_Int16>(*static_cast<sal_Int64*>(m_aValue.m_pValue)); |
| break; |
| default: |
| { |
| Any aValue = getAny(); |
| aValue >>= nRet; |
| break; |
| } |
| } |
| } |
| return nRet; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int32 ORowSetValue::getInt32() const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getInt32" ); |
| 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 = ::rtl::OUString(m_aValue.m_pString).toInt32(); |
| break; |
| case DataType::BIGINT: |
| if ( m_bSigned ) |
| nRet = sal_Int32(*(sal_Int64*)m_aValue.m_pValue); |
| else |
| nRet = ::rtl::OUString(m_aValue.m_pString).toInt32(); |
| break; |
| case DataType::FLOAT: |
| nRet = sal_Int32(*(float*)m_aValue.m_pValue); |
| break; |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| nRet = sal_Int32(*(double*)m_aValue.m_pValue); |
| break; |
| case DataType::DATE: |
| nRet = dbtools::DBTypeConversion::toDays(*(::com::sun::star::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_ASSERT(!"getInt32() for this type is not allowed!"); |
| break; |
| case DataType::BIT: |
| case DataType::BOOLEAN: |
| nRet = m_aValue.m_bBool; |
| break; |
| case DataType::TINYINT: |
| if ( m_bSigned ) |
| nRet = m_aValue.m_nInt8; |
| else |
| nRet = m_aValue.m_nInt16; |
| break; |
| case DataType::SMALLINT: |
| if ( m_bSigned ) |
| nRet = m_aValue.m_nInt16; |
| else |
| nRet = m_aValue.m_nInt32; |
| break; |
| case DataType::INTEGER: |
| if ( m_bSigned ) |
| nRet = m_aValue.m_nInt32; |
| else |
| nRet = static_cast<sal_Int32>(*static_cast<sal_Int64*>(m_aValue.m_pValue)); |
| break; |
| default: |
| { |
| Any aValue = getAny(); |
| aValue >>= nRet; |
| break; |
| } |
| } |
| } |
| return nRet; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int64 ORowSetValue::getLong() const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getLong" ); |
| 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 = ::rtl::OUString(m_aValue.m_pString).toInt64(); |
| break; |
| case DataType::BIGINT: |
| if ( m_bSigned ) |
| nRet = *(sal_Int64*)m_aValue.m_pValue; |
| else |
| nRet = ::rtl::OUString(m_aValue.m_pString).toInt64(); |
| break; |
| case DataType::FLOAT: |
| nRet = sal_Int64(*(float*)m_aValue.m_pValue); |
| break; |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| nRet = sal_Int64(*(double*)m_aValue.m_pValue); |
| break; |
| case DataType::DATE: |
| nRet = dbtools::DBTypeConversion::toDays(*(::com::sun::star::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_ASSERT(!"getInt32() for this type is not allowed!"); |
| break; |
| case DataType::BIT: |
| case DataType::BOOLEAN: |
| nRet = m_aValue.m_bBool; |
| break; |
| case DataType::TINYINT: |
| if ( m_bSigned ) |
| nRet = m_aValue.m_nInt8; |
| else |
| nRet = m_aValue.m_nInt16; |
| break; |
| case DataType::SMALLINT: |
| if ( m_bSigned ) |
| nRet = m_aValue.m_nInt16; |
| else |
| nRet = m_aValue.m_nInt32; |
| break; |
| case DataType::INTEGER: |
| if ( m_bSigned ) |
| nRet = m_aValue.m_nInt32; |
| else |
| nRet = *(sal_Int64*)m_aValue.m_pValue; |
| break; |
| default: |
| { |
| Any aValue = getAny(); |
| aValue >>= nRet; |
| break; |
| } |
| } |
| } |
| return nRet; |
| } |
| // ------------------------------------------------------------------------- |
| float ORowSetValue::getFloat() const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getFloat" ); |
| float nRet = 0; |
| if(!m_bNull) |
| { |
| switch(getTypeKind()) |
| { |
| case DataType::CHAR: |
| case DataType::VARCHAR: |
| case DataType::DECIMAL: |
| case DataType::NUMERIC: |
| case DataType::LONGVARCHAR: |
| nRet = ::rtl::OUString(m_aValue.m_pString).toFloat(); |
| break; |
| case DataType::BIGINT: |
| if ( m_bSigned ) |
| nRet = float(*(sal_Int64*)m_aValue.m_pValue); |
| else |
| nRet = ::rtl::OUString(m_aValue.m_pString).toFloat(); |
| break; |
| case DataType::FLOAT: |
| nRet = *(float*)m_aValue.m_pValue; |
| break; |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| nRet = (float)*(double*)m_aValue.m_pValue; |
| break; |
| case DataType::DATE: |
| nRet = (float)dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::Date*)m_aValue.m_pValue); |
| break; |
| case DataType::TIME: |
| nRet = (float)dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::Time*)m_aValue.m_pValue); |
| break; |
| case DataType::TIMESTAMP: |
| nRet = (float)dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::DateTime*)m_aValue.m_pValue); |
| break; |
| case DataType::BINARY: |
| case DataType::VARBINARY: |
| case DataType::LONGVARBINARY: |
| case DataType::BLOB: |
| case DataType::CLOB: |
| OSL_ASSERT(!"getDouble() for this type is not allowed!"); |
| break; |
| case DataType::BIT: |
| case DataType::BOOLEAN: |
| nRet = m_aValue.m_bBool; |
| break; |
| case DataType::TINYINT: |
| if ( m_bSigned ) |
| nRet = m_aValue.m_nInt8; |
| else |
| nRet = m_aValue.m_nInt16; |
| break; |
| case DataType::SMALLINT: |
| if ( m_bSigned ) |
| nRet = m_aValue.m_nInt16; |
| else |
| nRet = (float)m_aValue.m_nInt32; |
| break; |
| case DataType::INTEGER: |
| if ( m_bSigned ) |
| nRet = (float)m_aValue.m_nInt32; |
| else |
| nRet = float(*(sal_Int64*)m_aValue.m_pValue); |
| break; |
| default: |
| { |
| Any aValue = getAny(); |
| aValue >>= nRet; |
| break; |
| } |
| } |
| } |
| return nRet; |
| } |
| // ------------------------------------------------------------------------- |
| double ORowSetValue::getDouble() const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getDouble" ); |
| |
| |
| double nRet = 0; |
| if(!m_bNull) |
| { |
| switch(getTypeKind()) |
| { |
| case DataType::CHAR: |
| case DataType::VARCHAR: |
| case DataType::DECIMAL: |
| case DataType::NUMERIC: |
| case DataType::LONGVARCHAR: |
| nRet = ::rtl::OUString(m_aValue.m_pString).toDouble(); |
| break; |
| case DataType::BIGINT: |
| if ( m_bSigned ) |
| nRet = double(*(sal_Int64*)m_aValue.m_pValue); |
| else |
| nRet = ::rtl::OUString(m_aValue.m_pString).toDouble(); |
| break; |
| case DataType::FLOAT: |
| nRet = *(float*)m_aValue.m_pValue; |
| break; |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| nRet = *(double*)m_aValue.m_pValue; |
| break; |
| case DataType::DATE: |
| nRet = dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::Date*)m_aValue.m_pValue); |
| break; |
| case DataType::TIME: |
| nRet = dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::Time*)m_aValue.m_pValue); |
| break; |
| case DataType::TIMESTAMP: |
| nRet = dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::DateTime*)m_aValue.m_pValue); |
| break; |
| case DataType::BINARY: |
| case DataType::VARBINARY: |
| case DataType::LONGVARBINARY: |
| case DataType::BLOB: |
| case DataType::CLOB: |
| OSL_ASSERT(!"getDouble() for this type is not allowed!"); |
| break; |
| case DataType::BIT: |
| case DataType::BOOLEAN: |
| nRet = m_aValue.m_bBool; |
| break; |
| case DataType::TINYINT: |
| if ( m_bSigned ) |
| nRet = m_aValue.m_nInt8; |
| else |
| nRet = m_aValue.m_nInt16; |
| break; |
| case DataType::SMALLINT: |
| if ( m_bSigned ) |
| nRet = m_aValue.m_nInt16; |
| else |
| nRet = m_aValue.m_nInt32; |
| break; |
| case DataType::INTEGER: |
| if ( m_bSigned ) |
| nRet = m_aValue.m_nInt32; |
| else |
| nRet = double(*(sal_Int64*)m_aValue.m_pValue); |
| break; |
| default: |
| { |
| Any aValue = getAny(); |
| aValue >>= nRet; |
| break; |
| } |
| } |
| } |
| return nRet; |
| } |
| // ------------------------------------------------------------------------- |
| void ORowSetValue::setFromDouble(const double& _rVal,sal_Int32 _nDatatype) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::setFromDouble" ); |
| free(); |
| |
| m_bNull = sal_False; |
| switch(_nDatatype) |
| { |
| case DataType::CHAR: |
| case DataType::VARCHAR: |
| case DataType::DECIMAL: |
| case DataType::NUMERIC: |
| case DataType::LONGVARCHAR: |
| { |
| ::rtl::OUString aVal = ::rtl::OUString::valueOf(_rVal); |
| m_aValue.m_pString = aVal.pData; |
| rtl_uString_acquire(m_aValue.m_pString); |
| } |
| break; |
| case DataType::BIGINT: |
| if ( m_bSigned ) |
| { |
| m_aValue.m_pValue = new sal_Int64((sal_Int64)_rVal); |
| TRACE_ALLOC( sal_Int64 ) |
| } |
| else |
| { |
| ::rtl::OUString aVal = ::rtl::OUString::valueOf(_rVal); |
| m_aValue.m_pString = aVal.pData; |
| rtl_uString_acquire(m_aValue.m_pString); |
| } |
| break; |
| case DataType::FLOAT: |
| m_aValue.m_pValue = new float((float)_rVal); |
| TRACE_ALLOC( float ) |
| break; |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| m_aValue.m_pValue = new double(_rVal); |
| TRACE_ALLOC( double ) |
| break; |
| case DataType::DATE: |
| m_aValue.m_pValue = new Date(dbtools::DBTypeConversion::toDate(_rVal)); |
| TRACE_ALLOC( Date ) |
| break; |
| case DataType::TIME: |
| m_aValue.m_pValue = new Time(dbtools::DBTypeConversion::toTime(_rVal)); |
| TRACE_ALLOC( Time ) |
| break; |
| case DataType::TIMESTAMP: |
| m_aValue.m_pValue = new DateTime(dbtools::DBTypeConversion::toDateTime(_rVal)); |
| TRACE_ALLOC( DateTime ) |
| break; |
| case DataType::BINARY: |
| case DataType::VARBINARY: |
| case DataType::LONGVARBINARY: |
| case DataType::BLOB: |
| case DataType::CLOB: |
| OSL_ASSERT(!"setFromDouble() for this type is not allowed!"); |
| break; |
| case DataType::BIT: |
| case DataType::BOOLEAN: |
| m_aValue.m_bBool = _rVal != 0.0; |
| break; |
| case DataType::TINYINT: |
| if ( m_bSigned ) |
| m_aValue.m_nInt8 = sal_Int8(_rVal); |
| else |
| m_aValue.m_nInt16 = sal_Int16(_rVal); |
| break; |
| case DataType::SMALLINT: |
| if ( m_bSigned ) |
| m_aValue.m_nInt16 = sal_Int16(_rVal); |
| else |
| m_aValue.m_nInt32 = sal_Int32(_rVal); |
| break; |
| case DataType::INTEGER: |
| if ( m_bSigned ) |
| m_aValue.m_nInt32 = sal_Int32(_rVal); |
| else |
| { |
| m_aValue.m_pValue = new sal_Int64((sal_Int64)_rVal); |
| TRACE_ALLOC( sal_Int64 ) |
| } |
| break; |
| default: |
| { |
| m_aValue.m_pValue = new Any(_rVal); |
| break; |
| } |
| } |
| m_eTypeKind = _nDatatype; |
| } |
| // ----------------------------------------------------------------------------- |
| Sequence<sal_Int8> ORowSetValue::getSequence() const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getSequence" ); |
| 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 |
| { |
| ::com::sun::star::uno::Sequence< sal_Int8 > aReadSeq; |
| |
| nRead = xStream->readSomeBytes( aReadSeq, nBytesToRead ); |
| |
| if( nRead ) |
| { |
| const sal_uInt32 nOldLength = aSeq.getLength(); |
| aSeq.realloc( nOldLength + nRead ); |
| rtl_copyMemory( aSeq.getArray() + nOldLength, aReadSeq.getConstArray(), aReadSeq.getLength() ); |
| } |
| } |
| while( nBytesToRead == nRead ); |
| xStream->closeInput(); |
| } |
| } |
| } |
| break; |
| case DataType::VARCHAR: |
| case DataType::LONGVARCHAR: |
| { |
| ::rtl::OUString sVal(m_aValue.m_pString); |
| aSeq = Sequence<sal_Int8>(reinterpret_cast<const sal_Int8*>(sVal.getStr()),sizeof(sal_Unicode)*sVal.getLength()); |
| } |
| break; |
| case DataType::BINARY: |
| case DataType::VARBINARY: |
| case DataType::LONGVARBINARY: |
| aSeq = *static_cast< Sequence<sal_Int8>*>(m_aValue.m_pValue); |
| break; |
| default: |
| { |
| Any aValue = getAny(); |
| aValue >>= aSeq; |
| break; |
| } |
| } |
| } |
| return aSeq; |
| |
| } |
| // ----------------------------------------------------------------------------- |
| ::com::sun::star::util::Date ORowSetValue::getDate() const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getDate" ); |
| ::com::sun::star::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((double)*this); |
| break; |
| |
| case DataType::DATE: |
| aValue = *static_cast< ::com::sun::star::util::Date*>(m_aValue.m_pValue); |
| break; |
| case DataType::TIMESTAMP: |
| { |
| ::com::sun::star::util::DateTime* pDateTime = static_cast< ::com::sun::star::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( sal_Int64( *this ) ) ); |
| break; |
| |
| case DataType::BLOB: |
| case DataType::CLOB: |
| case DataType::OBJECT: |
| default: |
| OSL_ENSURE( false, "ORowSetValue::getDate: cannot retrieve the data!" ); |
| // NO break! |
| |
| case DataType::BINARY: |
| case DataType::VARBINARY: |
| case DataType::LONGVARBINARY: |
| case DataType::TIME: |
| aValue = DBTypeConversion::toDate( (double)0 ); |
| break; |
| } |
| } |
| return aValue; |
| } |
| // ----------------------------------------------------------------------------- |
| ::com::sun::star::util::Time ORowSetValue::getTime() const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getTime" ); |
| ::com::sun::star::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: |
| aValue = DBTypeConversion::toTime((double)*this); |
| break; |
| case DataType::FLOAT: |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| aValue = DBTypeConversion::toTime((double)*this); |
| break; |
| case DataType::TIMESTAMP: |
| { |
| ::com::sun::star::util::DateTime* pDateTime = static_cast< ::com::sun::star::util::DateTime*>(m_aValue.m_pValue); |
| aValue.HundredthSeconds = pDateTime->HundredthSeconds; |
| aValue.Seconds = pDateTime->Seconds; |
| aValue.Minutes = pDateTime->Minutes; |
| aValue.Hours = pDateTime->Hours; |
| } |
| break; |
| case DataType::TIME: |
| aValue = *static_cast< ::com::sun::star::util::Time*>(m_aValue.m_pValue); |
| break; |
| default: |
| { |
| Any aAnyValue = getAny(); |
| aAnyValue >>= aValue; |
| break; |
| } |
| } |
| } |
| return aValue; |
| } |
| // ----------------------------------------------------------------------------- |
| ::com::sun::star::util::DateTime ORowSetValue::getDateTime() const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getDateTime" ); |
| ::com::sun::star::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: |
| aValue = DBTypeConversion::toDateTime((double)*this); |
| break; |
| case DataType::FLOAT: |
| case DataType::DOUBLE: |
| case DataType::REAL: |
| aValue = DBTypeConversion::toDateTime((double)*this); |
| break; |
| case DataType::DATE: |
| { |
| ::com::sun::star::util::Date* pDate = static_cast< ::com::sun::star::util::Date*>(m_aValue.m_pValue); |
| aValue.Day = pDate->Day; |
| aValue.Month = pDate->Month; |
| aValue.Year = pDate->Year; |
| } |
| break; |
| case DataType::TIME: |
| { |
| ::com::sun::star::util::Time* pTime = static_cast< ::com::sun::star::util::Time*>(m_aValue.m_pValue); |
| aValue.HundredthSeconds = pTime->HundredthSeconds; |
| aValue.Seconds = pTime->Seconds; |
| aValue.Minutes = pTime->Minutes; |
| aValue.Hours = pTime->Hours; |
| } |
| break; |
| case DataType::TIMESTAMP: |
| aValue = *static_cast< ::com::sun::star::util::DateTime*>(m_aValue.m_pValue); |
| break; |
| default: |
| { |
| Any aAnyValue = getAny(); |
| aAnyValue >>= aValue; |
| break; |
| } |
| } |
| } |
| return aValue; |
| } |
| // ----------------------------------------------------------------------------- |
| void ORowSetValue::setSigned(sal_Bool _bMod) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::setSigned" ); |
| if ( m_bSigned != _bMod ) |
| { |
| m_bSigned = _bMod; |
| if ( !m_bNull ) |
| { |
| sal_Int32 nType = m_eTypeKind; |
| switch(m_eTypeKind) |
| { |
| case DataType::BIGINT: |
| if ( m_bSigned ) // now we are signed, so we were unsigned and need to call getString() |
| { |
| m_bSigned = !m_bSigned; |
| const ::rtl::OUString sValue = getString(); |
| free(); |
| m_bSigned = !m_bSigned; |
| (*this) = sValue; |
| } |
| else |
| { |
| m_bSigned = !m_bSigned; |
| const sal_Int64 nValue = getLong(); |
| free(); |
| m_bSigned = !m_bSigned; |
| (*this) = nValue; |
| } |
| break; |
| 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; |
| } |
| m_eTypeKind = nType; |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| namespace detail |
| { |
| class SAL_NO_VTABLE IValueSource |
| { |
| public: |
| virtual ::rtl::OUString getString() const = 0; |
| virtual sal_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 Time getTime() const = 0; |
| virtual DateTime getTimestamp() const = 0; |
| virtual Sequence< sal_Int8 > getBytes() const = 0; |
| virtual Reference< XInputStream > getBinaryStream() const = 0; |
| virtual Reference< XInputStream > getCharacterStream() const = 0; |
| virtual Reference< XBlob > getBlob() const = 0; |
| virtual Reference< XClob > getClob() const = 0; |
| virtual Any getObject() const = 0; |
| virtual sal_Bool wasNull() const = 0; |
| |
| virtual ~IValueSource() { } |
| }; |
| |
| class RowValue : public IValueSource |
| { |
| public: |
| RowValue( const Reference< XRow >& _xRow, const sal_Int32 _nPos ) |
| :m_xRow( _xRow ) |
| ,m_nPos( _nPos ) |
| { |
| } |
| |
| // IValueSource |
| virtual ::rtl::OUString getString() const { return m_xRow->getString( m_nPos ); }; |
| virtual sal_Bool getBoolean() const { return m_xRow->getBoolean( m_nPos ); }; |
| virtual sal_Int8 getByte() const { return m_xRow->getByte( m_nPos ); }; |
| virtual sal_Int16 getShort() const { return m_xRow->getShort( m_nPos ); } |
| virtual sal_Int32 getInt() const { return m_xRow->getInt( m_nPos ); } |
| virtual sal_Int64 getLong() const { return m_xRow->getLong( m_nPos ); } |
| virtual float getFloat() const { return m_xRow->getFloat( m_nPos ); }; |
| virtual double getDouble() const { return m_xRow->getDouble( m_nPos ); }; |
| virtual Date getDate() const { return m_xRow->getDate( m_nPos ); }; |
| virtual Time getTime() const { return m_xRow->getTime( m_nPos ); }; |
| virtual DateTime getTimestamp() const { return m_xRow->getTimestamp( m_nPos ); }; |
| virtual Sequence< sal_Int8 > getBytes() const { return m_xRow->getBytes( m_nPos ); }; |
| virtual Reference< XInputStream > getBinaryStream() const { return m_xRow->getBinaryStream( m_nPos ); }; |
| virtual Reference< XInputStream > getCharacterStream() const { return m_xRow->getCharacterStream( m_nPos ); }; |
| virtual Reference< XBlob > getBlob() const { return m_xRow->getBlob( m_nPos ); }; |
| virtual Reference< XClob > getClob() const { return m_xRow->getClob( m_nPos ); }; |
| virtual Any getObject() const { return m_xRow->getObject( m_nPos ,NULL); }; |
| virtual sal_Bool wasNull() const { return m_xRow->wasNull( ); }; |
| |
| private: |
| const Reference< XRow > m_xRow; |
| const sal_Int32 m_nPos; |
| }; |
| |
| class ColumnValue : public IValueSource |
| { |
| public: |
| ColumnValue( const Reference< XColumn >& _rxColumn ) |
| :m_xColumn( _rxColumn ) |
| { |
| } |
| |
| // IValueSource |
| virtual ::rtl::OUString getString() const { return m_xColumn->getString(); }; |
| virtual sal_Bool getBoolean() const { return m_xColumn->getBoolean(); }; |
| virtual sal_Int8 getByte() const { return m_xColumn->getByte(); }; |
| virtual sal_Int16 getShort() const { return m_xColumn->getShort(); } |
| virtual sal_Int32 getInt() const { return m_xColumn->getInt(); } |
| virtual sal_Int64 getLong() const { return m_xColumn->getLong(); } |
| virtual float getFloat() const { return m_xColumn->getFloat(); }; |
| virtual double getDouble() const { return m_xColumn->getDouble(); }; |
| virtual Date getDate() const { return m_xColumn->getDate(); }; |
| virtual Time getTime() const { return m_xColumn->getTime(); }; |
| virtual DateTime getTimestamp() const { return m_xColumn->getTimestamp(); }; |
| virtual Sequence< sal_Int8 > getBytes() const { return m_xColumn->getBytes(); }; |
| virtual Reference< XInputStream > getBinaryStream() const { return m_xColumn->getBinaryStream(); }; |
| virtual Reference< XInputStream > getCharacterStream() const { return m_xColumn->getCharacterStream(); }; |
| virtual Reference< XBlob > getBlob() const { return m_xColumn->getBlob(); }; |
| virtual Reference< XClob > getClob() const { return m_xColumn->getClob(); }; |
| virtual Any getObject() const { return m_xColumn->getObject( NULL ); }; |
| virtual sal_Bool wasNull() const { 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, sal_True, aColumnValue ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ORowSetValue::fill( sal_Int32 _nPos, sal_Int32 _nType, sal_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 ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XRow>& _xRow) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::fill (1)" ); |
| fill(_nPos,_nType,sal_True,_xRow); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ORowSetValue::impl_fill( const sal_Int32 _nType, sal_Bool _bNullable, const detail::IValueSource& _rValueSource ) |
| |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::fill (2)" ); |
| sal_Bool bReadData = sal_True; |
| 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 |
| (*this) = _rValueSource.getString(); |
| 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) = ::com::sun::star::uno::makeAny(_rValueSource.getClob()); |
| setTypeKind(DataType::CLOB); |
| break; |
| case DataType::BLOB: |
| (*this) = ::com::sun::star::uno::makeAny(_rValueSource.getBlob()); |
| setTypeKind(DataType::BLOB); |
| break; |
| case DataType::OTHER: |
| (*this) = _rValueSource.getObject(); |
| setTypeKind(DataType::OTHER); |
| break; |
| default: |
| OSL_ENSURE( false, "ORowSetValue::fill: unsupported type!" ); |
| (*this) = _rValueSource.getObject(); |
| break; |
| } |
| if ( bReadData && _bNullable && _rValueSource.wasNull() ) |
| setNull(); |
| setTypeKind(_nType); |
| } |
| // ----------------------------------------------------------------------------- |
| void ORowSetValue::fill(const Any& _rValue) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::fill (3)" ); |
| switch (_rValue.getValueType().getTypeClass()) |
| { |
| case TypeClass_VOID: |
| setNull(); |
| break; |
| case TypeClass_BOOLEAN: |
| { |
| sal_Bool bValue( sal_False ); |
| _rValue >>= bValue; |
| (*this) = bValue; |
| break; |
| } |
| case TypeClass_CHAR: |
| { |
| sal_Unicode aDummy(0); |
| _rValue >>= aDummy; |
| (*this) = ::rtl::OUString(aDummy); |
| break; |
| } |
| case TypeClass_STRING: |
| { |
| ::rtl::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_LONG: |
| { |
| sal_Int32 aDummy(0); |
| _rValue >>= aDummy; |
| (*this) = aDummy; |
| break; |
| } |
| case TypeClass_UNSIGNED_SHORT: |
| { |
| sal_uInt16 nValue(0); |
| _rValue >>= nValue; |
| (*this) = static_cast<sal_Int32>(nValue); |
| setSigned(sal_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) = static_cast<sal_Int64>(nValue); |
| setSigned(sal_False); |
| break; |
| } |
| case TypeClass_UNSIGNED_LONG: |
| { |
| sal_uInt32 nValue(0); |
| _rValue >>= nValue; |
| (*this) = static_cast<sal_Int64>(nValue); |
| setSigned(sal_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 |
| OSL_ENSURE( false, "ORowSetValue::fill: unsupported sequence type!" ); |
| break; |
| } |
| |
| case TypeClass_STRUCT: |
| { |
| ::com::sun::star::util::Date aDate; |
| ::com::sun::star::util::Time aTime; |
| ::com::sun::star::util::DateTime aDateTime; |
| if ( _rValue >>= aDate ) |
| { |
| (*this) = aDate; |
| } |
| else if ( _rValue >>= aTime ) |
| { |
| (*this) = aTime; |
| } |
| else if ( _rValue >>= aDateTime ) |
| { |
| (*this) = aDateTime; |
| } |
| else |
| OSL_ENSURE( false, "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: |
| OSL_ENSURE(0,"Unknown type"); |
| break; |
| } |
| } |
| |
| } // namespace connectivity |
