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