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