1*9b5730f6SAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3*9b5730f6SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4*9b5730f6SAndrew Rist * or more contributor license agreements. See the NOTICE file
5*9b5730f6SAndrew Rist * distributed with this work for additional information
6*9b5730f6SAndrew Rist * regarding copyright ownership. The ASF licenses this file
7*9b5730f6SAndrew Rist * to you under the Apache License, Version 2.0 (the
8*9b5730f6SAndrew Rist * "License"); you may not use this file except in compliance
9*9b5730f6SAndrew Rist * with the License. You may obtain a copy of the License at
10*9b5730f6SAndrew Rist *
11*9b5730f6SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12*9b5730f6SAndrew Rist *
13*9b5730f6SAndrew Rist * Unless required by applicable law or agreed to in writing,
14*9b5730f6SAndrew Rist * software distributed under the License is distributed on an
15*9b5730f6SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*9b5730f6SAndrew Rist * KIND, either express or implied. See the License for the
17*9b5730f6SAndrew Rist * specific language governing permissions and limitations
18*9b5730f6SAndrew Rist * under the License.
19*9b5730f6SAndrew Rist *
20*9b5730f6SAndrew Rist *************************************************************/
21*9b5730f6SAndrew Rist
22*9b5730f6SAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_connectivity.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir #include <stdio.h>
28cdf0e10cSrcweir #include "connectivity/FValue.hxx"
29cdf0e10cSrcweir #include "connectivity/CommonTools.hxx"
30cdf0e10cSrcweir #include <connectivity/dbconversion.hxx>
31cdf0e10cSrcweir #include <comphelper/extract.hxx>
32cdf0e10cSrcweir #include <com/sun/star/io/XInputStream.hpp>
33cdf0e10cSrcweir #include <rtl/ustrbuf.hxx>
34cdf0e10cSrcweir #include <rtl/logfile.hxx>
35cdf0e10cSrcweir
36cdf0e10cSrcweir using namespace ::dbtools;
37cdf0e10cSrcweir using namespace ::com::sun::star::sdbc;
38cdf0e10cSrcweir using namespace ::com::sun::star::sdb;
39cdf0e10cSrcweir using namespace ::com::sun::star::uno;
40cdf0e10cSrcweir using namespace ::com::sun::star::util;
41cdf0e10cSrcweir using namespace ::com::sun::star::io;
42cdf0e10cSrcweir
43cdf0e10cSrcweir namespace connectivity
44cdf0e10cSrcweir {
45cdf0e10cSrcweir
46cdf0e10cSrcweir namespace {
isStorageCompatible(sal_Int32 _eType1,sal_Int32 _eType2)47cdf0e10cSrcweir static sal_Bool isStorageCompatible(sal_Int32 _eType1, sal_Int32 _eType2)
48cdf0e10cSrcweir {
49cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::isStorageCompatible" );
50cdf0e10cSrcweir sal_Bool bIsCompatible = sal_True;
51cdf0e10cSrcweir
52cdf0e10cSrcweir if (_eType1 != _eType2)
53cdf0e10cSrcweir {
54cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_TRACE( aLogger, "ORowSetValue::isStorageCompatible _eType1 != _eType2" );
55cdf0e10cSrcweir switch (_eType1)
56cdf0e10cSrcweir {
57cdf0e10cSrcweir case DataType::CHAR:
58cdf0e10cSrcweir case DataType::VARCHAR:
59cdf0e10cSrcweir case DataType::DECIMAL:
60cdf0e10cSrcweir case DataType::NUMERIC:
61cdf0e10cSrcweir case DataType::LONGVARCHAR:
62cdf0e10cSrcweir bIsCompatible = (DataType::CHAR == _eType2)
63cdf0e10cSrcweir || (DataType::VARCHAR == _eType2)
64cdf0e10cSrcweir || (DataType::DECIMAL == _eType2)
65cdf0e10cSrcweir || (DataType::NUMERIC == _eType2)
66cdf0e10cSrcweir || (DataType::LONGVARCHAR == _eType2);
67cdf0e10cSrcweir break;
68cdf0e10cSrcweir
69cdf0e10cSrcweir case DataType::DOUBLE:
70cdf0e10cSrcweir case DataType::REAL:
71cdf0e10cSrcweir bIsCompatible = (DataType::DOUBLE == _eType2)
72cdf0e10cSrcweir || (DataType::REAL == _eType2);
73cdf0e10cSrcweir break;
74cdf0e10cSrcweir
75cdf0e10cSrcweir case DataType::BINARY:
76cdf0e10cSrcweir case DataType::VARBINARY:
77cdf0e10cSrcweir case DataType::LONGVARBINARY:
78cdf0e10cSrcweir bIsCompatible = (DataType::BINARY == _eType2)
79cdf0e10cSrcweir || (DataType::VARBINARY == _eType2)
80cdf0e10cSrcweir || (DataType::LONGVARBINARY == _eType2);
81cdf0e10cSrcweir break;
82cdf0e10cSrcweir
83cdf0e10cSrcweir case DataType::INTEGER:
84cdf0e10cSrcweir bIsCompatible = (DataType::SMALLINT == _eType2)
85cdf0e10cSrcweir || (DataType::TINYINT == _eType2)
86cdf0e10cSrcweir || (DataType::BIT == _eType2)
87cdf0e10cSrcweir || (DataType::BOOLEAN == _eType2);
88cdf0e10cSrcweir break;
89cdf0e10cSrcweir case DataType::SMALLINT:
90cdf0e10cSrcweir bIsCompatible = (DataType::TINYINT == _eType2)
91cdf0e10cSrcweir || (DataType::BIT == _eType2)
92cdf0e10cSrcweir || (DataType::BOOLEAN == _eType2);
93cdf0e10cSrcweir break;
94cdf0e10cSrcweir case DataType::TINYINT:
95cdf0e10cSrcweir bIsCompatible = (DataType::BIT == _eType2)
96cdf0e10cSrcweir || (DataType::BOOLEAN == _eType2);
97cdf0e10cSrcweir break;
98cdf0e10cSrcweir
99cdf0e10cSrcweir case DataType::BLOB:
100cdf0e10cSrcweir case DataType::CLOB:
101cdf0e10cSrcweir case DataType::OBJECT:
102cdf0e10cSrcweir bIsCompatible = (DataType::BLOB == _eType2)
103cdf0e10cSrcweir || (DataType::CLOB == _eType2)
104cdf0e10cSrcweir || (DataType::OBJECT == _eType2);
105cdf0e10cSrcweir break;
106cdf0e10cSrcweir
107cdf0e10cSrcweir default:
108cdf0e10cSrcweir bIsCompatible = sal_False;
109cdf0e10cSrcweir }
110cdf0e10cSrcweir }
111cdf0e10cSrcweir return bIsCompatible;
112cdf0e10cSrcweir }
113cdf0e10cSrcweir }
114cdf0e10cSrcweir
115cdf0e10cSrcweir // -----------------------------------------------------------------------------
116cdf0e10cSrcweir #ifdef DBG_UTIL
117cdf0e10cSrcweir
118cdf0e10cSrcweir #include <vector>
119cdf0e10cSrcweir #include <rtl/string.h>
120cdf0e10cSrcweir
121cdf0e10cSrcweir namespace tracing
122cdf0e10cSrcweir {
123cdf0e10cSrcweir struct AllocationType
124cdf0e10cSrcweir {
125cdf0e10cSrcweir const sal_Char* pName;
126cdf0e10cSrcweir sal_Int32 nAllocatedUnits;
127cdf0e10cSrcweir
AllocationTypeconnectivity::tracing::AllocationType128cdf0e10cSrcweir AllocationType( ) : pName( NULL ), nAllocatedUnits( 0 ) { }
129cdf0e10cSrcweir };
130cdf0e10cSrcweir
131cdf0e10cSrcweir // =============================================================================
132cdf0e10cSrcweir class AllocationTracer
133cdf0e10cSrcweir {
134cdf0e10cSrcweir public:
135cdf0e10cSrcweir typedef ::std::vector< AllocationType > AllocationState;
136cdf0e10cSrcweir static AllocationState s_aAllocated;
137cdf0e10cSrcweir static ::osl::Mutex s_aMutex;
138cdf0e10cSrcweir
139cdf0e10cSrcweir public:
140cdf0e10cSrcweir static void registerUnit( const sal_Char* _pName );
141cdf0e10cSrcweir static void revokeUnit( const sal_Char* _pName );
142cdf0e10cSrcweir
143cdf0e10cSrcweir private:
144cdf0e10cSrcweir static AllocationState::iterator getLocation( const sal_Char* _pName );
145cdf0e10cSrcweir };
146cdf0e10cSrcweir
147cdf0e10cSrcweir // =============================================================================
getLocation(const sal_Char * _pName)148cdf0e10cSrcweir AllocationTracer::AllocationState::iterator AllocationTracer::getLocation( const sal_Char* _pName )
149cdf0e10cSrcweir {
150cdf0e10cSrcweir AllocationState::iterator aLookFor = s_aAllocated.begin();
151cdf0e10cSrcweir for ( ;
152cdf0e10cSrcweir aLookFor != s_aAllocated.end();
153cdf0e10cSrcweir ++aLookFor
154cdf0e10cSrcweir )
155cdf0e10cSrcweir {
156cdf0e10cSrcweir if ( 0 == rtl_str_compare( aLookFor->pName, _pName ) )
157cdf0e10cSrcweir // found
158cdf0e10cSrcweir return aLookFor;
159cdf0e10cSrcweir }
160cdf0e10cSrcweir // not found
161cdf0e10cSrcweir s_aAllocated.push_back( AllocationType() );
162cdf0e10cSrcweir aLookFor = s_aAllocated.end(); --aLookFor;
163cdf0e10cSrcweir aLookFor->pName = _pName; // note that this assumes that _pName is a constant string ....
164cdf0e10cSrcweir return aLookFor;
165cdf0e10cSrcweir }
166cdf0e10cSrcweir
167cdf0e10cSrcweir // =============================================================================
168cdf0e10cSrcweir AllocationTracer::AllocationState AllocationTracer::s_aAllocated;
169cdf0e10cSrcweir ::osl::Mutex AllocationTracer::s_aMutex;
170cdf0e10cSrcweir
171cdf0e10cSrcweir // =============================================================================
registerUnit(const sal_Char * _pName)172cdf0e10cSrcweir void AllocationTracer::registerUnit( const sal_Char* _pName )
173cdf0e10cSrcweir {
174cdf0e10cSrcweir ::osl::MutexGuard aGuard( s_aMutex );
175cdf0e10cSrcweir
176cdf0e10cSrcweir AllocationState::iterator aPos = getLocation( _pName );
177cdf0e10cSrcweir ++aPos->nAllocatedUnits;
178cdf0e10cSrcweir }
179cdf0e10cSrcweir
180cdf0e10cSrcweir // =============================================================================
revokeUnit(const sal_Char * _pName)181cdf0e10cSrcweir void AllocationTracer::revokeUnit( const sal_Char* _pName )
182cdf0e10cSrcweir {
183cdf0e10cSrcweir ::osl::MutexGuard aGuard( s_aMutex );
184cdf0e10cSrcweir
185cdf0e10cSrcweir AllocationState::iterator aPos = getLocation( _pName );
186cdf0e10cSrcweir --aPos->nAllocatedUnits;
187cdf0e10cSrcweir }
188cdf0e10cSrcweir
189cdf0e10cSrcweir #define TRACE_ALLOC( type ) tracing::AllocationTracer::registerUnit( #type );
190cdf0e10cSrcweir #define TRACE_FREE( type ) tracing::AllocationTracer::revokeUnit( #type );
191cdf0e10cSrcweir }
192cdf0e10cSrcweir #else
193cdf0e10cSrcweir #define TRACE_ALLOC( type )
194cdf0e10cSrcweir #define TRACE_FREE( type )
195cdf0e10cSrcweir #endif
196cdf0e10cSrcweir
197cdf0e10cSrcweir // -----------------------------------------------------------------------------
setTypeKind(sal_Int32 _eType)198cdf0e10cSrcweir void ORowSetValue::setTypeKind(sal_Int32 _eType)
199cdf0e10cSrcweir {
200cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::setTypeKind" );
201cdf0e10cSrcweir if ( !m_bNull && !isStorageCompatible(_eType, m_eTypeKind) )
202cdf0e10cSrcweir {
203cdf0e10cSrcweir switch(_eType)
204cdf0e10cSrcweir {
205cdf0e10cSrcweir case DataType::VARCHAR:
206cdf0e10cSrcweir case DataType::CHAR:
207cdf0e10cSrcweir case DataType::DECIMAL:
208cdf0e10cSrcweir case DataType::NUMERIC:
209cdf0e10cSrcweir case DataType::LONGVARCHAR:
210cdf0e10cSrcweir (*this) = getString();
211cdf0e10cSrcweir break;
212cdf0e10cSrcweir case DataType::BIGINT:
213cdf0e10cSrcweir (*this) = getLong();
214cdf0e10cSrcweir break;
215cdf0e10cSrcweir
216cdf0e10cSrcweir case DataType::FLOAT:
217cdf0e10cSrcweir (*this) = getFloat();
218cdf0e10cSrcweir break;
219cdf0e10cSrcweir case DataType::DOUBLE:
220cdf0e10cSrcweir case DataType::REAL:
221cdf0e10cSrcweir (*this) = getDouble();
222cdf0e10cSrcweir break;
223cdf0e10cSrcweir case DataType::TINYINT:
224cdf0e10cSrcweir (*this) = getInt8();
225cdf0e10cSrcweir break;
226cdf0e10cSrcweir case DataType::SMALLINT:
227cdf0e10cSrcweir (*this) = getInt16();
228cdf0e10cSrcweir break;
229cdf0e10cSrcweir case DataType::INTEGER:
230cdf0e10cSrcweir (*this) = getInt32();
231cdf0e10cSrcweir break;
232cdf0e10cSrcweir case DataType::BIT:
233cdf0e10cSrcweir case DataType::BOOLEAN:
234cdf0e10cSrcweir (*this) = getBool();
235cdf0e10cSrcweir break;
236cdf0e10cSrcweir case DataType::DATE:
237cdf0e10cSrcweir (*this) = getDate();
238cdf0e10cSrcweir break;
239cdf0e10cSrcweir case DataType::TIME:
240cdf0e10cSrcweir (*this) = getTime();
241cdf0e10cSrcweir break;
242cdf0e10cSrcweir case DataType::TIMESTAMP:
243cdf0e10cSrcweir (*this) = getDateTime();
244cdf0e10cSrcweir break;
245cdf0e10cSrcweir case DataType::BINARY:
246cdf0e10cSrcweir case DataType::VARBINARY:
247cdf0e10cSrcweir case DataType::LONGVARBINARY:
248cdf0e10cSrcweir (*this) = getSequence();
249cdf0e10cSrcweir break;
250cdf0e10cSrcweir case DataType::BLOB:
251cdf0e10cSrcweir case DataType::CLOB:
252cdf0e10cSrcweir case DataType::OBJECT:
253cdf0e10cSrcweir case DataType::OTHER:
254cdf0e10cSrcweir (*this) = getAny();
255cdf0e10cSrcweir break;
256cdf0e10cSrcweir default:
257cdf0e10cSrcweir (*this) = getAny();
258cdf0e10cSrcweir OSL_ENSURE(0,"ORowSetValue:operator==(): UNSPUPPORTED TYPE!");
259cdf0e10cSrcweir }
260cdf0e10cSrcweir }
261cdf0e10cSrcweir
262cdf0e10cSrcweir m_eTypeKind = _eType;
263cdf0e10cSrcweir }
264cdf0e10cSrcweir
265cdf0e10cSrcweir // -----------------------------------------------------------------------------
free()266cdf0e10cSrcweir void ORowSetValue::free()
267cdf0e10cSrcweir {
268cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::free" );
269cdf0e10cSrcweir if(!m_bNull)
270cdf0e10cSrcweir {
271cdf0e10cSrcweir switch(m_eTypeKind)
272cdf0e10cSrcweir {
273cdf0e10cSrcweir case DataType::CHAR:
274cdf0e10cSrcweir case DataType::VARCHAR:
275cdf0e10cSrcweir case DataType::DECIMAL:
276cdf0e10cSrcweir case DataType::NUMERIC:
277cdf0e10cSrcweir case DataType::LONGVARCHAR:
278cdf0e10cSrcweir OSL_ENSURE(m_aValue.m_pString,"String pointer is null!");
279cdf0e10cSrcweir rtl_uString_release(m_aValue.m_pString);
280cdf0e10cSrcweir m_aValue.m_pString = NULL;
281cdf0e10cSrcweir break;
282cdf0e10cSrcweir case DataType::INTEGER:
283cdf0e10cSrcweir if ( !m_bSigned )
284cdf0e10cSrcweir {
285cdf0e10cSrcweir delete (sal_Int64*)m_aValue.m_pValue;
286cdf0e10cSrcweir TRACE_FREE( sal_Int64 )
287cdf0e10cSrcweir m_aValue.m_pValue = NULL;
288cdf0e10cSrcweir }
289cdf0e10cSrcweir break;
290cdf0e10cSrcweir case DataType::BIGINT:
291cdf0e10cSrcweir if ( m_bSigned )
292cdf0e10cSrcweir {
293cdf0e10cSrcweir delete (sal_Int64*)m_aValue.m_pValue;
294cdf0e10cSrcweir TRACE_FREE( sal_Int64 )
295cdf0e10cSrcweir m_aValue.m_pValue = NULL;
296cdf0e10cSrcweir }
297cdf0e10cSrcweir else
298cdf0e10cSrcweir {
299cdf0e10cSrcweir OSL_ENSURE(m_aValue.m_pString,"String pointer is null!");
300cdf0e10cSrcweir rtl_uString_release(m_aValue.m_pString);
301cdf0e10cSrcweir m_aValue.m_pString = NULL;
302cdf0e10cSrcweir }
303cdf0e10cSrcweir break;
304cdf0e10cSrcweir case DataType::FLOAT:
305cdf0e10cSrcweir delete (float*)m_aValue.m_pValue;
306cdf0e10cSrcweir TRACE_FREE( float )
307cdf0e10cSrcweir m_aValue.m_pValue = NULL;
308cdf0e10cSrcweir break;
309cdf0e10cSrcweir case DataType::DOUBLE:
310cdf0e10cSrcweir case DataType::REAL:
311cdf0e10cSrcweir delete (double*)m_aValue.m_pValue;
312cdf0e10cSrcweir TRACE_FREE( double )
313cdf0e10cSrcweir m_aValue.m_pValue = NULL;
314cdf0e10cSrcweir break;
315cdf0e10cSrcweir case DataType::DATE:
316cdf0e10cSrcweir delete (::com::sun::star::util::Date*)m_aValue.m_pValue;
317cdf0e10cSrcweir TRACE_FREE( Date )
318cdf0e10cSrcweir m_aValue.m_pValue = NULL;
319cdf0e10cSrcweir break;
320cdf0e10cSrcweir case DataType::TIME:
321cdf0e10cSrcweir delete (::com::sun::star::util::Time*)m_aValue.m_pValue;
322cdf0e10cSrcweir TRACE_FREE( Time )
323cdf0e10cSrcweir m_aValue.m_pValue = NULL;
324cdf0e10cSrcweir break;
325cdf0e10cSrcweir case DataType::TIMESTAMP:
326cdf0e10cSrcweir delete (::com::sun::star::util::DateTime*)m_aValue.m_pValue;
327cdf0e10cSrcweir TRACE_FREE( DateTime )
328cdf0e10cSrcweir m_aValue.m_pValue = NULL;
329cdf0e10cSrcweir break;
330cdf0e10cSrcweir case DataType::BINARY:
331cdf0e10cSrcweir case DataType::VARBINARY:
332cdf0e10cSrcweir case DataType::LONGVARBINARY:
333cdf0e10cSrcweir delete (Sequence<sal_Int8>*)m_aValue.m_pValue;
334cdf0e10cSrcweir TRACE_FREE( Sequence_sal_Int8 )
335cdf0e10cSrcweir m_aValue.m_pValue = NULL;
336cdf0e10cSrcweir break;
337cdf0e10cSrcweir case DataType::BLOB:
338cdf0e10cSrcweir case DataType::CLOB:
339cdf0e10cSrcweir case DataType::OBJECT:
340cdf0e10cSrcweir delete (Any*)m_aValue.m_pValue;
341cdf0e10cSrcweir TRACE_FREE( Any )
342cdf0e10cSrcweir m_aValue.m_pValue = NULL;
343cdf0e10cSrcweir break;
344cdf0e10cSrcweir case DataType::BIT:
345cdf0e10cSrcweir case DataType::TINYINT:
346cdf0e10cSrcweir case DataType::SMALLINT:
347cdf0e10cSrcweir case DataType::BOOLEAN:
348cdf0e10cSrcweir break;
349cdf0e10cSrcweir default:
350cdf0e10cSrcweir if ( m_aValue.m_pValue )
351cdf0e10cSrcweir {
352cdf0e10cSrcweir delete (Any*)m_aValue.m_pValue;
353cdf0e10cSrcweir TRACE_FREE( Any )
354cdf0e10cSrcweir m_aValue.m_pValue = NULL;
355cdf0e10cSrcweir }
356cdf0e10cSrcweir break;
357cdf0e10cSrcweir
358cdf0e10cSrcweir }
359cdf0e10cSrcweir m_bNull = sal_True;
360cdf0e10cSrcweir }
361cdf0e10cSrcweir }
362cdf0e10cSrcweir // -----------------------------------------------------------------------------
operator =(const ORowSetValue & _rRH)363cdf0e10cSrcweir ORowSetValue& ORowSetValue::operator=(const ORowSetValue& _rRH)
364cdf0e10cSrcweir {
365cdf0e10cSrcweir if(&_rRH == this)
366cdf0e10cSrcweir return *this;
367cdf0e10cSrcweir
368cdf0e10cSrcweir if ( m_eTypeKind != _rRH.m_eTypeKind || (_rRH.m_bNull && !m_bNull) || m_bSigned != _rRH.m_bSigned)
369cdf0e10cSrcweir free();
370cdf0e10cSrcweir
371cdf0e10cSrcweir m_bBound = _rRH.m_bBound;
372cdf0e10cSrcweir m_eTypeKind = _rRH.m_eTypeKind;
373cdf0e10cSrcweir m_bSigned = _rRH.m_bSigned;
374cdf0e10cSrcweir
375cdf0e10cSrcweir if(m_bNull && !_rRH.m_bNull)
376cdf0e10cSrcweir {
377cdf0e10cSrcweir switch(_rRH.m_eTypeKind)
378cdf0e10cSrcweir {
379cdf0e10cSrcweir case DataType::CHAR:
380cdf0e10cSrcweir case DataType::VARCHAR:
381cdf0e10cSrcweir case DataType::DECIMAL:
382cdf0e10cSrcweir case DataType::NUMERIC:
383cdf0e10cSrcweir case DataType::LONGVARCHAR:
384cdf0e10cSrcweir rtl_uString_acquire(_rRH.m_aValue.m_pString);
385cdf0e10cSrcweir m_aValue.m_pString = _rRH.m_aValue.m_pString;
386cdf0e10cSrcweir break;
387cdf0e10cSrcweir case DataType::BIGINT:
388cdf0e10cSrcweir if ( _rRH.m_bSigned )
389cdf0e10cSrcweir {
390cdf0e10cSrcweir m_aValue.m_pValue = new sal_Int64(*(sal_Int64*)_rRH.m_aValue.m_pValue);
391cdf0e10cSrcweir TRACE_ALLOC( sal_Int64 )
392cdf0e10cSrcweir }
393cdf0e10cSrcweir else
394cdf0e10cSrcweir {
395cdf0e10cSrcweir rtl_uString_acquire(_rRH.m_aValue.m_pString);
396cdf0e10cSrcweir m_aValue.m_pString = _rRH.m_aValue.m_pString;
397cdf0e10cSrcweir }
398cdf0e10cSrcweir break;
399cdf0e10cSrcweir case DataType::FLOAT:
400cdf0e10cSrcweir m_aValue.m_pValue = new float(*(float*)_rRH.m_aValue.m_pValue);
401cdf0e10cSrcweir TRACE_ALLOC( float )
402cdf0e10cSrcweir break;
403cdf0e10cSrcweir case DataType::DOUBLE:
404cdf0e10cSrcweir case DataType::REAL:
405cdf0e10cSrcweir m_aValue.m_pValue = new double(*(double*)_rRH.m_aValue.m_pValue);
406cdf0e10cSrcweir TRACE_ALLOC( double )
407cdf0e10cSrcweir break;
408cdf0e10cSrcweir case DataType::DATE:
409cdf0e10cSrcweir m_aValue.m_pValue = new Date(*(Date*)_rRH.m_aValue.m_pValue);
410cdf0e10cSrcweir TRACE_ALLOC( Date )
411cdf0e10cSrcweir break;
412cdf0e10cSrcweir case DataType::TIME:
413cdf0e10cSrcweir m_aValue.m_pValue = new Time(*(Time*)_rRH.m_aValue.m_pValue);
414cdf0e10cSrcweir TRACE_ALLOC( Time )
415cdf0e10cSrcweir break;
416cdf0e10cSrcweir case DataType::TIMESTAMP:
417cdf0e10cSrcweir m_aValue.m_pValue = new DateTime(*(DateTime*)_rRH.m_aValue.m_pValue);
418cdf0e10cSrcweir TRACE_ALLOC( DateTime )
419cdf0e10cSrcweir break;
420cdf0e10cSrcweir case DataType::BINARY:
421cdf0e10cSrcweir case DataType::VARBINARY:
422cdf0e10cSrcweir case DataType::LONGVARBINARY:
423cdf0e10cSrcweir m_aValue.m_pValue = new Sequence<sal_Int8>(*(Sequence<sal_Int8>*)_rRH.m_aValue.m_pValue);
424cdf0e10cSrcweir TRACE_ALLOC( Sequence_sal_Int8 )
425cdf0e10cSrcweir break;
426cdf0e10cSrcweir case DataType::BIT:
427cdf0e10cSrcweir case DataType::BOOLEAN:
428cdf0e10cSrcweir m_aValue.m_bBool = _rRH.m_aValue.m_bBool;
429cdf0e10cSrcweir break;
430cdf0e10cSrcweir case DataType::TINYINT:
431cdf0e10cSrcweir if ( _rRH.m_bSigned )
432cdf0e10cSrcweir m_aValue.m_nInt8 = _rRH.m_aValue.m_nInt8;
433cdf0e10cSrcweir else
434cdf0e10cSrcweir m_aValue.m_nInt16 = _rRH.m_aValue.m_nInt16;
435cdf0e10cSrcweir break;
436cdf0e10cSrcweir case DataType::SMALLINT:
437cdf0e10cSrcweir if ( _rRH.m_bSigned )
438cdf0e10cSrcweir m_aValue.m_nInt16 = _rRH.m_aValue.m_nInt16;
439cdf0e10cSrcweir else
440cdf0e10cSrcweir m_aValue.m_nInt32 = _rRH.m_aValue.m_nInt32;
441cdf0e10cSrcweir break;
442cdf0e10cSrcweir case DataType::INTEGER:
443cdf0e10cSrcweir if ( _rRH.m_bSigned )
444cdf0e10cSrcweir m_aValue.m_nInt32 = _rRH.m_aValue.m_nInt32;
445cdf0e10cSrcweir else
446cdf0e10cSrcweir {
447cdf0e10cSrcweir m_aValue.m_pValue = new sal_Int64(*(sal_Int64*)_rRH.m_aValue.m_pValue);
448cdf0e10cSrcweir TRACE_ALLOC( sal_Int64 )
449cdf0e10cSrcweir }
450cdf0e10cSrcweir break;
451cdf0e10cSrcweir default:
452cdf0e10cSrcweir m_aValue.m_pValue = new Any(*(Any*)_rRH.m_aValue.m_pValue);
453cdf0e10cSrcweir TRACE_ALLOC( Any )
454cdf0e10cSrcweir }
455cdf0e10cSrcweir }
456cdf0e10cSrcweir else if(!_rRH.m_bNull)
457cdf0e10cSrcweir {
458cdf0e10cSrcweir switch(_rRH.m_eTypeKind)
459cdf0e10cSrcweir {
460cdf0e10cSrcweir case DataType::CHAR:
461cdf0e10cSrcweir case DataType::VARCHAR:
462cdf0e10cSrcweir case DataType::DECIMAL:
463cdf0e10cSrcweir case DataType::NUMERIC:
464cdf0e10cSrcweir case DataType::LONGVARCHAR:
465cdf0e10cSrcweir (*this) = ::rtl::OUString(_rRH.m_aValue.m_pString);
466cdf0e10cSrcweir break;
467cdf0e10cSrcweir case DataType::BIGINT:
468cdf0e10cSrcweir if ( _rRH.m_bSigned )
469cdf0e10cSrcweir (*this) = *(sal_Int64*)_rRH.m_aValue.m_pValue;
470cdf0e10cSrcweir else
471cdf0e10cSrcweir (*this) = ::rtl::OUString(_rRH.m_aValue.m_pString);
472cdf0e10cSrcweir break;
473cdf0e10cSrcweir case DataType::FLOAT:
474cdf0e10cSrcweir (*this) = *(float*)_rRH.m_aValue.m_pValue;
475cdf0e10cSrcweir break;
476cdf0e10cSrcweir case DataType::DOUBLE:
477cdf0e10cSrcweir case DataType::REAL:
478cdf0e10cSrcweir (*this) = *(double*)_rRH.m_aValue.m_pValue;
479cdf0e10cSrcweir break;
480cdf0e10cSrcweir case DataType::DATE:
481cdf0e10cSrcweir (*this) = *(Date*)_rRH.m_aValue.m_pValue;
482cdf0e10cSrcweir break;
483cdf0e10cSrcweir case DataType::TIME:
484cdf0e10cSrcweir (*this) = *(Time*)_rRH.m_aValue.m_pValue;
485cdf0e10cSrcweir break;
486cdf0e10cSrcweir case DataType::TIMESTAMP:
487cdf0e10cSrcweir (*this) = *(DateTime*)_rRH.m_aValue.m_pValue;
488cdf0e10cSrcweir break;
489cdf0e10cSrcweir case DataType::BINARY:
490cdf0e10cSrcweir case DataType::VARBINARY:
491cdf0e10cSrcweir case DataType::LONGVARBINARY:
492cdf0e10cSrcweir (*this) = *(Sequence<sal_Int8>*)_rRH.m_aValue.m_pValue;
493cdf0e10cSrcweir break;
494cdf0e10cSrcweir case DataType::BIT:
495cdf0e10cSrcweir case DataType::BOOLEAN:
496cdf0e10cSrcweir m_aValue.m_bBool = _rRH.m_aValue.m_bBool;
497cdf0e10cSrcweir break;
498cdf0e10cSrcweir case DataType::TINYINT:
499cdf0e10cSrcweir if ( _rRH.m_bSigned )
500cdf0e10cSrcweir m_aValue.m_nInt8 = _rRH.m_aValue.m_nInt8;
501cdf0e10cSrcweir else
502cdf0e10cSrcweir m_aValue.m_nInt16 = _rRH.m_aValue.m_nInt16;
503cdf0e10cSrcweir break;
504cdf0e10cSrcweir case DataType::SMALLINT:
505cdf0e10cSrcweir if ( _rRH.m_bSigned )
506cdf0e10cSrcweir m_aValue.m_nInt16 = _rRH.m_aValue.m_nInt16;
507cdf0e10cSrcweir else
508cdf0e10cSrcweir m_aValue.m_nInt32 = _rRH.m_aValue.m_nInt32;
509cdf0e10cSrcweir break;
510cdf0e10cSrcweir case DataType::INTEGER:
511cdf0e10cSrcweir if ( _rRH.m_bSigned )
512cdf0e10cSrcweir m_aValue.m_nInt32 = _rRH.m_aValue.m_nInt32;
513cdf0e10cSrcweir else
514cdf0e10cSrcweir *static_cast<sal_Int64*>(m_aValue.m_pValue) = *(sal_Int64*)_rRH.m_aValue.m_pValue;
515cdf0e10cSrcweir break;
516cdf0e10cSrcweir default:
517cdf0e10cSrcweir (*(Any*)m_aValue.m_pValue) = (*(Any*)_rRH.m_aValue.m_pValue);
518cdf0e10cSrcweir }
519cdf0e10cSrcweir }
520cdf0e10cSrcweir
521cdf0e10cSrcweir m_bNull = _rRH.m_bNull;
522cdf0e10cSrcweir // OJ: BUGID: 96277
523cdf0e10cSrcweir m_eTypeKind = _rRH.m_eTypeKind;
524cdf0e10cSrcweir
525cdf0e10cSrcweir return *this;
526cdf0e10cSrcweir }
527cdf0e10cSrcweir // -------------------------------------------------------------------------
528cdf0e10cSrcweir
operator =(const Date & _rRH)529cdf0e10cSrcweir ORowSetValue& ORowSetValue::operator=(const Date& _rRH)
530cdf0e10cSrcweir {
531cdf0e10cSrcweir if(m_eTypeKind != DataType::DATE)
532cdf0e10cSrcweir free();
533cdf0e10cSrcweir
534cdf0e10cSrcweir if(m_bNull)
535cdf0e10cSrcweir {
536cdf0e10cSrcweir m_aValue.m_pValue = new Date(_rRH);
537cdf0e10cSrcweir TRACE_ALLOC( Date )
538cdf0e10cSrcweir m_eTypeKind = DataType::DATE;
539cdf0e10cSrcweir m_bNull = sal_False;
540cdf0e10cSrcweir }
541cdf0e10cSrcweir else
542cdf0e10cSrcweir *(Date*)m_aValue.m_pValue = _rRH;
543cdf0e10cSrcweir
544cdf0e10cSrcweir return *this;
545cdf0e10cSrcweir }
546cdf0e10cSrcweir // -------------------------------------------------------------------------
operator =(const Time & _rRH)547cdf0e10cSrcweir ORowSetValue& ORowSetValue::operator=(const Time& _rRH)
548cdf0e10cSrcweir {
549cdf0e10cSrcweir if(m_eTypeKind != DataType::TIME)
550cdf0e10cSrcweir free();
551cdf0e10cSrcweir
552cdf0e10cSrcweir if(m_bNull)
553cdf0e10cSrcweir {
554cdf0e10cSrcweir m_aValue.m_pValue = new Time(_rRH);
555cdf0e10cSrcweir TRACE_ALLOC( Time )
556cdf0e10cSrcweir m_eTypeKind = DataType::TIME;
557cdf0e10cSrcweir m_bNull = sal_False;
558cdf0e10cSrcweir }
559cdf0e10cSrcweir else
560cdf0e10cSrcweir *(Time*)m_aValue.m_pValue = _rRH;
561cdf0e10cSrcweir
562cdf0e10cSrcweir return *this;
563cdf0e10cSrcweir }
564cdf0e10cSrcweir // -------------------------------------------------------------------------
operator =(const DateTime & _rRH)565cdf0e10cSrcweir ORowSetValue& ORowSetValue::operator=(const DateTime& _rRH)
566cdf0e10cSrcweir {
567cdf0e10cSrcweir if(m_eTypeKind != DataType::TIMESTAMP)
568cdf0e10cSrcweir free();
569cdf0e10cSrcweir if(m_bNull)
570cdf0e10cSrcweir {
571cdf0e10cSrcweir m_aValue.m_pValue = new DateTime(_rRH);
572cdf0e10cSrcweir TRACE_ALLOC( DateTime )
573cdf0e10cSrcweir m_eTypeKind = DataType::TIMESTAMP;
574cdf0e10cSrcweir m_bNull = sal_False;
575cdf0e10cSrcweir }
576cdf0e10cSrcweir else
577cdf0e10cSrcweir *(DateTime*)m_aValue.m_pValue = _rRH;
578cdf0e10cSrcweir
579cdf0e10cSrcweir return *this;
580cdf0e10cSrcweir }
581cdf0e10cSrcweir // -------------------------------------------------------------------------
582cdf0e10cSrcweir
operator =(const::rtl::OUString & _rRH)583cdf0e10cSrcweir ORowSetValue& ORowSetValue::operator=(const ::rtl::OUString& _rRH)
584cdf0e10cSrcweir {
585cdf0e10cSrcweir if(m_eTypeKind != DataType::VARCHAR || m_aValue.m_pString != _rRH.pData)
586cdf0e10cSrcweir {
587cdf0e10cSrcweir free();
588cdf0e10cSrcweir m_bNull = sal_False;
589cdf0e10cSrcweir
590cdf0e10cSrcweir m_aValue.m_pString = _rRH.pData;
591cdf0e10cSrcweir rtl_uString_acquire(m_aValue.m_pString);
592cdf0e10cSrcweir m_eTypeKind = DataType::VARCHAR;
593cdf0e10cSrcweir }
594cdf0e10cSrcweir
595cdf0e10cSrcweir return *this;
596cdf0e10cSrcweir }
597cdf0e10cSrcweir // -------------------------------------------------------------------------
598cdf0e10cSrcweir
operator =(const double & _rRH)599cdf0e10cSrcweir ORowSetValue& ORowSetValue::operator=(const double& _rRH)
600cdf0e10cSrcweir {
601cdf0e10cSrcweir if( !isStorageCompatible(m_eTypeKind,DataType::DOUBLE) )
602cdf0e10cSrcweir free();
603cdf0e10cSrcweir
604cdf0e10cSrcweir if(m_bNull)
605cdf0e10cSrcweir {
606cdf0e10cSrcweir m_aValue.m_pValue = new double(_rRH);
607cdf0e10cSrcweir TRACE_ALLOC( double )
608cdf0e10cSrcweir m_eTypeKind = DataType::DOUBLE;
609cdf0e10cSrcweir m_bNull = sal_False;
610cdf0e10cSrcweir }
611cdf0e10cSrcweir else
612cdf0e10cSrcweir *(double*)m_aValue.m_pValue = _rRH;
613cdf0e10cSrcweir
614cdf0e10cSrcweir return *this;
615cdf0e10cSrcweir }
616cdf0e10cSrcweir // -----------------------------------------------------------------------------
operator =(const float & _rRH)617cdf0e10cSrcweir ORowSetValue& ORowSetValue::operator=(const float& _rRH)
618cdf0e10cSrcweir {
619cdf0e10cSrcweir if(m_eTypeKind != DataType::FLOAT)
620cdf0e10cSrcweir free();
621cdf0e10cSrcweir
622cdf0e10cSrcweir if(m_bNull)
623cdf0e10cSrcweir {
624cdf0e10cSrcweir m_aValue.m_pValue = new float(_rRH);
625cdf0e10cSrcweir TRACE_ALLOC( float )
626cdf0e10cSrcweir m_eTypeKind = DataType::FLOAT;
627cdf0e10cSrcweir m_bNull = sal_False;
628cdf0e10cSrcweir }
629cdf0e10cSrcweir else
630cdf0e10cSrcweir *(float*)m_aValue.m_pValue = _rRH;
631cdf0e10cSrcweir
632cdf0e10cSrcweir return *this;
633cdf0e10cSrcweir }
634cdf0e10cSrcweir // -------------------------------------------------------------------------
635cdf0e10cSrcweir
operator =(const sal_Int8 & _rRH)636cdf0e10cSrcweir ORowSetValue& ORowSetValue::operator=(const sal_Int8& _rRH)
637cdf0e10cSrcweir {
638cdf0e10cSrcweir if(m_eTypeKind != DataType::TINYINT )
639cdf0e10cSrcweir free();
640cdf0e10cSrcweir
641cdf0e10cSrcweir m_aValue.m_nInt8 = _rRH;
642cdf0e10cSrcweir m_eTypeKind = DataType::TINYINT;
643cdf0e10cSrcweir m_bNull = sal_False;
644cdf0e10cSrcweir return *this;
645cdf0e10cSrcweir }
646cdf0e10cSrcweir // -------------------------------------------------------------------------
647cdf0e10cSrcweir
operator =(const sal_Int16 & _rRH)648cdf0e10cSrcweir ORowSetValue& ORowSetValue::operator=(const sal_Int16& _rRH)
649cdf0e10cSrcweir {
650cdf0e10cSrcweir if(m_eTypeKind != DataType::SMALLINT )
651cdf0e10cSrcweir free();
652cdf0e10cSrcweir
653cdf0e10cSrcweir m_aValue.m_nInt16 = _rRH;
654cdf0e10cSrcweir m_eTypeKind = DataType::SMALLINT;
655cdf0e10cSrcweir m_bNull = sal_False;
656cdf0e10cSrcweir
657cdf0e10cSrcweir return *this;
658cdf0e10cSrcweir }
659cdf0e10cSrcweir // -------------------------------------------------------------------------
660cdf0e10cSrcweir
operator =(const sal_Int32 & _rRH)661cdf0e10cSrcweir ORowSetValue& ORowSetValue::operator=(const sal_Int32& _rRH)
662cdf0e10cSrcweir {
663cdf0e10cSrcweir if(m_eTypeKind != DataType::INTEGER )
664cdf0e10cSrcweir free();
665cdf0e10cSrcweir
666cdf0e10cSrcweir if ( m_bSigned )
667cdf0e10cSrcweir m_aValue.m_nInt32 = _rRH;
668cdf0e10cSrcweir else
669cdf0e10cSrcweir {
670cdf0e10cSrcweir if ( m_bNull )
671cdf0e10cSrcweir {
672cdf0e10cSrcweir m_aValue.m_pValue = new sal_Int64(_rRH);
673cdf0e10cSrcweir TRACE_ALLOC( sal_Int64 )
674cdf0e10cSrcweir }
675cdf0e10cSrcweir else
676cdf0e10cSrcweir *static_cast<sal_Int64*>(m_aValue.m_pValue) = static_cast<sal_Int64>(_rRH);
677cdf0e10cSrcweir }
678cdf0e10cSrcweir
679cdf0e10cSrcweir m_eTypeKind = DataType::INTEGER;
680cdf0e10cSrcweir m_bNull = sal_False;
681cdf0e10cSrcweir
682cdf0e10cSrcweir return *this;
683cdf0e10cSrcweir }
684cdf0e10cSrcweir // -------------------------------------------------------------------------
685cdf0e10cSrcweir
operator =(const sal_Bool _rRH)686cdf0e10cSrcweir ORowSetValue& ORowSetValue::operator=(const sal_Bool _rRH)
687cdf0e10cSrcweir {
688cdf0e10cSrcweir if(m_eTypeKind != DataType::BIT && DataType::BOOLEAN != m_eTypeKind )
689cdf0e10cSrcweir free();
690cdf0e10cSrcweir
691cdf0e10cSrcweir m_aValue.m_bBool = _rRH;
692cdf0e10cSrcweir m_eTypeKind = DataType::BIT;
693cdf0e10cSrcweir m_bNull = sal_False;
694cdf0e10cSrcweir
695cdf0e10cSrcweir return *this;
696cdf0e10cSrcweir }
697cdf0e10cSrcweir // -------------------------------------------------------------------------
operator =(const sal_Int64 & _rRH)698cdf0e10cSrcweir ORowSetValue& ORowSetValue::operator=(const sal_Int64& _rRH)
699cdf0e10cSrcweir {
700cdf0e10cSrcweir if ( DataType::BIGINT != m_eTypeKind || !m_bSigned )
701cdf0e10cSrcweir free();
702cdf0e10cSrcweir
703cdf0e10cSrcweir if ( m_bSigned )
704cdf0e10cSrcweir {
705cdf0e10cSrcweir if(m_bNull)
706cdf0e10cSrcweir {
707cdf0e10cSrcweir m_aValue.m_pValue = new sal_Int64(_rRH);
708cdf0e10cSrcweir TRACE_ALLOC( sal_Int64 )
709cdf0e10cSrcweir }
710cdf0e10cSrcweir else
711cdf0e10cSrcweir *static_cast<sal_Int64*>(m_aValue.m_pValue) = _rRH;
712cdf0e10cSrcweir }
713cdf0e10cSrcweir else
714cdf0e10cSrcweir {
715cdf0e10cSrcweir ::rtl::OUString aVal = ::rtl::OUString::valueOf(_rRH);
716cdf0e10cSrcweir m_aValue.m_pString = aVal.pData;
717cdf0e10cSrcweir rtl_uString_acquire(m_aValue.m_pString);
718cdf0e10cSrcweir }
719cdf0e10cSrcweir
720cdf0e10cSrcweir m_eTypeKind = DataType::BIGINT;
721cdf0e10cSrcweir m_bNull = sal_False;
722cdf0e10cSrcweir
723cdf0e10cSrcweir return *this;
724cdf0e10cSrcweir }
725cdf0e10cSrcweir // -------------------------------------------------------------------------
operator =(const Sequence<sal_Int8> & _rRH)726cdf0e10cSrcweir ORowSetValue& ORowSetValue::operator=(const Sequence<sal_Int8>& _rRH)
727cdf0e10cSrcweir {
728cdf0e10cSrcweir if (!isStorageCompatible(DataType::LONGVARBINARY,m_eTypeKind))
729cdf0e10cSrcweir free();
730cdf0e10cSrcweir
731cdf0e10cSrcweir if (m_bNull)
732cdf0e10cSrcweir {
733cdf0e10cSrcweir m_aValue.m_pValue = new Sequence<sal_Int8>(_rRH);
734cdf0e10cSrcweir TRACE_ALLOC( Sequence_sal_Int8 )
735cdf0e10cSrcweir }
736cdf0e10cSrcweir else
737cdf0e10cSrcweir *static_cast< Sequence< sal_Int8 >* >(m_aValue.m_pValue) = _rRH;
738cdf0e10cSrcweir
739cdf0e10cSrcweir m_eTypeKind = DataType::LONGVARBINARY;
740cdf0e10cSrcweir m_bNull = sal_False;
741cdf0e10cSrcweir
742cdf0e10cSrcweir return *this;
743cdf0e10cSrcweir }
744cdf0e10cSrcweir // -------------------------------------------------------------------------
operator =(const Any & _rAny)745cdf0e10cSrcweir ORowSetValue& ORowSetValue::operator=(const Any& _rAny)
746cdf0e10cSrcweir {
747cdf0e10cSrcweir if (!isStorageCompatible(DataType::OBJECT,m_eTypeKind))
748cdf0e10cSrcweir free();
749cdf0e10cSrcweir
750cdf0e10cSrcweir if ( m_bNull )
751cdf0e10cSrcweir {
752cdf0e10cSrcweir m_aValue.m_pValue = new Any(_rAny);
753cdf0e10cSrcweir TRACE_ALLOC( Any )
754cdf0e10cSrcweir }
755cdf0e10cSrcweir else
756cdf0e10cSrcweir *static_cast<Any*>(m_aValue.m_pValue) = _rAny;
757cdf0e10cSrcweir
758cdf0e10cSrcweir m_eTypeKind = DataType::OBJECT;
759cdf0e10cSrcweir m_bNull = sal_False;
760cdf0e10cSrcweir
761cdf0e10cSrcweir return *this;
762cdf0e10cSrcweir }
763cdf0e10cSrcweir // -------------------------------------------------------------------------
764cdf0e10cSrcweir
operator ==(const Date & _rLH,const Date & _rRH)765cdf0e10cSrcweir sal_Bool operator==(const Date& _rLH,const Date& _rRH)
766cdf0e10cSrcweir {
767cdf0e10cSrcweir return _rLH.Day == _rRH.Day && _rLH.Month == _rRH.Month && _rLH.Year == _rRH.Year;
768cdf0e10cSrcweir }
769cdf0e10cSrcweir // -------------------------------------------------------------------------
770cdf0e10cSrcweir
operator ==(const Time & _rLH,const Time & _rRH)771cdf0e10cSrcweir sal_Bool operator==(const Time& _rLH,const Time& _rRH)
772cdf0e10cSrcweir {
773cdf0e10cSrcweir return _rLH.Minutes == _rRH.Minutes && _rLH.Hours == _rRH.Hours && _rLH.Seconds == _rRH.Seconds && _rLH.HundredthSeconds == _rRH.HundredthSeconds;
774cdf0e10cSrcweir }
775cdf0e10cSrcweir // -------------------------------------------------------------------------
776cdf0e10cSrcweir
operator ==(const DateTime & _rLH,const DateTime & _rRH)777cdf0e10cSrcweir sal_Bool operator==(const DateTime& _rLH,const DateTime& _rRH)
778cdf0e10cSrcweir {
779cdf0e10cSrcweir return _rLH.Day == _rRH.Day && _rLH.Month == _rRH.Month && _rLH.Year == _rRH.Year &&
780cdf0e10cSrcweir _rLH.Minutes == _rRH.Minutes && _rLH.Hours == _rRH.Hours && _rLH.Seconds == _rRH.Seconds && _rLH.HundredthSeconds == _rRH.HundredthSeconds;
781cdf0e10cSrcweir }
782cdf0e10cSrcweir // -------------------------------------------------------------------------
783cdf0e10cSrcweir
operator ==(const ORowSetValue & _rRH) const784cdf0e10cSrcweir bool ORowSetValue::operator==(const ORowSetValue& _rRH) const
785cdf0e10cSrcweir {
786619a211cSMichael Stahl if ( m_bNull != _rRH.isNull() )
787619a211cSMichael Stahl return false;
788619a211cSMichael Stahl
789619a211cSMichael Stahl if(m_bNull && _rRH.isNull())
790619a211cSMichael Stahl return true;
791619a211cSMichael Stahl
792cdf0e10cSrcweir if ( m_eTypeKind != _rRH.m_eTypeKind )
793cdf0e10cSrcweir {
794cdf0e10cSrcweir switch(m_eTypeKind)
795cdf0e10cSrcweir {
796cdf0e10cSrcweir case DataType::FLOAT:
797cdf0e10cSrcweir case DataType::DOUBLE:
798cdf0e10cSrcweir case DataType::REAL:
799cdf0e10cSrcweir return getDouble() == _rRH.getDouble();
800cdf0e10cSrcweir default:
801cdf0e10cSrcweir switch(_rRH.m_eTypeKind)
802cdf0e10cSrcweir {
803cdf0e10cSrcweir case DataType::FLOAT:
804cdf0e10cSrcweir case DataType::DOUBLE:
805cdf0e10cSrcweir case DataType::REAL:
806cdf0e10cSrcweir return getDouble() == _rRH.getDouble();
807cdf0e10cSrcweir default:
808cdf0e10cSrcweir break;
809cdf0e10cSrcweir }
810cdf0e10cSrcweir break;
811cdf0e10cSrcweir }
812cdf0e10cSrcweir return false;
813cdf0e10cSrcweir }
814cdf0e10cSrcweir
815cdf0e10cSrcweir bool bRet = false;
816cdf0e10cSrcweir OSL_ENSURE(!m_bNull,"SHould not be null!");
817cdf0e10cSrcweir switch(m_eTypeKind)
818cdf0e10cSrcweir {
819cdf0e10cSrcweir case DataType::VARCHAR:
820cdf0e10cSrcweir case DataType::CHAR:
821cdf0e10cSrcweir case DataType::LONGVARCHAR:
822cdf0e10cSrcweir {
823cdf0e10cSrcweir ::rtl::OUString aVal1(m_aValue.m_pString);
824cdf0e10cSrcweir ::rtl::OUString aVal2(_rRH.m_aValue.m_pString);
825cdf0e10cSrcweir return aVal1 == aVal2;
826cdf0e10cSrcweir }
827cdf0e10cSrcweir default:
828cdf0e10cSrcweir if ( m_bSigned != _rRH.m_bSigned )
829cdf0e10cSrcweir return false;
830cdf0e10cSrcweir break;
831cdf0e10cSrcweir }
832cdf0e10cSrcweir
833cdf0e10cSrcweir switch(m_eTypeKind)
834cdf0e10cSrcweir {
835cdf0e10cSrcweir case DataType::DECIMAL:
836cdf0e10cSrcweir case DataType::NUMERIC:
837cdf0e10cSrcweir {
838cdf0e10cSrcweir ::rtl::OUString aVal1(m_aValue.m_pString);
839cdf0e10cSrcweir ::rtl::OUString aVal2(_rRH.m_aValue.m_pString);
840cdf0e10cSrcweir bRet = aVal1 == aVal2;
841cdf0e10cSrcweir }
842cdf0e10cSrcweir break;
843cdf0e10cSrcweir case DataType::FLOAT:
844cdf0e10cSrcweir bRet = *(float*)m_aValue.m_pValue == *(float*)_rRH.m_aValue.m_pValue;
845cdf0e10cSrcweir break;
846cdf0e10cSrcweir case DataType::DOUBLE:
847cdf0e10cSrcweir case DataType::REAL:
848cdf0e10cSrcweir bRet = *(double*)m_aValue.m_pValue == *(double*)_rRH.m_aValue.m_pValue;
849cdf0e10cSrcweir break;
850cdf0e10cSrcweir case DataType::TINYINT:
851cdf0e10cSrcweir bRet = m_bSigned ? ( m_aValue.m_nInt8 == _rRH.m_aValue.m_nInt8 ) : (m_aValue.m_nInt16 == _rRH.m_aValue.m_nInt16);
852cdf0e10cSrcweir break;
853cdf0e10cSrcweir case DataType::SMALLINT:
854cdf0e10cSrcweir bRet = m_bSigned ? ( m_aValue.m_nInt16 == _rRH.m_aValue.m_nInt16 ) : (m_aValue.m_nInt32 == _rRH.m_aValue.m_nInt32);
855cdf0e10cSrcweir break;
856cdf0e10cSrcweir case DataType::INTEGER:
857cdf0e10cSrcweir 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);
858cdf0e10cSrcweir break;
859cdf0e10cSrcweir case DataType::BIGINT:
860cdf0e10cSrcweir if ( m_bSigned )
861cdf0e10cSrcweir bRet = *(sal_Int64*)m_aValue.m_pValue == *(sal_Int64*)_rRH.m_aValue.m_pValue;
862cdf0e10cSrcweir else
863cdf0e10cSrcweir {
864cdf0e10cSrcweir ::rtl::OUString aVal1(m_aValue.m_pString);
865cdf0e10cSrcweir ::rtl::OUString aVal2(_rRH.m_aValue.m_pString);
866cdf0e10cSrcweir bRet = aVal1 == aVal2;
867cdf0e10cSrcweir }
868cdf0e10cSrcweir break;
869cdf0e10cSrcweir case DataType::BIT:
870cdf0e10cSrcweir case DataType::BOOLEAN:
871cdf0e10cSrcweir bRet = m_aValue.m_bBool == _rRH.m_aValue.m_bBool;
872cdf0e10cSrcweir break;
873cdf0e10cSrcweir case DataType::DATE:
874cdf0e10cSrcweir bRet = *(Date*)m_aValue.m_pValue == *(Date*)_rRH.m_aValue.m_pValue;
875cdf0e10cSrcweir break;
876cdf0e10cSrcweir case DataType::TIME:
877cdf0e10cSrcweir bRet = *(Time*)m_aValue.m_pValue == *(Time*)_rRH.m_aValue.m_pValue;
878cdf0e10cSrcweir break;
879cdf0e10cSrcweir case DataType::TIMESTAMP:
880cdf0e10cSrcweir bRet = *(DateTime*)m_aValue.m_pValue == *(DateTime*)_rRH.m_aValue.m_pValue;
881cdf0e10cSrcweir break;
882cdf0e10cSrcweir case DataType::BINARY:
883cdf0e10cSrcweir case DataType::VARBINARY:
884cdf0e10cSrcweir case DataType::LONGVARBINARY:
885cdf0e10cSrcweir bRet = false;
886cdf0e10cSrcweir break;
887cdf0e10cSrcweir case DataType::BLOB:
888cdf0e10cSrcweir case DataType::CLOB:
889cdf0e10cSrcweir case DataType::OBJECT:
890cdf0e10cSrcweir case DataType::OTHER:
891cdf0e10cSrcweir bRet = false;
892cdf0e10cSrcweir break;
893cdf0e10cSrcweir default:
894cdf0e10cSrcweir bRet = false;
895cdf0e10cSrcweir OSL_ENSURE(0,"ORowSetValue::operator==(): UNSPUPPORTED TYPE!");
896cdf0e10cSrcweir break;
897cdf0e10cSrcweir }
898cdf0e10cSrcweir return bRet;
899cdf0e10cSrcweir }
900cdf0e10cSrcweir // -------------------------------------------------------------------------
makeAny() const901cdf0e10cSrcweir Any ORowSetValue::makeAny() const
902cdf0e10cSrcweir {
903cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::makeAny" );
904cdf0e10cSrcweir Any rValue;
905cdf0e10cSrcweir if(isBound() && !isNull())
906cdf0e10cSrcweir {
907cdf0e10cSrcweir switch(getTypeKind())
908cdf0e10cSrcweir {
909cdf0e10cSrcweir case DataType::CHAR:
910cdf0e10cSrcweir case DataType::VARCHAR:
911cdf0e10cSrcweir case DataType::DECIMAL:
912cdf0e10cSrcweir case DataType::NUMERIC:
913cdf0e10cSrcweir case DataType::LONGVARCHAR:
914cdf0e10cSrcweir OSL_ENSURE(m_aValue.m_pString,"Value is null!");
915cdf0e10cSrcweir rValue <<= (::rtl::OUString)m_aValue.m_pString;
916cdf0e10cSrcweir break;
917cdf0e10cSrcweir case DataType::BIGINT:
918cdf0e10cSrcweir if ( m_bSigned )
919cdf0e10cSrcweir {
920cdf0e10cSrcweir OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
921cdf0e10cSrcweir rValue <<= *(sal_Int64*)m_aValue.m_pValue;
922cdf0e10cSrcweir }
923cdf0e10cSrcweir else
924cdf0e10cSrcweir {
925cdf0e10cSrcweir OSL_ENSURE(m_aValue.m_pString,"Value is null!");
926cdf0e10cSrcweir rValue <<= (::rtl::OUString)m_aValue.m_pString;
927cdf0e10cSrcweir }
928cdf0e10cSrcweir break;
929cdf0e10cSrcweir case DataType::FLOAT:
930cdf0e10cSrcweir OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
931cdf0e10cSrcweir rValue <<= *(float*)m_aValue.m_pValue;
932cdf0e10cSrcweir break;
933cdf0e10cSrcweir case DataType::DOUBLE:
934cdf0e10cSrcweir case DataType::REAL:
935cdf0e10cSrcweir OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
936cdf0e10cSrcweir rValue <<= *(double*)m_aValue.m_pValue;
937cdf0e10cSrcweir break;
938cdf0e10cSrcweir case DataType::DATE:
939cdf0e10cSrcweir OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
940cdf0e10cSrcweir rValue <<= *(Date*)m_aValue.m_pValue;
941cdf0e10cSrcweir break;
942cdf0e10cSrcweir case DataType::TIME:
943cdf0e10cSrcweir OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
944cdf0e10cSrcweir rValue <<= *(Time*)m_aValue.m_pValue;
945cdf0e10cSrcweir break;
946cdf0e10cSrcweir case DataType::TIMESTAMP:
947cdf0e10cSrcweir OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
948cdf0e10cSrcweir rValue <<= *(DateTime*)m_aValue.m_pValue;
949cdf0e10cSrcweir break;
950cdf0e10cSrcweir case DataType::BINARY:
951cdf0e10cSrcweir case DataType::VARBINARY:
952cdf0e10cSrcweir case DataType::LONGVARBINARY:
953cdf0e10cSrcweir OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
954cdf0e10cSrcweir rValue <<= *(Sequence<sal_Int8>*)m_aValue.m_pValue;
955cdf0e10cSrcweir break;
956cdf0e10cSrcweir case DataType::BLOB:
957cdf0e10cSrcweir case DataType::CLOB:
958cdf0e10cSrcweir case DataType::OBJECT:
959cdf0e10cSrcweir case DataType::OTHER:
960cdf0e10cSrcweir rValue = getAny();
961cdf0e10cSrcweir break;
962cdf0e10cSrcweir case DataType::BIT:
963cdf0e10cSrcweir case DataType::BOOLEAN:
964cdf0e10cSrcweir rValue.setValue( &m_aValue.m_bBool, ::getCppuBooleanType() );
965cdf0e10cSrcweir break;
966cdf0e10cSrcweir case DataType::TINYINT:
967cdf0e10cSrcweir if ( m_bSigned )
968cdf0e10cSrcweir rValue <<= m_aValue.m_nInt8;
969cdf0e10cSrcweir else
970cdf0e10cSrcweir rValue <<= m_aValue.m_nInt16;
971cdf0e10cSrcweir break;
972cdf0e10cSrcweir case DataType::SMALLINT:
973cdf0e10cSrcweir if ( m_bSigned )
974cdf0e10cSrcweir rValue <<= m_aValue.m_nInt16;
975cdf0e10cSrcweir else
976cdf0e10cSrcweir rValue <<= m_aValue.m_nInt32;
977cdf0e10cSrcweir break;
978cdf0e10cSrcweir case DataType::INTEGER:
979cdf0e10cSrcweir if ( m_bSigned )
980cdf0e10cSrcweir rValue <<= m_aValue.m_nInt32;
981cdf0e10cSrcweir else
982cdf0e10cSrcweir {
983cdf0e10cSrcweir OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
984cdf0e10cSrcweir rValue <<= *(sal_Int64*)m_aValue.m_pValue;
985cdf0e10cSrcweir }
986cdf0e10cSrcweir break;
987cdf0e10cSrcweir default:
988cdf0e10cSrcweir OSL_ENSURE(0,"ORowSetValue::makeAny(): UNSPUPPORTED TYPE!");
989cdf0e10cSrcweir rValue = getAny();
990cdf0e10cSrcweir break;
991cdf0e10cSrcweir }
992cdf0e10cSrcweir }
993cdf0e10cSrcweir return rValue;
994cdf0e10cSrcweir }
995cdf0e10cSrcweir // -------------------------------------------------------------------------
getString() const996cdf0e10cSrcweir ::rtl::OUString ORowSetValue::getString( ) const
997cdf0e10cSrcweir {
998cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getString" );
999cdf0e10cSrcweir ::rtl::OUString aRet;
1000cdf0e10cSrcweir if(!m_bNull)
1001cdf0e10cSrcweir {
1002cdf0e10cSrcweir switch(getTypeKind())
1003cdf0e10cSrcweir {
1004cdf0e10cSrcweir case DataType::CHAR:
1005cdf0e10cSrcweir case DataType::VARCHAR:
1006cdf0e10cSrcweir case DataType::DECIMAL:
1007cdf0e10cSrcweir case DataType::NUMERIC:
1008cdf0e10cSrcweir case DataType::LONGVARCHAR:
1009cdf0e10cSrcweir aRet = m_aValue.m_pString;
1010cdf0e10cSrcweir break;
1011cdf0e10cSrcweir case DataType::BIGINT:
1012cdf0e10cSrcweir if ( m_bSigned )
1013cdf0e10cSrcweir aRet = ::rtl::OUString::valueOf((sal_Int64)*this);
1014cdf0e10cSrcweir else
1015cdf0e10cSrcweir aRet = m_aValue.m_pString;
1016cdf0e10cSrcweir break;
1017cdf0e10cSrcweir case DataType::FLOAT:
1018cdf0e10cSrcweir aRet = ::rtl::OUString::valueOf((float)*this);
1019cdf0e10cSrcweir break;
1020cdf0e10cSrcweir case DataType::DOUBLE:
1021cdf0e10cSrcweir case DataType::REAL:
1022cdf0e10cSrcweir aRet = ::rtl::OUString::valueOf((double)*this);
1023cdf0e10cSrcweir break;
1024cdf0e10cSrcweir case DataType::DATE:
1025cdf0e10cSrcweir aRet = connectivity::toDateString(*this);
1026cdf0e10cSrcweir break;
1027cdf0e10cSrcweir case DataType::TIME:
1028cdf0e10cSrcweir aRet = connectivity::toTimeString(*this);
1029cdf0e10cSrcweir break;
1030cdf0e10cSrcweir case DataType::TIMESTAMP:
1031cdf0e10cSrcweir aRet = connectivity::toDateTimeString(*this);
1032cdf0e10cSrcweir break;
1033cdf0e10cSrcweir case DataType::BINARY:
1034cdf0e10cSrcweir case DataType::VARBINARY:
1035cdf0e10cSrcweir case DataType::LONGVARBINARY:
1036cdf0e10cSrcweir {
1037cdf0e10cSrcweir ::rtl::OUStringBuffer sVal = ::rtl::OUString::createFromAscii("0x");
1038cdf0e10cSrcweir Sequence<sal_Int8> aSeq(getSequence());
1039cdf0e10cSrcweir const sal_Int8* pBegin = aSeq.getConstArray();
1040cdf0e10cSrcweir const sal_Int8* pEnd = pBegin + aSeq.getLength();
1041cdf0e10cSrcweir for(;pBegin != pEnd;++pBegin)
1042cdf0e10cSrcweir sVal.append((sal_Int32)*pBegin,16);
1043cdf0e10cSrcweir aRet = sVal.makeStringAndClear();
1044cdf0e10cSrcweir }
1045cdf0e10cSrcweir break;
1046cdf0e10cSrcweir case DataType::BIT:
1047cdf0e10cSrcweir case DataType::BOOLEAN:
1048cdf0e10cSrcweir aRet = ::rtl::OUString::valueOf((sal_Int32)(sal_Bool)*this);
1049cdf0e10cSrcweir break;
1050cdf0e10cSrcweir case DataType::TINYINT:
1051cdf0e10cSrcweir if ( m_bSigned )
1052cdf0e10cSrcweir aRet = ::rtl::OUString::valueOf((sal_Int32)(sal_Int8)*this);
1053cdf0e10cSrcweir else
1054cdf0e10cSrcweir aRet = ::rtl::OUString::valueOf((sal_Int32)(sal_Int16)*this);
1055cdf0e10cSrcweir break;
1056cdf0e10cSrcweir case DataType::SMALLINT:
1057cdf0e10cSrcweir if ( m_bSigned )
1058cdf0e10cSrcweir aRet = ::rtl::OUString::valueOf((sal_Int32)(sal_Int16)*this);
1059cdf0e10cSrcweir else
1060cdf0e10cSrcweir aRet = ::rtl::OUString::valueOf((sal_Int32)*this);
1061cdf0e10cSrcweir break;
1062cdf0e10cSrcweir case DataType::INTEGER:
1063cdf0e10cSrcweir if ( m_bSigned )
1064cdf0e10cSrcweir aRet = ::rtl::OUString::valueOf((sal_Int32)*this);
1065cdf0e10cSrcweir else
1066cdf0e10cSrcweir aRet = ::rtl::OUString::valueOf((sal_Int64)*this);
1067cdf0e10cSrcweir break;
1068cdf0e10cSrcweir case DataType::CLOB:
1069cdf0e10cSrcweir {
1070cdf0e10cSrcweir Any aValue( getAny() );
1071cdf0e10cSrcweir Reference< XClob > xClob;
1072cdf0e10cSrcweir if ( aValue >>= xClob )
1073cdf0e10cSrcweir {
1074cdf0e10cSrcweir if ( xClob.is() )
1075cdf0e10cSrcweir {
1076cdf0e10cSrcweir aRet = xClob->getSubString(1,(sal_Int32)xClob->length() );
1077cdf0e10cSrcweir }
1078cdf0e10cSrcweir }
1079cdf0e10cSrcweir }
1080cdf0e10cSrcweir break;
1081cdf0e10cSrcweir default:
1082cdf0e10cSrcweir {
1083cdf0e10cSrcweir Any aValue = getAny();
1084cdf0e10cSrcweir aValue >>= aRet;
1085cdf0e10cSrcweir break;
1086cdf0e10cSrcweir }
1087cdf0e10cSrcweir }
1088cdf0e10cSrcweir }
1089cdf0e10cSrcweir return aRet;
1090cdf0e10cSrcweir }
1091cdf0e10cSrcweir // -------------------------------------------------------------------------
getBool() const1092cdf0e10cSrcweir sal_Bool ORowSetValue::getBool() const
1093cdf0e10cSrcweir {
1094cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getBool" );
1095cdf0e10cSrcweir sal_Bool bRet = sal_False;
1096cdf0e10cSrcweir if(!m_bNull)
1097cdf0e10cSrcweir {
1098cdf0e10cSrcweir switch(getTypeKind())
1099cdf0e10cSrcweir {
1100cdf0e10cSrcweir case DataType::CHAR:
1101cdf0e10cSrcweir case DataType::VARCHAR:
1102cdf0e10cSrcweir case DataType::LONGVARCHAR:
1103cdf0e10cSrcweir {
1104cdf0e10cSrcweir const ::rtl::OUString sValue(m_aValue.m_pString);
1105cdf0e10cSrcweir const static ::rtl::OUString s_sTrue(RTL_CONSTASCII_USTRINGPARAM("true"));
1106cdf0e10cSrcweir const static ::rtl::OUString s_sFalse(RTL_CONSTASCII_USTRINGPARAM("false"));
1107cdf0e10cSrcweir if ( sValue.equalsIgnoreAsciiCase(s_sTrue) )
1108cdf0e10cSrcweir {
1109cdf0e10cSrcweir bRet = sal_True;
1110cdf0e10cSrcweir break;
1111cdf0e10cSrcweir }
1112cdf0e10cSrcweir else if ( sValue.equalsIgnoreAsciiCase(s_sFalse) )
1113cdf0e10cSrcweir {
1114cdf0e10cSrcweir bRet = sal_False;
1115cdf0e10cSrcweir break;
1116cdf0e10cSrcweir }
1117cdf0e10cSrcweir }
1118cdf0e10cSrcweir // run through
1119cdf0e10cSrcweir case DataType::DECIMAL:
1120cdf0e10cSrcweir case DataType::NUMERIC:
1121cdf0e10cSrcweir
1122cdf0e10cSrcweir bRet = ::rtl::OUString(m_aValue.m_pString).toInt32() != 0;
1123cdf0e10cSrcweir break;
1124cdf0e10cSrcweir case DataType::BIGINT:
1125cdf0e10cSrcweir if ( m_bSigned )
1126cdf0e10cSrcweir bRet = *(sal_Int64*)m_aValue.m_pValue != 0;
1127cdf0e10cSrcweir else
1128cdf0e10cSrcweir bRet = ::rtl::OUString(m_aValue.m_pString).toInt64() != 0;
1129cdf0e10cSrcweir break;
1130cdf0e10cSrcweir case DataType::FLOAT:
1131cdf0e10cSrcweir bRet = *(float*)m_aValue.m_pValue != 0.0;
1132cdf0e10cSrcweir break;
1133cdf0e10cSrcweir case DataType::DOUBLE:
1134cdf0e10cSrcweir case DataType::REAL:
1135cdf0e10cSrcweir bRet = *(double*)m_aValue.m_pValue != 0.0;
1136cdf0e10cSrcweir break;
1137cdf0e10cSrcweir case DataType::DATE:
1138cdf0e10cSrcweir case DataType::TIME:
1139cdf0e10cSrcweir case DataType::TIMESTAMP:
1140cdf0e10cSrcweir case DataType::BINARY:
1141cdf0e10cSrcweir case DataType::VARBINARY:
1142cdf0e10cSrcweir case DataType::LONGVARBINARY:
1143cdf0e10cSrcweir OSL_ASSERT(!"getBool() for this type is not allowed!");
1144cdf0e10cSrcweir break;
1145cdf0e10cSrcweir case DataType::BIT:
1146cdf0e10cSrcweir case DataType::BOOLEAN:
1147cdf0e10cSrcweir bRet = m_aValue.m_bBool;
1148cdf0e10cSrcweir break;
1149cdf0e10cSrcweir case DataType::TINYINT:
1150cdf0e10cSrcweir bRet = m_bSigned ? (m_aValue.m_nInt8 != 0) : (m_aValue.m_nInt16 != 0);
1151cdf0e10cSrcweir break;
1152cdf0e10cSrcweir case DataType::SMALLINT:
1153cdf0e10cSrcweir bRet = m_bSigned ? (m_aValue.m_nInt16 != 0) : (m_aValue.m_nInt32 != 0);
1154cdf0e10cSrcweir break;
1155cdf0e10cSrcweir case DataType::INTEGER:
1156cdf0e10cSrcweir bRet = m_bSigned ? (m_aValue.m_nInt32 != 0) : (*static_cast<sal_Int64*>(m_aValue.m_pValue) != sal_Int64(0));
1157cdf0e10cSrcweir break;
1158cdf0e10cSrcweir default:
1159cdf0e10cSrcweir {
1160cdf0e10cSrcweir Any aValue = getAny();
1161cdf0e10cSrcweir aValue >>= bRet;
1162cdf0e10cSrcweir break;
1163cdf0e10cSrcweir }
1164cdf0e10cSrcweir }
1165cdf0e10cSrcweir }
1166cdf0e10cSrcweir return bRet;
1167cdf0e10cSrcweir }
1168cdf0e10cSrcweir // -------------------------------------------------------------------------
getInt8() const1169cdf0e10cSrcweir sal_Int8 ORowSetValue::getInt8() const
1170cdf0e10cSrcweir {
1171cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getInt8" );
1172cdf0e10cSrcweir
1173cdf0e10cSrcweir
1174cdf0e10cSrcweir sal_Int8 nRet = 0;
1175cdf0e10cSrcweir if(!m_bNull)
1176cdf0e10cSrcweir {
1177cdf0e10cSrcweir switch(getTypeKind())
1178cdf0e10cSrcweir {
1179cdf0e10cSrcweir case DataType::CHAR:
1180cdf0e10cSrcweir case DataType::VARCHAR:
1181cdf0e10cSrcweir case DataType::DECIMAL:
1182cdf0e10cSrcweir case DataType::NUMERIC:
1183cdf0e10cSrcweir case DataType::LONGVARCHAR:
1184cdf0e10cSrcweir nRet = sal_Int8(::rtl::OUString(m_aValue.m_pString).toInt32());
1185cdf0e10cSrcweir break;
1186cdf0e10cSrcweir case DataType::BIGINT:
1187cdf0e10cSrcweir if ( m_bSigned )
1188cdf0e10cSrcweir nRet = sal_Int8(*(sal_Int64*)m_aValue.m_pValue);
1189cdf0e10cSrcweir else
1190cdf0e10cSrcweir nRet = sal_Int8(::rtl::OUString(m_aValue.m_pString).toInt32());
1191cdf0e10cSrcweir break;
1192cdf0e10cSrcweir case DataType::FLOAT:
1193cdf0e10cSrcweir nRet = sal_Int8(*(float*)m_aValue.m_pValue);
1194cdf0e10cSrcweir break;
1195cdf0e10cSrcweir case DataType::DOUBLE:
1196cdf0e10cSrcweir case DataType::REAL:
1197cdf0e10cSrcweir nRet = sal_Int8(*(double*)m_aValue.m_pValue);
1198cdf0e10cSrcweir break;
1199cdf0e10cSrcweir case DataType::DATE:
1200cdf0e10cSrcweir case DataType::TIME:
1201cdf0e10cSrcweir case DataType::TIMESTAMP:
1202cdf0e10cSrcweir case DataType::BINARY:
1203cdf0e10cSrcweir case DataType::VARBINARY:
1204cdf0e10cSrcweir case DataType::LONGVARBINARY:
1205cdf0e10cSrcweir case DataType::BLOB:
1206cdf0e10cSrcweir case DataType::CLOB:
1207cdf0e10cSrcweir OSL_ASSERT(!"getInt8() for this type is not allowed!");
1208cdf0e10cSrcweir break;
1209cdf0e10cSrcweir case DataType::BIT:
1210cdf0e10cSrcweir case DataType::BOOLEAN:
1211cdf0e10cSrcweir nRet = m_aValue.m_bBool;
1212cdf0e10cSrcweir break;
1213cdf0e10cSrcweir case DataType::TINYINT:
1214cdf0e10cSrcweir if ( m_bSigned )
1215cdf0e10cSrcweir nRet = m_aValue.m_nInt8;
1216cdf0e10cSrcweir else
1217cdf0e10cSrcweir nRet = static_cast<sal_Int8>(m_aValue.m_nInt16);
1218cdf0e10cSrcweir break;
1219cdf0e10cSrcweir case DataType::SMALLINT:
1220cdf0e10cSrcweir if ( m_bSigned )
1221cdf0e10cSrcweir nRet = static_cast<sal_Int8>(m_aValue.m_nInt16);
1222cdf0e10cSrcweir else
1223cdf0e10cSrcweir nRet = static_cast<sal_Int8>(m_aValue.m_nInt32);
1224cdf0e10cSrcweir break;
1225cdf0e10cSrcweir case DataType::INTEGER:
1226cdf0e10cSrcweir if ( m_bSigned )
1227cdf0e10cSrcweir nRet = static_cast<sal_Int8>(m_aValue.m_nInt32);
1228cdf0e10cSrcweir else
1229cdf0e10cSrcweir nRet = static_cast<sal_Int8>(*static_cast<sal_Int64*>(m_aValue.m_pValue));
1230cdf0e10cSrcweir break;
1231cdf0e10cSrcweir default:
1232cdf0e10cSrcweir {
1233cdf0e10cSrcweir Any aValue = getAny();
1234cdf0e10cSrcweir aValue >>= nRet;
1235cdf0e10cSrcweir break;
1236cdf0e10cSrcweir }
1237cdf0e10cSrcweir }
1238cdf0e10cSrcweir }
1239cdf0e10cSrcweir return nRet;
1240cdf0e10cSrcweir }
1241cdf0e10cSrcweir // -------------------------------------------------------------------------
getInt16() const1242cdf0e10cSrcweir sal_Int16 ORowSetValue::getInt16() const
1243cdf0e10cSrcweir {
1244cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getInt16" );
1245cdf0e10cSrcweir
1246cdf0e10cSrcweir
1247cdf0e10cSrcweir sal_Int16 nRet = 0;
1248cdf0e10cSrcweir if(!m_bNull)
1249cdf0e10cSrcweir {
1250cdf0e10cSrcweir switch(getTypeKind())
1251cdf0e10cSrcweir {
1252cdf0e10cSrcweir case DataType::CHAR:
1253cdf0e10cSrcweir case DataType::VARCHAR:
1254cdf0e10cSrcweir case DataType::DECIMAL:
1255cdf0e10cSrcweir case DataType::NUMERIC:
1256cdf0e10cSrcweir case DataType::LONGVARCHAR:
1257cdf0e10cSrcweir nRet = sal_Int16(::rtl::OUString(m_aValue.m_pString).toInt32());
1258cdf0e10cSrcweir break;
1259cdf0e10cSrcweir case DataType::BIGINT:
1260cdf0e10cSrcweir if ( m_bSigned )
1261cdf0e10cSrcweir nRet = sal_Int16(*(sal_Int64*)m_aValue.m_pValue);
1262cdf0e10cSrcweir else
1263cdf0e10cSrcweir nRet = sal_Int16(::rtl::OUString(m_aValue.m_pString).toInt32());
1264cdf0e10cSrcweir break;
1265cdf0e10cSrcweir case DataType::FLOAT:
1266cdf0e10cSrcweir nRet = sal_Int16(*(float*)m_aValue.m_pValue);
1267cdf0e10cSrcweir break;
1268cdf0e10cSrcweir case DataType::DOUBLE:
1269cdf0e10cSrcweir case DataType::REAL:
1270cdf0e10cSrcweir nRet = sal_Int16(*(double*)m_aValue.m_pValue);
1271cdf0e10cSrcweir break;
1272cdf0e10cSrcweir case DataType::DATE:
1273cdf0e10cSrcweir case DataType::TIME:
1274cdf0e10cSrcweir case DataType::TIMESTAMP:
1275cdf0e10cSrcweir case DataType::BINARY:
1276cdf0e10cSrcweir case DataType::VARBINARY:
1277cdf0e10cSrcweir case DataType::LONGVARBINARY:
1278cdf0e10cSrcweir case DataType::BLOB:
1279cdf0e10cSrcweir case DataType::CLOB:
1280cdf0e10cSrcweir OSL_ASSERT(!"getInt16() for this type is not allowed!");
1281cdf0e10cSrcweir break;
1282cdf0e10cSrcweir case DataType::BIT:
1283cdf0e10cSrcweir case DataType::BOOLEAN:
1284cdf0e10cSrcweir nRet = m_aValue.m_bBool;
1285cdf0e10cSrcweir break;
1286cdf0e10cSrcweir case DataType::TINYINT:
1287cdf0e10cSrcweir if ( m_bSigned )
1288cdf0e10cSrcweir nRet = m_aValue.m_nInt8;
1289cdf0e10cSrcweir else
1290cdf0e10cSrcweir nRet = m_aValue.m_nInt16;
1291cdf0e10cSrcweir break;
1292cdf0e10cSrcweir case DataType::SMALLINT:
1293cdf0e10cSrcweir if ( m_bSigned )
1294cdf0e10cSrcweir nRet = m_aValue.m_nInt16;
1295cdf0e10cSrcweir else
1296cdf0e10cSrcweir nRet = static_cast<sal_Int16>(m_aValue.m_nInt32);
1297cdf0e10cSrcweir break;
1298cdf0e10cSrcweir case DataType::INTEGER:
1299cdf0e10cSrcweir if ( m_bSigned )
1300cdf0e10cSrcweir nRet = static_cast<sal_Int16>(m_aValue.m_nInt32);
1301cdf0e10cSrcweir else
1302cdf0e10cSrcweir nRet = static_cast<sal_Int16>(*static_cast<sal_Int64*>(m_aValue.m_pValue));
1303cdf0e10cSrcweir break;
1304cdf0e10cSrcweir default:
1305cdf0e10cSrcweir {
1306cdf0e10cSrcweir Any aValue = getAny();
1307cdf0e10cSrcweir aValue >>= nRet;
1308cdf0e10cSrcweir break;
1309cdf0e10cSrcweir }
1310cdf0e10cSrcweir }
1311cdf0e10cSrcweir }
1312cdf0e10cSrcweir return nRet;
1313cdf0e10cSrcweir }
1314cdf0e10cSrcweir // -------------------------------------------------------------------------
getInt32() const1315cdf0e10cSrcweir sal_Int32 ORowSetValue::getInt32() const
1316cdf0e10cSrcweir {
1317cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getInt32" );
1318cdf0e10cSrcweir sal_Int32 nRet = 0;
1319cdf0e10cSrcweir if(!m_bNull)
1320cdf0e10cSrcweir {
1321cdf0e10cSrcweir switch(getTypeKind())
1322cdf0e10cSrcweir {
1323cdf0e10cSrcweir case DataType::CHAR:
1324cdf0e10cSrcweir case DataType::VARCHAR:
1325cdf0e10cSrcweir case DataType::DECIMAL:
1326cdf0e10cSrcweir case DataType::NUMERIC:
1327cdf0e10cSrcweir case DataType::LONGVARCHAR:
1328cdf0e10cSrcweir nRet = ::rtl::OUString(m_aValue.m_pString).toInt32();
1329cdf0e10cSrcweir break;
1330cdf0e10cSrcweir case DataType::BIGINT:
1331cdf0e10cSrcweir if ( m_bSigned )
1332cdf0e10cSrcweir nRet = sal_Int32(*(sal_Int64*)m_aValue.m_pValue);
1333cdf0e10cSrcweir else
1334cdf0e10cSrcweir nRet = ::rtl::OUString(m_aValue.m_pString).toInt32();
1335cdf0e10cSrcweir break;
1336cdf0e10cSrcweir case DataType::FLOAT:
1337cdf0e10cSrcweir nRet = sal_Int32(*(float*)m_aValue.m_pValue);
1338cdf0e10cSrcweir break;
1339cdf0e10cSrcweir case DataType::DOUBLE:
1340cdf0e10cSrcweir case DataType::REAL:
1341cdf0e10cSrcweir nRet = sal_Int32(*(double*)m_aValue.m_pValue);
1342cdf0e10cSrcweir break;
1343cdf0e10cSrcweir case DataType::DATE:
1344cdf0e10cSrcweir nRet = dbtools::DBTypeConversion::toDays(*(::com::sun::star::util::Date*)m_aValue.m_pValue);
1345cdf0e10cSrcweir break;
1346cdf0e10cSrcweir case DataType::TIME:
1347cdf0e10cSrcweir case DataType::TIMESTAMP:
1348cdf0e10cSrcweir case DataType::BINARY:
1349cdf0e10cSrcweir case DataType::VARBINARY:
1350cdf0e10cSrcweir case DataType::LONGVARBINARY:
1351cdf0e10cSrcweir case DataType::BLOB:
1352cdf0e10cSrcweir case DataType::CLOB:
1353cdf0e10cSrcweir OSL_ASSERT(!"getInt32() for this type is not allowed!");
1354cdf0e10cSrcweir break;
1355cdf0e10cSrcweir case DataType::BIT:
1356cdf0e10cSrcweir case DataType::BOOLEAN:
1357cdf0e10cSrcweir nRet = m_aValue.m_bBool;
1358cdf0e10cSrcweir break;
1359cdf0e10cSrcweir case DataType::TINYINT:
1360cdf0e10cSrcweir if ( m_bSigned )
1361cdf0e10cSrcweir nRet = m_aValue.m_nInt8;
1362cdf0e10cSrcweir else
1363cdf0e10cSrcweir nRet = m_aValue.m_nInt16;
1364cdf0e10cSrcweir break;
1365cdf0e10cSrcweir case DataType::SMALLINT:
1366cdf0e10cSrcweir if ( m_bSigned )
1367cdf0e10cSrcweir nRet = m_aValue.m_nInt16;
1368cdf0e10cSrcweir else
1369cdf0e10cSrcweir nRet = m_aValue.m_nInt32;
1370cdf0e10cSrcweir break;
1371cdf0e10cSrcweir case DataType::INTEGER:
1372cdf0e10cSrcweir if ( m_bSigned )
1373cdf0e10cSrcweir nRet = m_aValue.m_nInt32;
1374cdf0e10cSrcweir else
1375cdf0e10cSrcweir nRet = static_cast<sal_Int32>(*static_cast<sal_Int64*>(m_aValue.m_pValue));
1376cdf0e10cSrcweir break;
1377cdf0e10cSrcweir default:
1378cdf0e10cSrcweir {
1379cdf0e10cSrcweir Any aValue = getAny();
1380cdf0e10cSrcweir aValue >>= nRet;
1381cdf0e10cSrcweir break;
1382cdf0e10cSrcweir }
1383cdf0e10cSrcweir }
1384cdf0e10cSrcweir }
1385cdf0e10cSrcweir return nRet;
1386cdf0e10cSrcweir }
1387cdf0e10cSrcweir // -------------------------------------------------------------------------
getLong() const1388cdf0e10cSrcweir sal_Int64 ORowSetValue::getLong() const
1389cdf0e10cSrcweir {
1390cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getLong" );
1391cdf0e10cSrcweir sal_Int64 nRet = 0;
1392cdf0e10cSrcweir if(!m_bNull)
1393cdf0e10cSrcweir {
1394cdf0e10cSrcweir switch(getTypeKind())
1395cdf0e10cSrcweir {
1396cdf0e10cSrcweir case DataType::CHAR:
1397cdf0e10cSrcweir case DataType::VARCHAR:
1398cdf0e10cSrcweir case DataType::DECIMAL:
1399cdf0e10cSrcweir case DataType::NUMERIC:
1400cdf0e10cSrcweir case DataType::LONGVARCHAR:
1401cdf0e10cSrcweir nRet = ::rtl::OUString(m_aValue.m_pString).toInt64();
1402cdf0e10cSrcweir break;
1403cdf0e10cSrcweir case DataType::BIGINT:
1404cdf0e10cSrcweir if ( m_bSigned )
1405cdf0e10cSrcweir nRet = *(sal_Int64*)m_aValue.m_pValue;
1406cdf0e10cSrcweir else
1407cdf0e10cSrcweir nRet = ::rtl::OUString(m_aValue.m_pString).toInt64();
1408cdf0e10cSrcweir break;
1409cdf0e10cSrcweir case DataType::FLOAT:
1410cdf0e10cSrcweir nRet = sal_Int64(*(float*)m_aValue.m_pValue);
1411cdf0e10cSrcweir break;
1412cdf0e10cSrcweir case DataType::DOUBLE:
1413cdf0e10cSrcweir case DataType::REAL:
1414cdf0e10cSrcweir nRet = sal_Int64(*(double*)m_aValue.m_pValue);
1415cdf0e10cSrcweir break;
1416cdf0e10cSrcweir case DataType::DATE:
1417cdf0e10cSrcweir nRet = dbtools::DBTypeConversion::toDays(*(::com::sun::star::util::Date*)m_aValue.m_pValue);
1418cdf0e10cSrcweir break;
1419cdf0e10cSrcweir case DataType::TIME:
1420cdf0e10cSrcweir case DataType::TIMESTAMP:
1421cdf0e10cSrcweir case DataType::BINARY:
1422cdf0e10cSrcweir case DataType::VARBINARY:
1423cdf0e10cSrcweir case DataType::LONGVARBINARY:
1424cdf0e10cSrcweir case DataType::BLOB:
1425cdf0e10cSrcweir case DataType::CLOB:
1426cdf0e10cSrcweir OSL_ASSERT(!"getInt32() for this type is not allowed!");
1427cdf0e10cSrcweir break;
1428cdf0e10cSrcweir case DataType::BIT:
1429cdf0e10cSrcweir case DataType::BOOLEAN:
1430cdf0e10cSrcweir nRet = m_aValue.m_bBool;
1431cdf0e10cSrcweir break;
1432cdf0e10cSrcweir case DataType::TINYINT:
1433cdf0e10cSrcweir if ( m_bSigned )
1434cdf0e10cSrcweir nRet = m_aValue.m_nInt8;
1435cdf0e10cSrcweir else
1436cdf0e10cSrcweir nRet = m_aValue.m_nInt16;
1437cdf0e10cSrcweir break;
1438cdf0e10cSrcweir case DataType::SMALLINT:
1439cdf0e10cSrcweir if ( m_bSigned )
1440cdf0e10cSrcweir nRet = m_aValue.m_nInt16;
1441cdf0e10cSrcweir else
1442cdf0e10cSrcweir nRet = m_aValue.m_nInt32;
1443cdf0e10cSrcweir break;
1444cdf0e10cSrcweir case DataType::INTEGER:
1445cdf0e10cSrcweir if ( m_bSigned )
1446cdf0e10cSrcweir nRet = m_aValue.m_nInt32;
1447cdf0e10cSrcweir else
1448cdf0e10cSrcweir nRet = *(sal_Int64*)m_aValue.m_pValue;
1449cdf0e10cSrcweir break;
1450cdf0e10cSrcweir default:
1451cdf0e10cSrcweir {
1452cdf0e10cSrcweir Any aValue = getAny();
1453cdf0e10cSrcweir aValue >>= nRet;
1454cdf0e10cSrcweir break;
1455cdf0e10cSrcweir }
1456cdf0e10cSrcweir }
1457cdf0e10cSrcweir }
1458cdf0e10cSrcweir return nRet;
1459cdf0e10cSrcweir }
1460cdf0e10cSrcweir // -------------------------------------------------------------------------
getFloat() const1461cdf0e10cSrcweir float ORowSetValue::getFloat() const
1462cdf0e10cSrcweir {
1463cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getFloat" );
1464cdf0e10cSrcweir float nRet = 0;
1465cdf0e10cSrcweir if(!m_bNull)
1466cdf0e10cSrcweir {
1467cdf0e10cSrcweir switch(getTypeKind())
1468cdf0e10cSrcweir {
1469cdf0e10cSrcweir case DataType::CHAR:
1470cdf0e10cSrcweir case DataType::VARCHAR:
1471cdf0e10cSrcweir case DataType::DECIMAL:
1472cdf0e10cSrcweir case DataType::NUMERIC:
1473cdf0e10cSrcweir case DataType::LONGVARCHAR:
1474cdf0e10cSrcweir nRet = ::rtl::OUString(m_aValue.m_pString).toFloat();
1475cdf0e10cSrcweir break;
1476cdf0e10cSrcweir case DataType::BIGINT:
1477cdf0e10cSrcweir if ( m_bSigned )
1478cdf0e10cSrcweir nRet = float(*(sal_Int64*)m_aValue.m_pValue);
1479cdf0e10cSrcweir else
1480cdf0e10cSrcweir nRet = ::rtl::OUString(m_aValue.m_pString).toFloat();
1481cdf0e10cSrcweir break;
1482cdf0e10cSrcweir case DataType::FLOAT:
1483cdf0e10cSrcweir nRet = *(float*)m_aValue.m_pValue;
1484cdf0e10cSrcweir break;
1485cdf0e10cSrcweir case DataType::DOUBLE:
1486cdf0e10cSrcweir case DataType::REAL:
1487cdf0e10cSrcweir nRet = (float)*(double*)m_aValue.m_pValue;
1488cdf0e10cSrcweir break;
1489cdf0e10cSrcweir case DataType::DATE:
1490cdf0e10cSrcweir nRet = (float)dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::Date*)m_aValue.m_pValue);
1491cdf0e10cSrcweir break;
1492cdf0e10cSrcweir case DataType::TIME:
1493cdf0e10cSrcweir nRet = (float)dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::Time*)m_aValue.m_pValue);
1494cdf0e10cSrcweir break;
1495cdf0e10cSrcweir case DataType::TIMESTAMP:
1496cdf0e10cSrcweir nRet = (float)dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::DateTime*)m_aValue.m_pValue);
1497cdf0e10cSrcweir break;
1498cdf0e10cSrcweir case DataType::BINARY:
1499cdf0e10cSrcweir case DataType::VARBINARY:
1500cdf0e10cSrcweir case DataType::LONGVARBINARY:
1501cdf0e10cSrcweir case DataType::BLOB:
1502cdf0e10cSrcweir case DataType::CLOB:
1503cdf0e10cSrcweir OSL_ASSERT(!"getDouble() for this type is not allowed!");
1504cdf0e10cSrcweir break;
1505cdf0e10cSrcweir case DataType::BIT:
1506cdf0e10cSrcweir case DataType::BOOLEAN:
1507cdf0e10cSrcweir nRet = m_aValue.m_bBool;
1508cdf0e10cSrcweir break;
1509cdf0e10cSrcweir case DataType::TINYINT:
1510cdf0e10cSrcweir if ( m_bSigned )
1511cdf0e10cSrcweir nRet = m_aValue.m_nInt8;
1512cdf0e10cSrcweir else
1513cdf0e10cSrcweir nRet = m_aValue.m_nInt16;
1514cdf0e10cSrcweir break;
1515cdf0e10cSrcweir case DataType::SMALLINT:
1516cdf0e10cSrcweir if ( m_bSigned )
1517cdf0e10cSrcweir nRet = m_aValue.m_nInt16;
1518cdf0e10cSrcweir else
1519cdf0e10cSrcweir nRet = (float)m_aValue.m_nInt32;
1520cdf0e10cSrcweir break;
1521cdf0e10cSrcweir case DataType::INTEGER:
1522cdf0e10cSrcweir if ( m_bSigned )
1523cdf0e10cSrcweir nRet = (float)m_aValue.m_nInt32;
1524cdf0e10cSrcweir else
1525cdf0e10cSrcweir nRet = float(*(sal_Int64*)m_aValue.m_pValue);
1526cdf0e10cSrcweir break;
1527cdf0e10cSrcweir default:
1528cdf0e10cSrcweir {
1529cdf0e10cSrcweir Any aValue = getAny();
1530cdf0e10cSrcweir aValue >>= nRet;
1531cdf0e10cSrcweir break;
1532cdf0e10cSrcweir }
1533cdf0e10cSrcweir }
1534cdf0e10cSrcweir }
1535cdf0e10cSrcweir return nRet;
1536cdf0e10cSrcweir }
1537cdf0e10cSrcweir // -------------------------------------------------------------------------
getDouble() const1538cdf0e10cSrcweir double ORowSetValue::getDouble() const
1539cdf0e10cSrcweir {
1540cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getDouble" );
1541cdf0e10cSrcweir
1542cdf0e10cSrcweir
1543cdf0e10cSrcweir double nRet = 0;
1544cdf0e10cSrcweir if(!m_bNull)
1545cdf0e10cSrcweir {
1546cdf0e10cSrcweir switch(getTypeKind())
1547cdf0e10cSrcweir {
1548cdf0e10cSrcweir case DataType::CHAR:
1549cdf0e10cSrcweir case DataType::VARCHAR:
1550cdf0e10cSrcweir case DataType::DECIMAL:
1551cdf0e10cSrcweir case DataType::NUMERIC:
1552cdf0e10cSrcweir case DataType::LONGVARCHAR:
1553cdf0e10cSrcweir nRet = ::rtl::OUString(m_aValue.m_pString).toDouble();
1554cdf0e10cSrcweir break;
1555cdf0e10cSrcweir case DataType::BIGINT:
1556cdf0e10cSrcweir if ( m_bSigned )
1557cdf0e10cSrcweir nRet = double(*(sal_Int64*)m_aValue.m_pValue);
1558cdf0e10cSrcweir else
1559cdf0e10cSrcweir nRet = ::rtl::OUString(m_aValue.m_pString).toDouble();
1560cdf0e10cSrcweir break;
1561cdf0e10cSrcweir case DataType::FLOAT:
1562cdf0e10cSrcweir nRet = *(float*)m_aValue.m_pValue;
1563cdf0e10cSrcweir break;
1564cdf0e10cSrcweir case DataType::DOUBLE:
1565cdf0e10cSrcweir case DataType::REAL:
1566cdf0e10cSrcweir nRet = *(double*)m_aValue.m_pValue;
1567cdf0e10cSrcweir break;
1568cdf0e10cSrcweir case DataType::DATE:
1569cdf0e10cSrcweir nRet = dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::Date*)m_aValue.m_pValue);
1570cdf0e10cSrcweir break;
1571cdf0e10cSrcweir case DataType::TIME:
1572cdf0e10cSrcweir nRet = dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::Time*)m_aValue.m_pValue);
1573cdf0e10cSrcweir break;
1574cdf0e10cSrcweir case DataType::TIMESTAMP:
1575cdf0e10cSrcweir nRet = dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::DateTime*)m_aValue.m_pValue);
1576cdf0e10cSrcweir break;
1577cdf0e10cSrcweir case DataType::BINARY:
1578cdf0e10cSrcweir case DataType::VARBINARY:
1579cdf0e10cSrcweir case DataType::LONGVARBINARY:
1580cdf0e10cSrcweir case DataType::BLOB:
1581cdf0e10cSrcweir case DataType::CLOB:
1582cdf0e10cSrcweir OSL_ASSERT(!"getDouble() for this type is not allowed!");
1583cdf0e10cSrcweir break;
1584cdf0e10cSrcweir case DataType::BIT:
1585cdf0e10cSrcweir case DataType::BOOLEAN:
1586cdf0e10cSrcweir nRet = m_aValue.m_bBool;
1587cdf0e10cSrcweir break;
1588cdf0e10cSrcweir case DataType::TINYINT:
1589cdf0e10cSrcweir if ( m_bSigned )
1590cdf0e10cSrcweir nRet = m_aValue.m_nInt8;
1591cdf0e10cSrcweir else
1592cdf0e10cSrcweir nRet = m_aValue.m_nInt16;
1593cdf0e10cSrcweir break;
1594cdf0e10cSrcweir case DataType::SMALLINT:
1595cdf0e10cSrcweir if ( m_bSigned )
1596cdf0e10cSrcweir nRet = m_aValue.m_nInt16;
1597cdf0e10cSrcweir else
1598cdf0e10cSrcweir nRet = m_aValue.m_nInt32;
1599cdf0e10cSrcweir break;
1600cdf0e10cSrcweir case DataType::INTEGER:
1601cdf0e10cSrcweir if ( m_bSigned )
1602cdf0e10cSrcweir nRet = m_aValue.m_nInt32;
1603cdf0e10cSrcweir else
1604cdf0e10cSrcweir nRet = double(*(sal_Int64*)m_aValue.m_pValue);
1605cdf0e10cSrcweir break;
1606cdf0e10cSrcweir default:
1607cdf0e10cSrcweir {
1608cdf0e10cSrcweir Any aValue = getAny();
1609cdf0e10cSrcweir aValue >>= nRet;
1610cdf0e10cSrcweir break;
1611cdf0e10cSrcweir }
1612cdf0e10cSrcweir }
1613cdf0e10cSrcweir }
1614cdf0e10cSrcweir return nRet;
1615cdf0e10cSrcweir }
1616cdf0e10cSrcweir // -------------------------------------------------------------------------
setFromDouble(const double & _rVal,sal_Int32 _nDatatype)1617cdf0e10cSrcweir void ORowSetValue::setFromDouble(const double& _rVal,sal_Int32 _nDatatype)
1618cdf0e10cSrcweir {
1619cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::setFromDouble" );
1620cdf0e10cSrcweir free();
1621cdf0e10cSrcweir
1622cdf0e10cSrcweir m_bNull = sal_False;
1623cdf0e10cSrcweir switch(_nDatatype)
1624cdf0e10cSrcweir {
1625cdf0e10cSrcweir case DataType::CHAR:
1626cdf0e10cSrcweir case DataType::VARCHAR:
1627cdf0e10cSrcweir case DataType::DECIMAL:
1628cdf0e10cSrcweir case DataType::NUMERIC:
1629cdf0e10cSrcweir case DataType::LONGVARCHAR:
1630cdf0e10cSrcweir {
1631cdf0e10cSrcweir ::rtl::OUString aVal = ::rtl::OUString::valueOf(_rVal);
1632cdf0e10cSrcweir m_aValue.m_pString = aVal.pData;
1633cdf0e10cSrcweir rtl_uString_acquire(m_aValue.m_pString);
1634cdf0e10cSrcweir }
1635cdf0e10cSrcweir break;
1636cdf0e10cSrcweir case DataType::BIGINT:
1637cdf0e10cSrcweir if ( m_bSigned )
1638cdf0e10cSrcweir {
1639cdf0e10cSrcweir m_aValue.m_pValue = new sal_Int64((sal_Int64)_rVal);
1640cdf0e10cSrcweir TRACE_ALLOC( sal_Int64 )
1641cdf0e10cSrcweir }
1642cdf0e10cSrcweir else
1643cdf0e10cSrcweir {
1644cdf0e10cSrcweir ::rtl::OUString aVal = ::rtl::OUString::valueOf(_rVal);
1645cdf0e10cSrcweir m_aValue.m_pString = aVal.pData;
1646cdf0e10cSrcweir rtl_uString_acquire(m_aValue.m_pString);
1647cdf0e10cSrcweir }
1648cdf0e10cSrcweir break;
1649cdf0e10cSrcweir case DataType::FLOAT:
1650cdf0e10cSrcweir m_aValue.m_pValue = new float((float)_rVal);
1651cdf0e10cSrcweir TRACE_ALLOC( float )
1652cdf0e10cSrcweir break;
1653cdf0e10cSrcweir case DataType::DOUBLE:
1654cdf0e10cSrcweir case DataType::REAL:
1655cdf0e10cSrcweir m_aValue.m_pValue = new double(_rVal);
1656cdf0e10cSrcweir TRACE_ALLOC( double )
1657cdf0e10cSrcweir break;
1658cdf0e10cSrcweir case DataType::DATE:
1659cdf0e10cSrcweir m_aValue.m_pValue = new Date(dbtools::DBTypeConversion::toDate(_rVal));
1660cdf0e10cSrcweir TRACE_ALLOC( Date )
1661cdf0e10cSrcweir break;
1662cdf0e10cSrcweir case DataType::TIME:
1663cdf0e10cSrcweir m_aValue.m_pValue = new Time(dbtools::DBTypeConversion::toTime(_rVal));
1664cdf0e10cSrcweir TRACE_ALLOC( Time )
1665cdf0e10cSrcweir break;
1666cdf0e10cSrcweir case DataType::TIMESTAMP:
1667cdf0e10cSrcweir m_aValue.m_pValue = new DateTime(dbtools::DBTypeConversion::toDateTime(_rVal));
1668cdf0e10cSrcweir TRACE_ALLOC( DateTime )
1669cdf0e10cSrcweir break;
1670cdf0e10cSrcweir case DataType::BINARY:
1671cdf0e10cSrcweir case DataType::VARBINARY:
1672cdf0e10cSrcweir case DataType::LONGVARBINARY:
1673cdf0e10cSrcweir case DataType::BLOB:
1674cdf0e10cSrcweir case DataType::CLOB:
1675cdf0e10cSrcweir OSL_ASSERT(!"setFromDouble() for this type is not allowed!");
1676cdf0e10cSrcweir break;
1677cdf0e10cSrcweir case DataType::BIT:
1678cdf0e10cSrcweir case DataType::BOOLEAN:
1679cdf0e10cSrcweir m_aValue.m_bBool = _rVal != 0.0;
1680cdf0e10cSrcweir break;
1681cdf0e10cSrcweir case DataType::TINYINT:
1682cdf0e10cSrcweir if ( m_bSigned )
1683cdf0e10cSrcweir m_aValue.m_nInt8 = sal_Int8(_rVal);
1684cdf0e10cSrcweir else
1685cdf0e10cSrcweir m_aValue.m_nInt16 = sal_Int16(_rVal);
1686cdf0e10cSrcweir break;
1687cdf0e10cSrcweir case DataType::SMALLINT:
1688cdf0e10cSrcweir if ( m_bSigned )
1689cdf0e10cSrcweir m_aValue.m_nInt16 = sal_Int16(_rVal);
1690cdf0e10cSrcweir else
1691cdf0e10cSrcweir m_aValue.m_nInt32 = sal_Int32(_rVal);
1692cdf0e10cSrcweir break;
1693cdf0e10cSrcweir case DataType::INTEGER:
1694cdf0e10cSrcweir if ( m_bSigned )
1695cdf0e10cSrcweir m_aValue.m_nInt32 = sal_Int32(_rVal);
1696cdf0e10cSrcweir else
1697cdf0e10cSrcweir {
1698cdf0e10cSrcweir m_aValue.m_pValue = new sal_Int64((sal_Int64)_rVal);
1699cdf0e10cSrcweir TRACE_ALLOC( sal_Int64 )
1700cdf0e10cSrcweir }
1701cdf0e10cSrcweir break;
1702cdf0e10cSrcweir default:
1703cdf0e10cSrcweir {
1704cdf0e10cSrcweir m_aValue.m_pValue = new Any(_rVal);
1705cdf0e10cSrcweir break;
1706cdf0e10cSrcweir }
1707cdf0e10cSrcweir }
1708cdf0e10cSrcweir m_eTypeKind = _nDatatype;
1709cdf0e10cSrcweir }
1710cdf0e10cSrcweir // -----------------------------------------------------------------------------
getSequence() const1711cdf0e10cSrcweir Sequence<sal_Int8> ORowSetValue::getSequence() const
1712cdf0e10cSrcweir {
1713cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getSequence" );
1714cdf0e10cSrcweir Sequence<sal_Int8> aSeq;
1715cdf0e10cSrcweir if (!m_bNull)
1716cdf0e10cSrcweir {
1717cdf0e10cSrcweir switch(m_eTypeKind)
1718cdf0e10cSrcweir {
1719cdf0e10cSrcweir case DataType::OBJECT:
1720cdf0e10cSrcweir case DataType::CLOB:
1721cdf0e10cSrcweir case DataType::BLOB:
1722cdf0e10cSrcweir {
1723cdf0e10cSrcweir Reference<XInputStream> xStream;
1724cdf0e10cSrcweir const Any aValue = makeAny();
1725cdf0e10cSrcweir if(aValue.hasValue())
1726cdf0e10cSrcweir {
1727cdf0e10cSrcweir Reference<XBlob> xBlob(aValue,UNO_QUERY);
1728cdf0e10cSrcweir if ( xBlob.is() )
1729cdf0e10cSrcweir xStream = xBlob->getBinaryStream();
1730cdf0e10cSrcweir else
1731cdf0e10cSrcweir {
1732cdf0e10cSrcweir Reference<XClob> xClob(aValue,UNO_QUERY);
1733cdf0e10cSrcweir if ( xClob.is() )
1734cdf0e10cSrcweir xStream = xClob->getCharacterStream();
1735cdf0e10cSrcweir }
1736cdf0e10cSrcweir if(xStream.is())
1737cdf0e10cSrcweir {
1738cdf0e10cSrcweir const sal_uInt32 nBytesToRead = 65535;
1739cdf0e10cSrcweir sal_uInt32 nRead;
1740cdf0e10cSrcweir
1741cdf0e10cSrcweir do
1742cdf0e10cSrcweir {
1743cdf0e10cSrcweir ::com::sun::star::uno::Sequence< sal_Int8 > aReadSeq;
1744cdf0e10cSrcweir
1745cdf0e10cSrcweir nRead = xStream->readSomeBytes( aReadSeq, nBytesToRead );
1746cdf0e10cSrcweir
1747cdf0e10cSrcweir if( nRead )
1748cdf0e10cSrcweir {
1749cdf0e10cSrcweir const sal_uInt32 nOldLength = aSeq.getLength();
1750cdf0e10cSrcweir aSeq.realloc( nOldLength + nRead );
1751cdf0e10cSrcweir rtl_copyMemory( aSeq.getArray() + nOldLength, aReadSeq.getConstArray(), aReadSeq.getLength() );
1752cdf0e10cSrcweir }
1753cdf0e10cSrcweir }
1754cdf0e10cSrcweir while( nBytesToRead == nRead );
1755cdf0e10cSrcweir xStream->closeInput();
1756cdf0e10cSrcweir }
1757cdf0e10cSrcweir }
1758cdf0e10cSrcweir }
1759cdf0e10cSrcweir break;
1760cdf0e10cSrcweir case DataType::VARCHAR:
1761cdf0e10cSrcweir case DataType::LONGVARCHAR:
1762cdf0e10cSrcweir {
1763cdf0e10cSrcweir ::rtl::OUString sVal(m_aValue.m_pString);
1764cdf0e10cSrcweir aSeq = Sequence<sal_Int8>(reinterpret_cast<const sal_Int8*>(sVal.getStr()),sizeof(sal_Unicode)*sVal.getLength());
1765cdf0e10cSrcweir }
1766cdf0e10cSrcweir break;
1767cdf0e10cSrcweir case DataType::BINARY:
1768cdf0e10cSrcweir case DataType::VARBINARY:
1769cdf0e10cSrcweir case DataType::LONGVARBINARY:
1770cdf0e10cSrcweir aSeq = *static_cast< Sequence<sal_Int8>*>(m_aValue.m_pValue);
1771cdf0e10cSrcweir break;
1772cdf0e10cSrcweir default:
1773cdf0e10cSrcweir {
1774cdf0e10cSrcweir Any aValue = getAny();
1775cdf0e10cSrcweir aValue >>= aSeq;
1776cdf0e10cSrcweir break;
1777cdf0e10cSrcweir }
1778cdf0e10cSrcweir }
1779cdf0e10cSrcweir }
1780cdf0e10cSrcweir return aSeq;
1781cdf0e10cSrcweir
1782cdf0e10cSrcweir }
1783cdf0e10cSrcweir // -----------------------------------------------------------------------------
getDate() const1784cdf0e10cSrcweir ::com::sun::star::util::Date ORowSetValue::getDate() const
1785cdf0e10cSrcweir {
1786cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getDate" );
1787cdf0e10cSrcweir ::com::sun::star::util::Date aValue;
1788cdf0e10cSrcweir if(!m_bNull)
1789cdf0e10cSrcweir {
1790cdf0e10cSrcweir switch(m_eTypeKind)
1791cdf0e10cSrcweir {
1792cdf0e10cSrcweir case DataType::CHAR:
1793cdf0e10cSrcweir case DataType::VARCHAR:
1794cdf0e10cSrcweir case DataType::LONGVARCHAR:
1795cdf0e10cSrcweir aValue = DBTypeConversion::toDate(getString());
1796cdf0e10cSrcweir break;
1797cdf0e10cSrcweir case DataType::DECIMAL:
1798cdf0e10cSrcweir case DataType::NUMERIC:
1799cdf0e10cSrcweir case DataType::FLOAT:
1800cdf0e10cSrcweir case DataType::DOUBLE:
1801cdf0e10cSrcweir case DataType::REAL:
1802cdf0e10cSrcweir aValue = DBTypeConversion::toDate((double)*this);
1803cdf0e10cSrcweir break;
1804cdf0e10cSrcweir
1805cdf0e10cSrcweir case DataType::DATE:
1806cdf0e10cSrcweir aValue = *static_cast< ::com::sun::star::util::Date*>(m_aValue.m_pValue);
1807cdf0e10cSrcweir break;
1808cdf0e10cSrcweir case DataType::TIMESTAMP:
1809cdf0e10cSrcweir {
1810cdf0e10cSrcweir ::com::sun::star::util::DateTime* pDateTime = static_cast< ::com::sun::star::util::DateTime*>(m_aValue.m_pValue);
1811cdf0e10cSrcweir aValue.Day = pDateTime->Day;
1812cdf0e10cSrcweir aValue.Month = pDateTime->Month;
1813cdf0e10cSrcweir aValue.Year = pDateTime->Year;
1814cdf0e10cSrcweir }
1815cdf0e10cSrcweir break;
1816cdf0e10cSrcweir case DataType::BIT:
1817cdf0e10cSrcweir case DataType::BOOLEAN:
1818cdf0e10cSrcweir case DataType::TINYINT:
1819cdf0e10cSrcweir case DataType::SMALLINT:
1820cdf0e10cSrcweir case DataType::INTEGER:
1821cdf0e10cSrcweir case DataType::BIGINT:
1822cdf0e10cSrcweir aValue = DBTypeConversion::toDate( double( sal_Int64( *this ) ) );
1823cdf0e10cSrcweir break;
1824cdf0e10cSrcweir
1825cdf0e10cSrcweir case DataType::BLOB:
1826cdf0e10cSrcweir case DataType::CLOB:
1827cdf0e10cSrcweir case DataType::OBJECT:
1828cdf0e10cSrcweir default:
1829cdf0e10cSrcweir OSL_ENSURE( false, "ORowSetValue::getDate: cannot retrieve the data!" );
1830cdf0e10cSrcweir // NO break!
1831cdf0e10cSrcweir
1832cdf0e10cSrcweir case DataType::BINARY:
1833cdf0e10cSrcweir case DataType::VARBINARY:
1834cdf0e10cSrcweir case DataType::LONGVARBINARY:
1835cdf0e10cSrcweir case DataType::TIME:
1836cdf0e10cSrcweir aValue = DBTypeConversion::toDate( (double)0 );
1837cdf0e10cSrcweir break;
1838cdf0e10cSrcweir }
1839cdf0e10cSrcweir }
1840cdf0e10cSrcweir return aValue;
1841cdf0e10cSrcweir }
1842cdf0e10cSrcweir // -----------------------------------------------------------------------------
getTime() const1843cdf0e10cSrcweir ::com::sun::star::util::Time ORowSetValue::getTime() const
1844cdf0e10cSrcweir {
1845cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getTime" );
1846cdf0e10cSrcweir ::com::sun::star::util::Time aValue;
1847cdf0e10cSrcweir if(!m_bNull)
1848cdf0e10cSrcweir {
1849cdf0e10cSrcweir switch(m_eTypeKind)
1850cdf0e10cSrcweir {
1851cdf0e10cSrcweir case DataType::CHAR:
1852cdf0e10cSrcweir case DataType::VARCHAR:
1853cdf0e10cSrcweir case DataType::LONGVARCHAR:
1854cdf0e10cSrcweir aValue = DBTypeConversion::toTime(getString());
1855cdf0e10cSrcweir break;
1856cdf0e10cSrcweir case DataType::DECIMAL:
1857cdf0e10cSrcweir case DataType::NUMERIC:
1858cdf0e10cSrcweir aValue = DBTypeConversion::toTime((double)*this);
1859cdf0e10cSrcweir break;
1860cdf0e10cSrcweir case DataType::FLOAT:
1861cdf0e10cSrcweir case DataType::DOUBLE:
1862cdf0e10cSrcweir case DataType::REAL:
1863cdf0e10cSrcweir aValue = DBTypeConversion::toTime((double)*this);
1864cdf0e10cSrcweir break;
1865cdf0e10cSrcweir case DataType::TIMESTAMP:
1866cdf0e10cSrcweir {
1867cdf0e10cSrcweir ::com::sun::star::util::DateTime* pDateTime = static_cast< ::com::sun::star::util::DateTime*>(m_aValue.m_pValue);
1868cdf0e10cSrcweir aValue.HundredthSeconds = pDateTime->HundredthSeconds;
1869cdf0e10cSrcweir aValue.Seconds = pDateTime->Seconds;
1870cdf0e10cSrcweir aValue.Minutes = pDateTime->Minutes;
1871cdf0e10cSrcweir aValue.Hours = pDateTime->Hours;
1872cdf0e10cSrcweir }
1873cdf0e10cSrcweir break;
1874cdf0e10cSrcweir case DataType::TIME:
1875cdf0e10cSrcweir aValue = *static_cast< ::com::sun::star::util::Time*>(m_aValue.m_pValue);
1876cdf0e10cSrcweir break;
1877cdf0e10cSrcweir default:
1878cdf0e10cSrcweir {
1879cdf0e10cSrcweir Any aAnyValue = getAny();
1880cdf0e10cSrcweir aAnyValue >>= aValue;
1881cdf0e10cSrcweir break;
1882cdf0e10cSrcweir }
1883cdf0e10cSrcweir }
1884cdf0e10cSrcweir }
1885cdf0e10cSrcweir return aValue;
1886cdf0e10cSrcweir }
1887cdf0e10cSrcweir // -----------------------------------------------------------------------------
getDateTime() const1888cdf0e10cSrcweir ::com::sun::star::util::DateTime ORowSetValue::getDateTime() const
1889cdf0e10cSrcweir {
1890cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::getDateTime" );
1891cdf0e10cSrcweir ::com::sun::star::util::DateTime aValue;
1892cdf0e10cSrcweir if(!m_bNull)
1893cdf0e10cSrcweir {
1894cdf0e10cSrcweir switch(m_eTypeKind)
1895cdf0e10cSrcweir {
1896cdf0e10cSrcweir case DataType::CHAR:
1897cdf0e10cSrcweir case DataType::VARCHAR:
1898cdf0e10cSrcweir case DataType::LONGVARCHAR:
1899cdf0e10cSrcweir aValue = DBTypeConversion::toDateTime(getString());
1900cdf0e10cSrcweir break;
1901cdf0e10cSrcweir case DataType::DECIMAL:
1902cdf0e10cSrcweir case DataType::NUMERIC:
1903cdf0e10cSrcweir aValue = DBTypeConversion::toDateTime((double)*this);
1904cdf0e10cSrcweir break;
1905cdf0e10cSrcweir case DataType::FLOAT:
1906cdf0e10cSrcweir case DataType::DOUBLE:
1907cdf0e10cSrcweir case DataType::REAL:
1908cdf0e10cSrcweir aValue = DBTypeConversion::toDateTime((double)*this);
1909cdf0e10cSrcweir break;
1910cdf0e10cSrcweir case DataType::DATE:
1911cdf0e10cSrcweir {
1912cdf0e10cSrcweir ::com::sun::star::util::Date* pDate = static_cast< ::com::sun::star::util::Date*>(m_aValue.m_pValue);
1913cdf0e10cSrcweir aValue.Day = pDate->Day;
1914cdf0e10cSrcweir aValue.Month = pDate->Month;
1915cdf0e10cSrcweir aValue.Year = pDate->Year;
1916cdf0e10cSrcweir }
1917cdf0e10cSrcweir break;
1918cdf0e10cSrcweir case DataType::TIME:
1919cdf0e10cSrcweir {
1920cdf0e10cSrcweir ::com::sun::star::util::Time* pTime = static_cast< ::com::sun::star::util::Time*>(m_aValue.m_pValue);
1921cdf0e10cSrcweir aValue.HundredthSeconds = pTime->HundredthSeconds;
1922cdf0e10cSrcweir aValue.Seconds = pTime->Seconds;
1923cdf0e10cSrcweir aValue.Minutes = pTime->Minutes;
1924cdf0e10cSrcweir aValue.Hours = pTime->Hours;
1925cdf0e10cSrcweir }
1926cdf0e10cSrcweir break;
1927cdf0e10cSrcweir case DataType::TIMESTAMP:
1928cdf0e10cSrcweir aValue = *static_cast< ::com::sun::star::util::DateTime*>(m_aValue.m_pValue);
1929cdf0e10cSrcweir break;
1930cdf0e10cSrcweir default:
1931cdf0e10cSrcweir {
1932cdf0e10cSrcweir Any aAnyValue = getAny();
1933cdf0e10cSrcweir aAnyValue >>= aValue;
1934cdf0e10cSrcweir break;
1935cdf0e10cSrcweir }
1936cdf0e10cSrcweir }
1937cdf0e10cSrcweir }
1938cdf0e10cSrcweir return aValue;
1939cdf0e10cSrcweir }
1940cdf0e10cSrcweir // -----------------------------------------------------------------------------
setSigned(sal_Bool _bMod)1941cdf0e10cSrcweir void ORowSetValue::setSigned(sal_Bool _bMod)
1942cdf0e10cSrcweir {
1943cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::setSigned" );
1944cdf0e10cSrcweir if ( m_bSigned != _bMod )
1945cdf0e10cSrcweir {
1946cdf0e10cSrcweir m_bSigned = _bMod;
1947cdf0e10cSrcweir if ( !m_bNull )
1948cdf0e10cSrcweir {
1949cdf0e10cSrcweir sal_Int32 nType = m_eTypeKind;
1950cdf0e10cSrcweir switch(m_eTypeKind)
1951cdf0e10cSrcweir {
1952cdf0e10cSrcweir case DataType::BIGINT:
1953cdf0e10cSrcweir if ( m_bSigned ) // now we are signed, so we were unsigned and need to call getString()
1954cdf0e10cSrcweir {
1955cdf0e10cSrcweir m_bSigned = !m_bSigned;
1956cdf0e10cSrcweir const ::rtl::OUString sValue = getString();
1957cdf0e10cSrcweir free();
1958cdf0e10cSrcweir m_bSigned = !m_bSigned;
1959cdf0e10cSrcweir (*this) = sValue;
1960cdf0e10cSrcweir }
1961cdf0e10cSrcweir else
1962cdf0e10cSrcweir {
1963cdf0e10cSrcweir m_bSigned = !m_bSigned;
1964cdf0e10cSrcweir const sal_Int64 nValue = getLong();
1965cdf0e10cSrcweir free();
1966cdf0e10cSrcweir m_bSigned = !m_bSigned;
1967cdf0e10cSrcweir (*this) = nValue;
1968cdf0e10cSrcweir }
1969cdf0e10cSrcweir break;
1970cdf0e10cSrcweir case DataType::TINYINT:
1971cdf0e10cSrcweir if ( m_bSigned )
1972cdf0e10cSrcweir (*this) = getInt8();
1973cdf0e10cSrcweir else
1974cdf0e10cSrcweir {
1975cdf0e10cSrcweir m_bSigned = !m_bSigned;
1976cdf0e10cSrcweir (*this) = getInt16();
1977cdf0e10cSrcweir m_bSigned = !m_bSigned;
1978cdf0e10cSrcweir }
1979cdf0e10cSrcweir break;
1980cdf0e10cSrcweir case DataType::SMALLINT:
1981cdf0e10cSrcweir if ( m_bSigned )
1982cdf0e10cSrcweir (*this) = getInt16();
1983cdf0e10cSrcweir else
1984cdf0e10cSrcweir {
1985cdf0e10cSrcweir m_bSigned = !m_bSigned;
1986cdf0e10cSrcweir (*this) = getInt32();
1987cdf0e10cSrcweir m_bSigned = !m_bSigned;
1988cdf0e10cSrcweir }
1989cdf0e10cSrcweir break;
1990cdf0e10cSrcweir case DataType::INTEGER:
1991cdf0e10cSrcweir if ( m_bSigned )
1992cdf0e10cSrcweir (*this) = getInt32();
1993cdf0e10cSrcweir else
1994cdf0e10cSrcweir {
1995cdf0e10cSrcweir m_bSigned = !m_bSigned;
1996cdf0e10cSrcweir (*this) = getLong();
1997cdf0e10cSrcweir m_bSigned = !m_bSigned;
1998cdf0e10cSrcweir }
1999cdf0e10cSrcweir break;
2000cdf0e10cSrcweir }
2001cdf0e10cSrcweir m_eTypeKind = nType;
2002cdf0e10cSrcweir }
2003cdf0e10cSrcweir }
2004cdf0e10cSrcweir }
2005cdf0e10cSrcweir
2006cdf0e10cSrcweir // -----------------------------------------------------------------------------
2007cdf0e10cSrcweir namespace detail
2008cdf0e10cSrcweir {
2009cdf0e10cSrcweir class SAL_NO_VTABLE IValueSource
2010cdf0e10cSrcweir {
2011cdf0e10cSrcweir public:
2012cdf0e10cSrcweir virtual ::rtl::OUString getString() const = 0;
2013cdf0e10cSrcweir virtual sal_Bool getBoolean() const = 0;
2014cdf0e10cSrcweir virtual sal_Int8 getByte() const = 0;
2015cdf0e10cSrcweir virtual sal_Int16 getShort() const = 0;
2016cdf0e10cSrcweir virtual sal_Int32 getInt() const = 0;
2017cdf0e10cSrcweir virtual sal_Int64 getLong() const = 0;
2018cdf0e10cSrcweir virtual float getFloat() const = 0;
2019cdf0e10cSrcweir virtual double getDouble() const = 0;
2020cdf0e10cSrcweir virtual Date getDate() const = 0;
2021cdf0e10cSrcweir virtual Time getTime() const = 0;
2022cdf0e10cSrcweir virtual DateTime getTimestamp() const = 0;
2023cdf0e10cSrcweir virtual Sequence< sal_Int8 > getBytes() const = 0;
2024cdf0e10cSrcweir virtual Reference< XInputStream > getBinaryStream() const = 0;
2025cdf0e10cSrcweir virtual Reference< XInputStream > getCharacterStream() const = 0;
2026cdf0e10cSrcweir virtual Reference< XBlob > getBlob() const = 0;
2027cdf0e10cSrcweir virtual Reference< XClob > getClob() const = 0;
2028cdf0e10cSrcweir virtual Any getObject() const = 0;
2029cdf0e10cSrcweir virtual sal_Bool wasNull() const = 0;
2030cdf0e10cSrcweir
~IValueSource()2031cdf0e10cSrcweir virtual ~IValueSource() { }
2032cdf0e10cSrcweir };
2033cdf0e10cSrcweir
2034cdf0e10cSrcweir class RowValue : public IValueSource
2035cdf0e10cSrcweir {
2036cdf0e10cSrcweir public:
RowValue(const Reference<XRow> & _xRow,const sal_Int32 _nPos)2037cdf0e10cSrcweir RowValue( const Reference< XRow >& _xRow, const sal_Int32 _nPos )
2038cdf0e10cSrcweir :m_xRow( _xRow )
2039cdf0e10cSrcweir ,m_nPos( _nPos )
2040cdf0e10cSrcweir {
2041cdf0e10cSrcweir }
2042cdf0e10cSrcweir
2043cdf0e10cSrcweir // IValueSource
getString() const2044cdf0e10cSrcweir virtual ::rtl::OUString getString() const { return m_xRow->getString( m_nPos ); };
getBoolean() const2045cdf0e10cSrcweir virtual sal_Bool getBoolean() const { return m_xRow->getBoolean( m_nPos ); };
getByte() const2046cdf0e10cSrcweir virtual sal_Int8 getByte() const { return m_xRow->getByte( m_nPos ); };
getShort() const2047cdf0e10cSrcweir virtual sal_Int16 getShort() const { return m_xRow->getShort( m_nPos ); }
getInt() const2048cdf0e10cSrcweir virtual sal_Int32 getInt() const { return m_xRow->getInt( m_nPos ); }
getLong() const2049cdf0e10cSrcweir virtual sal_Int64 getLong() const { return m_xRow->getLong( m_nPos ); }
getFloat() const2050cdf0e10cSrcweir virtual float getFloat() const { return m_xRow->getFloat( m_nPos ); };
getDouble() const2051cdf0e10cSrcweir virtual double getDouble() const { return m_xRow->getDouble( m_nPos ); };
getDate() const2052cdf0e10cSrcweir virtual Date getDate() const { return m_xRow->getDate( m_nPos ); };
getTime() const2053cdf0e10cSrcweir virtual Time getTime() const { return m_xRow->getTime( m_nPos ); };
getTimestamp() const2054cdf0e10cSrcweir virtual DateTime getTimestamp() const { return m_xRow->getTimestamp( m_nPos ); };
getBytes() const2055cdf0e10cSrcweir virtual Sequence< sal_Int8 > getBytes() const { return m_xRow->getBytes( m_nPos ); };
getBinaryStream() const2056cdf0e10cSrcweir virtual Reference< XInputStream > getBinaryStream() const { return m_xRow->getBinaryStream( m_nPos ); };
getCharacterStream() const2057cdf0e10cSrcweir virtual Reference< XInputStream > getCharacterStream() const { return m_xRow->getCharacterStream( m_nPos ); };
getBlob() const2058cdf0e10cSrcweir virtual Reference< XBlob > getBlob() const { return m_xRow->getBlob( m_nPos ); };
getClob() const2059cdf0e10cSrcweir virtual Reference< XClob > getClob() const { return m_xRow->getClob( m_nPos ); };
getObject() const2060cdf0e10cSrcweir virtual Any getObject() const { return m_xRow->getObject( m_nPos ,NULL); };
wasNull() const2061cdf0e10cSrcweir virtual sal_Bool wasNull() const { return m_xRow->wasNull( ); };
2062cdf0e10cSrcweir
2063cdf0e10cSrcweir private:
2064cdf0e10cSrcweir const Reference< XRow > m_xRow;
2065cdf0e10cSrcweir const sal_Int32 m_nPos;
2066cdf0e10cSrcweir };
2067cdf0e10cSrcweir
2068cdf0e10cSrcweir class ColumnValue : public IValueSource
2069cdf0e10cSrcweir {
2070cdf0e10cSrcweir public:
ColumnValue(const Reference<XColumn> & _rxColumn)2071cdf0e10cSrcweir ColumnValue( const Reference< XColumn >& _rxColumn )
2072cdf0e10cSrcweir :m_xColumn( _rxColumn )
2073cdf0e10cSrcweir {
2074cdf0e10cSrcweir }
2075cdf0e10cSrcweir
2076cdf0e10cSrcweir // IValueSource
getString() const2077cdf0e10cSrcweir virtual ::rtl::OUString getString() const { return m_xColumn->getString(); };
getBoolean() const2078cdf0e10cSrcweir virtual sal_Bool getBoolean() const { return m_xColumn->getBoolean(); };
getByte() const2079cdf0e10cSrcweir virtual sal_Int8 getByte() const { return m_xColumn->getByte(); };
getShort() const2080cdf0e10cSrcweir virtual sal_Int16 getShort() const { return m_xColumn->getShort(); }
getInt() const2081cdf0e10cSrcweir virtual sal_Int32 getInt() const { return m_xColumn->getInt(); }
getLong() const2082cdf0e10cSrcweir virtual sal_Int64 getLong() const { return m_xColumn->getLong(); }
getFloat() const2083cdf0e10cSrcweir virtual float getFloat() const { return m_xColumn->getFloat(); };
getDouble() const2084cdf0e10cSrcweir virtual double getDouble() const { return m_xColumn->getDouble(); };
getDate() const2085cdf0e10cSrcweir virtual Date getDate() const { return m_xColumn->getDate(); };
getTime() const2086cdf0e10cSrcweir virtual Time getTime() const { return m_xColumn->getTime(); };
getTimestamp() const2087cdf0e10cSrcweir virtual DateTime getTimestamp() const { return m_xColumn->getTimestamp(); };
getBytes() const2088cdf0e10cSrcweir virtual Sequence< sal_Int8 > getBytes() const { return m_xColumn->getBytes(); };
getBinaryStream() const2089cdf0e10cSrcweir virtual Reference< XInputStream > getBinaryStream() const { return m_xColumn->getBinaryStream(); };
getCharacterStream() const2090cdf0e10cSrcweir virtual Reference< XInputStream > getCharacterStream() const { return m_xColumn->getCharacterStream(); };
getBlob() const2091cdf0e10cSrcweir virtual Reference< XBlob > getBlob() const { return m_xColumn->getBlob(); };
getClob() const2092cdf0e10cSrcweir virtual Reference< XClob > getClob() const { return m_xColumn->getClob(); };
getObject() const2093cdf0e10cSrcweir virtual Any getObject() const { return m_xColumn->getObject( NULL ); };
wasNull() const2094cdf0e10cSrcweir virtual sal_Bool wasNull() const { return m_xColumn->wasNull( ); };
2095cdf0e10cSrcweir
2096cdf0e10cSrcweir private:
2097cdf0e10cSrcweir const Reference< XColumn > m_xColumn;
2098cdf0e10cSrcweir };
2099cdf0e10cSrcweir }
2100cdf0e10cSrcweir
2101cdf0e10cSrcweir // -----------------------------------------------------------------------------
fill(const sal_Int32 _nType,const Reference<XColumn> & _rxColumn)2102cdf0e10cSrcweir void ORowSetValue::fill( const sal_Int32 _nType, const Reference< XColumn >& _rxColumn )
2103cdf0e10cSrcweir {
2104cdf0e10cSrcweir detail::ColumnValue aColumnValue( _rxColumn );
2105cdf0e10cSrcweir impl_fill( _nType, sal_True, aColumnValue );
2106cdf0e10cSrcweir }
2107cdf0e10cSrcweir
2108cdf0e10cSrcweir // -----------------------------------------------------------------------------
fill(sal_Int32 _nPos,sal_Int32 _nType,sal_Bool _bNullable,const Reference<XRow> & _xRow)2109cdf0e10cSrcweir void ORowSetValue::fill( sal_Int32 _nPos, sal_Int32 _nType, sal_Bool _bNullable, const Reference< XRow>& _xRow )
2110cdf0e10cSrcweir {
2111cdf0e10cSrcweir detail::RowValue aRowValue( _xRow, _nPos );
2112cdf0e10cSrcweir impl_fill( _nType, _bNullable, aRowValue );
2113cdf0e10cSrcweir }
2114cdf0e10cSrcweir
2115cdf0e10cSrcweir // -----------------------------------------------------------------------------
fill(sal_Int32 _nPos,sal_Int32 _nType,const::com::sun::star::uno::Reference<::com::sun::star::sdbc::XRow> & _xRow)2116cdf0e10cSrcweir void ORowSetValue::fill(sal_Int32 _nPos,
2117cdf0e10cSrcweir sal_Int32 _nType,
2118cdf0e10cSrcweir const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XRow>& _xRow)
2119cdf0e10cSrcweir {
2120cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::fill (1)" );
2121cdf0e10cSrcweir fill(_nPos,_nType,sal_True,_xRow);
2122cdf0e10cSrcweir }
2123cdf0e10cSrcweir
2124cdf0e10cSrcweir // -----------------------------------------------------------------------------
impl_fill(const sal_Int32 _nType,sal_Bool _bNullable,const detail::IValueSource & _rValueSource)2125cdf0e10cSrcweir void ORowSetValue::impl_fill( const sal_Int32 _nType, sal_Bool _bNullable, const detail::IValueSource& _rValueSource )
2126cdf0e10cSrcweir
2127cdf0e10cSrcweir {
2128cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::fill (2)" );
2129cdf0e10cSrcweir sal_Bool bReadData = sal_True;
2130cdf0e10cSrcweir switch(_nType)
2131cdf0e10cSrcweir {
2132cdf0e10cSrcweir case DataType::CHAR:
2133cdf0e10cSrcweir case DataType::VARCHAR:
2134cdf0e10cSrcweir case DataType::DECIMAL:
2135cdf0e10cSrcweir case DataType::NUMERIC:
2136cdf0e10cSrcweir case DataType::LONGVARCHAR:
2137cdf0e10cSrcweir (*this) = _rValueSource.getString();
2138cdf0e10cSrcweir break;
2139cdf0e10cSrcweir case DataType::BIGINT:
2140cdf0e10cSrcweir if ( isSigned() )
2141cdf0e10cSrcweir (*this) = _rValueSource.getLong();
2142cdf0e10cSrcweir else
2143cdf0e10cSrcweir (*this) = _rValueSource.getString();
2144cdf0e10cSrcweir break;
2145cdf0e10cSrcweir case DataType::FLOAT:
2146cdf0e10cSrcweir (*this) = _rValueSource.getFloat();
2147cdf0e10cSrcweir break;
2148cdf0e10cSrcweir case DataType::DOUBLE:
2149cdf0e10cSrcweir case DataType::REAL:
2150cdf0e10cSrcweir (*this) = _rValueSource.getDouble();
2151cdf0e10cSrcweir break;
2152cdf0e10cSrcweir case DataType::DATE:
2153cdf0e10cSrcweir (*this) = _rValueSource.getDate();
2154cdf0e10cSrcweir break;
2155cdf0e10cSrcweir case DataType::TIME:
2156cdf0e10cSrcweir (*this) = _rValueSource.getTime();
2157cdf0e10cSrcweir break;
2158cdf0e10cSrcweir case DataType::TIMESTAMP:
2159cdf0e10cSrcweir (*this) = _rValueSource.getTimestamp();
2160cdf0e10cSrcweir break;
2161cdf0e10cSrcweir case DataType::BINARY:
2162cdf0e10cSrcweir case DataType::VARBINARY:
2163cdf0e10cSrcweir case DataType::LONGVARBINARY:
2164cdf0e10cSrcweir (*this) = _rValueSource.getBytes();
2165cdf0e10cSrcweir break;
2166cdf0e10cSrcweir case DataType::BIT:
2167cdf0e10cSrcweir case DataType::BOOLEAN:
2168cdf0e10cSrcweir (*this) = _rValueSource.getBoolean();
2169cdf0e10cSrcweir break;
2170cdf0e10cSrcweir case DataType::TINYINT:
2171cdf0e10cSrcweir if ( isSigned() )
2172cdf0e10cSrcweir (*this) = _rValueSource.getByte();
2173cdf0e10cSrcweir else
2174cdf0e10cSrcweir (*this) = _rValueSource.getShort();
2175cdf0e10cSrcweir break;
2176cdf0e10cSrcweir case DataType::SMALLINT:
2177cdf0e10cSrcweir if ( isSigned() )
2178cdf0e10cSrcweir (*this) = _rValueSource.getShort();
2179cdf0e10cSrcweir else
2180cdf0e10cSrcweir (*this) = _rValueSource.getInt();
2181cdf0e10cSrcweir break;
2182cdf0e10cSrcweir case DataType::INTEGER:
2183cdf0e10cSrcweir if ( isSigned() )
2184cdf0e10cSrcweir (*this) = _rValueSource.getInt();
2185cdf0e10cSrcweir else
2186cdf0e10cSrcweir (*this) = _rValueSource.getLong();
2187cdf0e10cSrcweir break;
2188cdf0e10cSrcweir case DataType::CLOB:
2189cdf0e10cSrcweir (*this) = ::com::sun::star::uno::makeAny(_rValueSource.getClob());
2190cdf0e10cSrcweir setTypeKind(DataType::CLOB);
2191cdf0e10cSrcweir break;
2192cdf0e10cSrcweir case DataType::BLOB:
2193cdf0e10cSrcweir (*this) = ::com::sun::star::uno::makeAny(_rValueSource.getBlob());
2194cdf0e10cSrcweir setTypeKind(DataType::BLOB);
2195cdf0e10cSrcweir break;
2196cdf0e10cSrcweir case DataType::OTHER:
2197cdf0e10cSrcweir (*this) = _rValueSource.getObject();
2198cdf0e10cSrcweir setTypeKind(DataType::OTHER);
2199cdf0e10cSrcweir break;
2200cdf0e10cSrcweir default:
2201cdf0e10cSrcweir OSL_ENSURE( false, "ORowSetValue::fill: unsupported type!" );
2202cdf0e10cSrcweir (*this) = _rValueSource.getObject();
2203cdf0e10cSrcweir break;
2204cdf0e10cSrcweir }
2205cdf0e10cSrcweir if ( bReadData && _bNullable && _rValueSource.wasNull() )
2206cdf0e10cSrcweir setNull();
2207cdf0e10cSrcweir setTypeKind(_nType);
2208cdf0e10cSrcweir }
2209cdf0e10cSrcweir // -----------------------------------------------------------------------------
fill(const Any & _rValue)2210cdf0e10cSrcweir void ORowSetValue::fill(const Any& _rValue)
2211cdf0e10cSrcweir {
2212cdf0e10cSrcweir RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbtools", "Ocke.Janssen@sun.com", "ORowSetValue::fill (3)" );
2213cdf0e10cSrcweir switch (_rValue.getValueType().getTypeClass())
2214cdf0e10cSrcweir {
2215cdf0e10cSrcweir case TypeClass_VOID:
2216cdf0e10cSrcweir setNull();
2217cdf0e10cSrcweir break;
2218cdf0e10cSrcweir case TypeClass_BOOLEAN:
2219cdf0e10cSrcweir {
2220cdf0e10cSrcweir sal_Bool bValue( sal_False );
2221cdf0e10cSrcweir _rValue >>= bValue;
2222cdf0e10cSrcweir (*this) = bValue;
2223cdf0e10cSrcweir break;
2224cdf0e10cSrcweir }
2225cdf0e10cSrcweir case TypeClass_CHAR:
2226cdf0e10cSrcweir {
2227cdf0e10cSrcweir sal_Unicode aDummy(0);
2228cdf0e10cSrcweir _rValue >>= aDummy;
2229cdf0e10cSrcweir (*this) = ::rtl::OUString(aDummy);
2230cdf0e10cSrcweir break;
2231cdf0e10cSrcweir }
2232cdf0e10cSrcweir case TypeClass_STRING:
2233cdf0e10cSrcweir {
2234cdf0e10cSrcweir ::rtl::OUString sDummy;
2235cdf0e10cSrcweir _rValue >>= sDummy;
2236cdf0e10cSrcweir (*this) = sDummy;
2237cdf0e10cSrcweir break;
2238cdf0e10cSrcweir }
2239cdf0e10cSrcweir case TypeClass_FLOAT:
2240cdf0e10cSrcweir {
2241cdf0e10cSrcweir float aDummy(0.0);
2242cdf0e10cSrcweir _rValue >>= aDummy;
2243cdf0e10cSrcweir (*this) = aDummy;
2244cdf0e10cSrcweir break;
2245cdf0e10cSrcweir }
2246cdf0e10cSrcweir case TypeClass_DOUBLE:
2247cdf0e10cSrcweir {
2248cdf0e10cSrcweir double aDummy(0.0);
2249cdf0e10cSrcweir _rValue >>= aDummy;
2250cdf0e10cSrcweir (*this) = aDummy;
2251cdf0e10cSrcweir break;
2252cdf0e10cSrcweir }
2253cdf0e10cSrcweir case TypeClass_BYTE:
2254cdf0e10cSrcweir {
2255cdf0e10cSrcweir sal_Int8 aDummy(0);
2256cdf0e10cSrcweir _rValue >>= aDummy;
2257cdf0e10cSrcweir (*this) = aDummy;
2258cdf0e10cSrcweir break;
2259cdf0e10cSrcweir }
2260cdf0e10cSrcweir case TypeClass_SHORT:
2261cdf0e10cSrcweir {
2262cdf0e10cSrcweir sal_Int16 aDummy(0);
2263cdf0e10cSrcweir _rValue >>= aDummy;
2264cdf0e10cSrcweir (*this) = aDummy;
2265cdf0e10cSrcweir break;
2266cdf0e10cSrcweir }
2267cdf0e10cSrcweir case TypeClass_LONG:
2268cdf0e10cSrcweir {
2269cdf0e10cSrcweir sal_Int32 aDummy(0);
2270cdf0e10cSrcweir _rValue >>= aDummy;
2271cdf0e10cSrcweir (*this) = aDummy;
2272cdf0e10cSrcweir break;
2273cdf0e10cSrcweir }
2274cdf0e10cSrcweir case TypeClass_UNSIGNED_SHORT:
2275cdf0e10cSrcweir {
2276cdf0e10cSrcweir sal_uInt16 nValue(0);
2277cdf0e10cSrcweir _rValue >>= nValue;
2278cdf0e10cSrcweir (*this) = static_cast<sal_Int32>(nValue);
2279cdf0e10cSrcweir setSigned(sal_False);
2280cdf0e10cSrcweir break;
2281cdf0e10cSrcweir }
2282cdf0e10cSrcweir case TypeClass_HYPER:
2283cdf0e10cSrcweir {
2284cdf0e10cSrcweir sal_Int64 nValue(0);
2285cdf0e10cSrcweir _rValue >>= nValue;
2286cdf0e10cSrcweir (*this) = nValue;
2287cdf0e10cSrcweir break;
2288cdf0e10cSrcweir }
2289cdf0e10cSrcweir case TypeClass_UNSIGNED_HYPER:
2290cdf0e10cSrcweir {
2291cdf0e10cSrcweir sal_uInt64 nValue(0);
2292cdf0e10cSrcweir _rValue >>= nValue;
2293cdf0e10cSrcweir (*this) = static_cast<sal_Int64>(nValue);
2294cdf0e10cSrcweir setSigned(sal_False);
2295cdf0e10cSrcweir break;
2296cdf0e10cSrcweir }
2297cdf0e10cSrcweir case TypeClass_UNSIGNED_LONG:
2298cdf0e10cSrcweir {
2299cdf0e10cSrcweir sal_uInt32 nValue(0);
2300cdf0e10cSrcweir _rValue >>= nValue;
2301cdf0e10cSrcweir (*this) = static_cast<sal_Int64>(nValue);
2302cdf0e10cSrcweir setSigned(sal_False);
2303cdf0e10cSrcweir break;
2304cdf0e10cSrcweir }
2305cdf0e10cSrcweir case TypeClass_ENUM:
2306cdf0e10cSrcweir {
2307cdf0e10cSrcweir sal_Int32 enumValue( 0 );
2308cdf0e10cSrcweir ::cppu::enum2int( enumValue, _rValue );
2309cdf0e10cSrcweir (*this) = enumValue;
2310cdf0e10cSrcweir }
2311cdf0e10cSrcweir break;
2312cdf0e10cSrcweir
2313cdf0e10cSrcweir case TypeClass_SEQUENCE:
2314cdf0e10cSrcweir {
2315cdf0e10cSrcweir Sequence<sal_Int8> aDummy;
2316cdf0e10cSrcweir if ( _rValue >>= aDummy )
2317cdf0e10cSrcweir (*this) = aDummy;
2318cdf0e10cSrcweir else
2319cdf0e10cSrcweir OSL_ENSURE( false, "ORowSetValue::fill: unsupported sequence type!" );
2320cdf0e10cSrcweir break;
2321cdf0e10cSrcweir }
2322cdf0e10cSrcweir
2323cdf0e10cSrcweir case TypeClass_STRUCT:
2324cdf0e10cSrcweir {
2325cdf0e10cSrcweir ::com::sun::star::util::Date aDate;
2326cdf0e10cSrcweir ::com::sun::star::util::Time aTime;
2327cdf0e10cSrcweir ::com::sun::star::util::DateTime aDateTime;
2328cdf0e10cSrcweir if ( _rValue >>= aDate )
2329cdf0e10cSrcweir {
2330cdf0e10cSrcweir (*this) = aDate;
2331cdf0e10cSrcweir }
2332cdf0e10cSrcweir else if ( _rValue >>= aTime )
2333cdf0e10cSrcweir {
2334cdf0e10cSrcweir (*this) = aTime;
2335cdf0e10cSrcweir }
2336cdf0e10cSrcweir else if ( _rValue >>= aDateTime )
2337cdf0e10cSrcweir {
2338cdf0e10cSrcweir (*this) = aDateTime;
2339cdf0e10cSrcweir }
2340cdf0e10cSrcweir else
2341cdf0e10cSrcweir OSL_ENSURE( false, "ORowSetValue::fill: unsupported structure!" );
2342cdf0e10cSrcweir
2343cdf0e10cSrcweir break;
2344cdf0e10cSrcweir }
2345cdf0e10cSrcweir case TypeClass_INTERFACE:
2346cdf0e10cSrcweir {
2347cdf0e10cSrcweir Reference< XClob > xClob;
2348cdf0e10cSrcweir if ( _rValue >>= xClob )
2349cdf0e10cSrcweir {
2350cdf0e10cSrcweir (*this) = _rValue;
2351cdf0e10cSrcweir setTypeKind(DataType::CLOB);
2352cdf0e10cSrcweir }
2353cdf0e10cSrcweir else
2354cdf0e10cSrcweir {
2355cdf0e10cSrcweir Reference< XBlob > xBlob;
2356cdf0e10cSrcweir if ( _rValue >>= xBlob )
2357cdf0e10cSrcweir {
2358cdf0e10cSrcweir (*this) = _rValue;
2359cdf0e10cSrcweir setTypeKind(DataType::BLOB);
2360cdf0e10cSrcweir }
2361cdf0e10cSrcweir else
2362cdf0e10cSrcweir {
2363cdf0e10cSrcweir (*this) = _rValue;
2364cdf0e10cSrcweir }
2365cdf0e10cSrcweir }
2366cdf0e10cSrcweir }
2367cdf0e10cSrcweir break;
2368cdf0e10cSrcweir
2369cdf0e10cSrcweir default:
2370cdf0e10cSrcweir OSL_ENSURE(0,"Unknown type");
2371cdf0e10cSrcweir break;
2372cdf0e10cSrcweir }
2373cdf0e10cSrcweir }
2374cdf0e10cSrcweir
2375cdf0e10cSrcweir } // namespace connectivity
2376