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