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