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_ado.hxx" 26 #include <comphelper/sequence.hxx> 27 #include "ado/ADatabaseMetaDataResultSet.hxx" 28 #include "ado/ADatabaseMetaDataResultSetMetaData.hxx" 29 #include <com/sun/star/sdbc/DataType.hpp> 30 #include <com/sun/star/sdbc/ColumnValue.hpp> 31 #include <com/sun/star/sdbc/KeyRule.hpp> 32 #include <com/sun/star/sdbc/ProcedureResult.hpp> 33 #include <com/sun/star/sdbc/IndexType.hpp> 34 #include <comphelper/property.hxx> 35 #include <com/sun/star/lang/DisposedException.hpp> 36 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp> 37 #include <com/sun/star/sdbc/ResultSetType.hpp> 38 #include <com/sun/star/sdbc/FetchDirection.hpp> 39 #include <cppuhelper/typeprovider.hxx> 40 #include <comphelper/seqstream.hxx> 41 #include "connectivity/dbexception.hxx" 42 43 44 #include <oledb.h> 45 46 using namespace dbtools; 47 using namespace connectivity::ado; 48 using namespace cppu; 49 using namespace ::comphelper; 50 //------------------------------------------------------------------------------ 51 using namespace ::com::sun::star::lang; 52 using namespace com::sun::star::uno; 53 using namespace com::sun::star::lang; 54 using namespace com::sun::star::beans; 55 using namespace com::sun::star::sdbc; 56 57 // ------------------------------------------------------------------------- 58 ODatabaseMetaDataResultSet::ODatabaseMetaDataResultSet(ADORecordset* _pRecordSet) 59 :ODatabaseMetaDataResultSet_BASE(m_aMutex) 60 ,OPropertySetHelper(ODatabaseMetaDataResultSet_BASE::rBHelper) 61 ,m_aStatement(NULL) 62 ,m_xMetaData(NULL) 63 ,m_pRecordSet(_pRecordSet) 64 ,m_bEOF(sal_False) 65 { 66 osl_incrementInterlockedCount( &m_refCount ); 67 m_aColMapping.push_back(-1); 68 if(_pRecordSet) 69 { 70 m_pRecordSet->AddRef(); 71 VARIANT_BOOL bIsAtBOF; 72 m_pRecordSet->get_BOF(&bIsAtBOF); 73 m_bOnFirstAfterOpen = bIsAtBOF != VARIANT_TRUE; 74 } 75 else 76 m_bOnFirstAfterOpen = sal_False; 77 osl_decrementInterlockedCount( &m_refCount ); 78 // allocBuffer(); 79 } 80 81 // ------------------------------------------------------------------------- 82 ODatabaseMetaDataResultSet::~ODatabaseMetaDataResultSet() 83 { 84 if(m_pRecordSet) 85 m_pRecordSet->Release(); 86 } 87 // ------------------------------------------------------------------------- 88 void ODatabaseMetaDataResultSet::disposing(void) 89 { 90 OPropertySetHelper::disposing(); 91 92 ::osl::MutexGuard aGuard(m_aMutex); 93 if(m_pRecordSet) 94 m_pRecordSet->Close(); 95 m_aStatement = NULL; 96 m_xMetaData.clear(); 97 } 98 // ------------------------------------------------------------------------- 99 Any SAL_CALL ODatabaseMetaDataResultSet::queryInterface( const Type & rType ) 100 { 101 Any aRet = OPropertySetHelper::queryInterface(rType); 102 return aRet.hasValue() ? aRet : ODatabaseMetaDataResultSet_BASE::queryInterface(rType); 103 } 104 // ------------------------------------------------------------------------- 105 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL ODatabaseMetaDataResultSet::getTypes( ) 106 { 107 ::cppu::OTypeCollection aTypes( ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XMultiPropertySet > *)0 ), 108 ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XFastPropertySet > *)0 ), 109 ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > *)0 )); 110 111 return ::comphelper::concatSequences(aTypes.getTypes(),ODatabaseMetaDataResultSet_BASE::getTypes()); 112 } 113 // ----------------------------------------------------------------------------- 114 void ODatabaseMetaDataResultSet::checkRecordSet() 115 { 116 if(!m_pRecordSet) 117 throwFunctionSequenceException(*this); 118 } 119 // ------------------------------------------------------------------------- 120 121 sal_Int32 SAL_CALL ODatabaseMetaDataResultSet::findColumn( const ::rtl::OUString& columnName ) 122 { 123 ::osl::MutexGuard aGuard( m_aMutex ); 124 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed ); 125 126 127 Reference< XResultSetMetaData > xMeta = getMetaData(); 128 sal_Int32 nLen = xMeta->getColumnCount(); 129 sal_Int32 i = 1; 130 for(;i<=nLen;++i) 131 if(xMeta->isCaseSensitive(i) ? columnName == xMeta->getColumnName(i) : 132 columnName.equalsIgnoreAsciiCase(xMeta->getColumnName(i))) 133 break; 134 return i; 135 } 136 #define BLOCK_SIZE 256 137 // ------------------------------------------------------------------------- 138 Reference< ::com::sun::star::io::XInputStream > SAL_CALL ODatabaseMetaDataResultSet::getBinaryStream( sal_Int32 columnIndex ) 139 { 140 ::osl::MutexGuard aGuard( m_aMutex ); 141 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 142 143 checkRecordSet(); 144 145 146 columnIndex = mapColumn(columnIndex); 147 WpADOField aField = ADOS::getField(m_pRecordSet,columnIndex); 148 if((aField.GetAttributes() & adFldLong) == adFldLong) 149 { 150 //Copy the data only up to the Actual Size of Field. 151 sal_Int32 nSize = aField.GetActualSize(); 152 Sequence<sal_Int8> aData(nSize); 153 long index = 0; 154 while(index < nSize) 155 { 156 m_aValue = aField.GetChunk(BLOCK_SIZE); 157 if(m_aValue.isNull()) 158 break; 159 UCHAR chData; 160 for(long index2 = 0;index2 < BLOCK_SIZE;++index2) 161 { 162 HRESULT hr = ::SafeArrayGetElement(m_aValue.parray,&index2,&chData); 163 if(SUCCEEDED(hr)) 164 { 165 //Take BYTE by BYTE and advance Memory Location 166 aData.getArray()[index++] = chData; 167 } 168 else 169 break; 170 } 171 } 172 return index ? Reference< ::com::sun::star::io::XInputStream >(new SequenceInputStream(aData)) : Reference< ::com::sun::star::io::XInputStream >(); 173 } 174 // else we ask for a bytesequence 175 aField.get_Value(m_aValue); 176 if(m_aValue.isNull()) 177 return NULL; 178 return new SequenceInputStream(m_aValue); 179 } 180 // ------------------------------------------------------------------------- 181 Reference< ::com::sun::star::io::XInputStream > SAL_CALL ODatabaseMetaDataResultSet::getCharacterStream( sal_Int32 /*columnIndex*/ ) 182 { 183 ::dbtools::throwFeatureNotImplementedException( "XRow::getCharacterStream", *this ); 184 return NULL; 185 } 186 187 // ------------------------------------------------------------------------- 188 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::getBoolean( sal_Int32 columnIndex ) 189 { 190 ::osl::MutexGuard aGuard( m_aMutex ); 191 192 if ( !m_aValueRange.empty() && columnIndex == 11 && (m_aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end() ) 193 { 194 getValue(2); 195 if ( static_cast<sal_Int16>(m_aValue) != adCurrency ) 196 return sal_False; 197 } 198 return getValue(columnIndex); 199 } 200 // ------------------------------------------------------------------------- 201 202 sal_Int8 SAL_CALL ODatabaseMetaDataResultSet::getByte( sal_Int32 columnIndex ) 203 { 204 ::osl::MutexGuard aGuard( m_aMutex ); 205 206 getValue(columnIndex); 207 208 columnIndex = mapColumn(columnIndex); 209 210 if(m_aValue.isNull()) 211 return 0; 212 if ( !m_aValueRange.empty() && (m_aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end()) 213 return (sal_Int8)(*m_aValueRangeIter).second[(sal_Int32)m_aValue]; 214 else if(m_aStrValueRange.size() && (m_aStrValueRangeIter = m_aStrValueRange.find(columnIndex)) != m_aStrValueRange.end()) 215 return (sal_Int8)(*m_aStrValueRangeIter).second[m_aValue]; 216 217 return m_aValue; 218 } 219 // ------------------------------------------------------------------------- 220 221 Sequence< sal_Int8 > SAL_CALL ODatabaseMetaDataResultSet::getBytes( sal_Int32 columnIndex ) 222 { 223 return getValue(columnIndex); 224 } 225 // ------------------------------------------------------------------------- 226 227 ::com::sun::star::util::Date SAL_CALL ODatabaseMetaDataResultSet::getDate( sal_Int32 columnIndex ) 228 { 229 return getValue(columnIndex); 230 } 231 // ------------------------------------------------------------------------- 232 233 double SAL_CALL ODatabaseMetaDataResultSet::getDouble( sal_Int32 columnIndex ) 234 { 235 return getValue(columnIndex); 236 } 237 // ------------------------------------------------------------------------- 238 239 float SAL_CALL ODatabaseMetaDataResultSet::getFloat( sal_Int32 columnIndex ) 240 { 241 return getValue(columnIndex); 242 } 243 // ------------------------------------------------------------------------- 244 245 sal_Int32 SAL_CALL ODatabaseMetaDataResultSet::getInt( sal_Int32 columnIndex ) 246 { 247 ::osl::MutexGuard aGuard( m_aMutex ); 248 249 250 getValue(columnIndex); 251 252 columnIndex = mapColumn(columnIndex); 253 if(m_aValue.isNull()) 254 return 0; 255 256 if(m_aValueRange.size() && (m_aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end()) 257 return (*m_aValueRangeIter).second[(sal_Int32)m_aValue]; 258 else if(m_aStrValueRange.size() && (m_aStrValueRangeIter = m_aStrValueRange.find(columnIndex)) != m_aStrValueRange.end()) 259 return (*m_aStrValueRangeIter).second[m_aValue]; 260 261 return m_aValue; 262 } 263 // ------------------------------------------------------------------------- 264 265 sal_Int32 SAL_CALL ODatabaseMetaDataResultSet::getRow( ) 266 { 267 ::dbtools::throwFeatureNotImplementedException( "XResultSet::getRow", *this ); 268 return 0; 269 } 270 // ------------------------------------------------------------------------- 271 272 sal_Int64 SAL_CALL ODatabaseMetaDataResultSet::getLong( sal_Int32 /*columnIndex*/ ) 273 { 274 ::dbtools::throwFeatureNotImplementedException( "XRow::getLong", *this ); 275 return sal_Int64(0); 276 } 277 // ------------------------------------------------------------------------- 278 279 Reference< XResultSetMetaData > SAL_CALL ODatabaseMetaDataResultSet::getMetaData( ) 280 { 281 ::osl::MutexGuard aGuard( m_aMutex ); 282 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 283 284 checkRecordSet(); 285 286 287 if(!m_xMetaData.is()) 288 m_xMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this); 289 290 return m_xMetaData; 291 } 292 // ------------------------------------------------------------------------- 293 Reference< XArray > SAL_CALL ODatabaseMetaDataResultSet::getArray( sal_Int32 /*columnIndex*/ ) 294 { 295 ::dbtools::throwFeatureNotImplementedException( "XRow::getRow", *this ); 296 return NULL; 297 } 298 299 // ------------------------------------------------------------------------- 300 301 Reference< XClob > SAL_CALL ODatabaseMetaDataResultSet::getClob( sal_Int32 /*columnIndex*/ ) 302 { 303 ::dbtools::throwFeatureNotImplementedException( "XRow::getRow", *this ); 304 return NULL; 305 } 306 // ------------------------------------------------------------------------- 307 Reference< XBlob > SAL_CALL ODatabaseMetaDataResultSet::getBlob( sal_Int32 /*columnIndex*/ ) 308 { 309 ::dbtools::throwFeatureNotImplementedException( "XRow::getRow", *this ); 310 return NULL; 311 } 312 // ------------------------------------------------------------------------- 313 314 Reference< XRef > SAL_CALL ODatabaseMetaDataResultSet::getRef( sal_Int32 /*columnIndex*/ ) 315 { 316 ::dbtools::throwFeatureNotImplementedException( "XRow::getRow", *this ); 317 return NULL; 318 } 319 // ------------------------------------------------------------------------- 320 321 Any SAL_CALL ODatabaseMetaDataResultSet::getObject( sal_Int32 columnIndex, const Reference< ::com::sun::star::container::XNameAccess >& /*typeMap*/ ) 322 { 323 ::osl::MutexGuard aGuard( m_aMutex ); 324 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 325 326 checkRecordSet(); 327 328 329 columnIndex = mapColumn(columnIndex); 330 return Any(); 331 } 332 // ------------------------------------------------------------------------- 333 334 sal_Int16 SAL_CALL ODatabaseMetaDataResultSet::getShort( sal_Int32 columnIndex ) 335 { 336 ::osl::MutexGuard aGuard( m_aMutex ); 337 338 getValue(columnIndex); 339 340 columnIndex = mapColumn(columnIndex); 341 if(m_aValue.isNull()) 342 return 0; 343 344 if(m_aValueRange.size() && (m_aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end()) 345 return (sal_Int16)(*m_aValueRangeIter).second[(sal_Int32)m_aValue]; 346 else if(m_aStrValueRange.size() && (m_aStrValueRangeIter = m_aStrValueRange.find(columnIndex)) != m_aStrValueRange.end()) 347 return (sal_Int16)(*m_aStrValueRangeIter).second[m_aValue]; 348 349 return m_aValue; 350 } 351 // ------------------------------------------------------------------------- 352 353 ::rtl::OUString SAL_CALL ODatabaseMetaDataResultSet::getString( sal_Int32 columnIndex ) 354 { 355 ::osl::MutexGuard aGuard( m_aMutex ); 356 357 getValue(columnIndex); 358 359 360 columnIndex = mapColumn(columnIndex); 361 if(m_aValue.isNull()) 362 return ::rtl::OUString(); 363 if(m_aIntValueRange.size() && (m_aIntValueRangeIter = m_aIntValueRange.find(columnIndex)) != m_aIntValueRange.end()) 364 return (*m_aIntValueRangeIter).second[m_aValue]; 365 366 return m_aValue; 367 } 368 369 // ------------------------------------------------------------------------- 370 371 372 ::com::sun::star::util::Time SAL_CALL ODatabaseMetaDataResultSet::getTime( sal_Int32 columnIndex ) 373 { 374 return getValue(columnIndex); 375 } 376 // ------------------------------------------------------------------------- 377 378 379 ::com::sun::star::util::DateTime SAL_CALL ODatabaseMetaDataResultSet::getTimestamp( sal_Int32 columnIndex ) 380 { 381 return getValue(columnIndex); 382 } 383 // ------------------------------------------------------------------------- 384 385 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isAfterLast( ) 386 { 387 ::osl::MutexGuard aGuard( m_aMutex ); 388 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 389 390 checkRecordSet(); 391 392 393 VARIANT_BOOL bIsAtEOF; 394 m_pRecordSet->get_EOF(&bIsAtEOF); 395 return bIsAtEOF == VARIANT_TRUE; 396 } 397 // ------------------------------------------------------------------------- 398 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isFirst( ) 399 { 400 ::osl::MutexGuard aGuard( m_aMutex ); 401 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 402 403 checkRecordSet(); 404 405 406 return m_nRowPos == 1; 407 } 408 // ------------------------------------------------------------------------- 409 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isLast( ) 410 { 411 ::osl::MutexGuard aGuard( m_aMutex ); 412 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 413 414 checkRecordSet(); 415 416 417 return sal_True; 418 } 419 // ------------------------------------------------------------------------- 420 void SAL_CALL ODatabaseMetaDataResultSet::beforeFirst( ) 421 { 422 ::osl::MutexGuard aGuard( m_aMutex ); 423 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 424 425 checkRecordSet(); 426 427 428 if(first()) 429 previous(); 430 } 431 // ------------------------------------------------------------------------- 432 void SAL_CALL ODatabaseMetaDataResultSet::afterLast( ) 433 { 434 ::osl::MutexGuard aGuard( m_aMutex ); 435 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 436 437 checkRecordSet(); 438 439 440 if(last()) 441 next(); 442 m_bEOF = sal_True; 443 } 444 // ------------------------------------------------------------------------- 445 446 void SAL_CALL ODatabaseMetaDataResultSet::close( ) 447 { 448 { 449 ::osl::MutexGuard aGuard( m_aMutex ); 450 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 451 452 } 453 dispose(); 454 } 455 // ------------------------------------------------------------------------- 456 457 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::first( ) 458 { 459 ::osl::MutexGuard aGuard( m_aMutex ); 460 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 461 462 463 if(!m_pRecordSet) 464 return sal_False; 465 466 sal_Bool bRet = SUCCEEDED(m_pRecordSet->MoveFirst()); 467 if ( bRet ) 468 m_nRowPos = 1; 469 return bRet; 470 } 471 // ------------------------------------------------------------------------- 472 473 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::last( ) 474 { 475 ::osl::MutexGuard aGuard( m_aMutex ); 476 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed ); 477 478 479 return m_pRecordSet && SUCCEEDED(m_pRecordSet->MoveLast()) ? sal_True : sal_False; 480 } 481 // ------------------------------------------------------------------------- 482 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::absolute( sal_Int32 row ) 483 { 484 ::osl::MutexGuard aGuard( m_aMutex ); 485 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 486 487 488 if(first()) 489 { 490 OLEVariant aEmpty; 491 aEmpty.setNoArg(); 492 sal_Bool bRet = SUCCEEDED(m_pRecordSet->Move(row,aEmpty)); 493 if(bRet) 494 m_nRowPos = row; 495 return bRet; 496 } 497 return sal_False; 498 } 499 // ------------------------------------------------------------------------- 500 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::relative( sal_Int32 row ) 501 { 502 ::osl::MutexGuard aGuard( m_aMutex ); 503 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 504 505 506 if(!m_pRecordSet) 507 return sal_False; 508 509 OLEVariant aEmpty; 510 aEmpty.setNoArg(); 511 sal_Bool bRet = SUCCEEDED(m_pRecordSet->Move(row,aEmpty)); 512 if(bRet) 513 m_nRowPos += row; 514 return bRet; 515 } 516 // ------------------------------------------------------------------------- 517 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::previous( ) 518 { 519 ::osl::MutexGuard aGuard( m_aMutex ); 520 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 521 522 523 if(!m_pRecordSet) 524 return sal_False; 525 526 sal_Bool bRet = SUCCEEDED(m_pRecordSet->MovePrevious()); 527 if(bRet) 528 --m_nRowPos; 529 return bRet; 530 } 531 // ------------------------------------------------------------------------- 532 Reference< XInterface > SAL_CALL ODatabaseMetaDataResultSet::getStatement( ) 533 { 534 return m_aStatement.get(); 535 } 536 // ------------------------------------------------------------------------- 537 538 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::rowDeleted( ) 539 { 540 ::osl::MutexGuard aGuard( m_aMutex ); 541 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 542 543 checkRecordSet(); 544 545 546 RecordStatusEnum eRec; 547 m_pRecordSet->get_Status((sal_Int32*)&eRec); 548 return (eRec & adRecDeleted) == adRecDeleted; 549 } 550 // ------------------------------------------------------------------------- 551 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::rowInserted( ) 552 { ::osl::MutexGuard aGuard( m_aMutex ); 553 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 554 555 checkRecordSet(); 556 557 558 RecordStatusEnum eRec; 559 m_pRecordSet->get_Status((sal_Int32*)&eRec); 560 return (eRec & adRecNew) == adRecNew; 561 } 562 // ------------------------------------------------------------------------- 563 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::rowUpdated( ) 564 { 565 ::osl::MutexGuard aGuard( m_aMutex ); 566 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 567 568 checkRecordSet(); 569 570 571 RecordStatusEnum eRec; 572 m_pRecordSet->get_Status((sal_Int32*)&eRec); 573 return (eRec & adRecModified) == adRecModified; 574 } 575 // ------------------------------------------------------------------------- 576 577 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isBeforeFirst( ) 578 { 579 ::osl::MutexGuard aGuard( m_aMutex ); 580 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 581 582 583 if(!m_pRecordSet) 584 return sal_True; 585 586 VARIANT_BOOL bIsAtBOF; 587 m_pRecordSet->get_BOF(&bIsAtBOF); 588 return bIsAtBOF == VARIANT_TRUE; 589 } 590 // ------------------------------------------------------------------------- 591 592 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::next( ) 593 { 594 ::osl::MutexGuard aGuard( m_aMutex ); 595 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 596 597 598 if(!m_pRecordSet) 599 return sal_False; 600 601 if(m_bOnFirstAfterOpen) 602 { 603 m_bOnFirstAfterOpen = sal_False; 604 return sal_True; 605 } 606 else 607 return SUCCEEDED(m_pRecordSet->MoveNext()); 608 } 609 // ------------------------------------------------------------------------- 610 611 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::wasNull( ) 612 { 613 ::osl::MutexGuard aGuard( m_aMutex ); 614 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 615 616 checkRecordSet(); 617 618 619 return m_aValue.isNull(); 620 } 621 // ------------------------------------------------------------------------- 622 void SAL_CALL ODatabaseMetaDataResultSet::refreshRow( ) 623 { 624 ::osl::MutexGuard aGuard( m_aMutex ); 625 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 626 627 checkRecordSet(); 628 629 630 m_pRecordSet->Resync(adAffectCurrent,adResyncAllValues); 631 } 632 // ------------------------------------------------------------------------- 633 634 void SAL_CALL ODatabaseMetaDataResultSet::cancel( ) 635 { 636 ::osl::MutexGuard aGuard( m_aMutex ); 637 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 638 639 checkRecordSet(); 640 641 642 m_pRecordSet->Cancel(); 643 } 644 // ------------------------------------------------------------------------- 645 void SAL_CALL ODatabaseMetaDataResultSet::clearWarnings( ) 646 { 647 } 648 // ------------------------------------------------------------------------- 649 Any SAL_CALL ODatabaseMetaDataResultSet::getWarnings( ) 650 { 651 return Any(); 652 } 653 //------------------------------------------------------------------------------ 654 sal_Int32 ODatabaseMetaDataResultSet::getResultSetConcurrency() const 655 { 656 return ResultSetConcurrency::READ_ONLY; 657 } 658 //------------------------------------------------------------------------------ 659 sal_Int32 ODatabaseMetaDataResultSet::getResultSetType() const 660 { 661 return ResultSetType::FORWARD_ONLY; 662 } 663 //------------------------------------------------------------------------------ 664 sal_Int32 ODatabaseMetaDataResultSet::getFetchDirection() const 665 { 666 return FetchDirection::FORWARD; 667 } 668 //------------------------------------------------------------------------------ 669 sal_Int32 ODatabaseMetaDataResultSet::getFetchSize() const 670 { 671 sal_Int32 nValue=-1; 672 if(m_pRecordSet) 673 m_pRecordSet->get_CacheSize(&nValue); 674 return nValue; 675 } 676 //------------------------------------------------------------------------------ 677 ::rtl::OUString ODatabaseMetaDataResultSet::getCursorName() const 678 { 679 return ::rtl::OUString(); 680 } 681 682 //------------------------------------------------------------------------------ 683 void ODatabaseMetaDataResultSet::setFetchDirection(sal_Int32 /*_par0*/) 684 { 685 ::dbtools::throwFeatureNotImplementedException( "ResultSet::FetchDirection", *this ); 686 } 687 //------------------------------------------------------------------------------ 688 void ODatabaseMetaDataResultSet::setFetchSize(sal_Int32 _par0) 689 { 690 if(m_pRecordSet) 691 m_pRecordSet->put_CacheSize(_par0); 692 } 693 // ------------------------------------------------------------------------- 694 ::cppu::IPropertyArrayHelper* ODatabaseMetaDataResultSet::createArrayHelper( ) const 695 { 696 697 Sequence< com::sun::star::beans::Property > aProps(5); 698 com::sun::star::beans::Property* pProperties = aProps.getArray(); 699 sal_Int32 nPos = 0; 700 DECL_PROP0(CURSORNAME, ::rtl::OUString); 701 DECL_PROP0(FETCHDIRECTION, sal_Int32); 702 DECL_PROP0(FETCHSIZE, sal_Int32); 703 DECL_PROP0(RESULTSETCONCURRENCY,sal_Int32); 704 DECL_PROP0(RESULTSETTYPE, sal_Int32); 705 706 return new ::cppu::OPropertyArrayHelper(aProps); 707 } 708 // ------------------------------------------------------------------------- 709 ::cppu::IPropertyArrayHelper & ODatabaseMetaDataResultSet::getInfoHelper() 710 { 711 return *const_cast<ODatabaseMetaDataResultSet*>(this)->getArrayHelper(); 712 } 713 // ------------------------------------------------------------------------- 714 sal_Bool ODatabaseMetaDataResultSet::convertFastPropertyValue( 715 Any & rConvertedValue, 716 Any & rOldValue, 717 sal_Int32 nHandle, 718 const Any& rValue ) 719 { 720 switch(nHandle) 721 { 722 case PROPERTY_ID_CURSORNAME: 723 case PROPERTY_ID_RESULTSETCONCURRENCY: 724 case PROPERTY_ID_RESULTSETTYPE: 725 throw ::com::sun::star::lang::IllegalArgumentException(); 726 break; 727 case PROPERTY_ID_FETCHDIRECTION: 728 return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchDirection()); 729 case PROPERTY_ID_FETCHSIZE: 730 return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchSize()); 731 default: 732 ; 733 } 734 return sal_False; 735 } 736 // ------------------------------------------------------------------------- 737 void ODatabaseMetaDataResultSet::setFastPropertyValue_NoBroadcast( 738 sal_Int32 nHandle, 739 const Any& /*rValue*/ 740 ) 741 { 742 switch(nHandle) 743 { 744 case PROPERTY_ID_CURSORNAME: 745 case PROPERTY_ID_RESULTSETCONCURRENCY: 746 case PROPERTY_ID_RESULTSETTYPE: 747 case PROPERTY_ID_FETCHDIRECTION: 748 case PROPERTY_ID_FETCHSIZE: 749 throw Exception(); 750 break; 751 default: 752 OSL_ENSURE(0,"setFastPropertyValue_NoBroadcast: Illegal handle value!"); 753 } 754 } 755 // ------------------------------------------------------------------------- 756 void ODatabaseMetaDataResultSet::getFastPropertyValue( 757 Any& rValue, 758 sal_Int32 nHandle 759 ) const 760 { 761 switch(nHandle) 762 { 763 case PROPERTY_ID_CURSORNAME: 764 rValue <<= getCursorName(); 765 break; 766 case PROPERTY_ID_RESULTSETCONCURRENCY: 767 rValue <<= getResultSetConcurrency(); 768 break; 769 case PROPERTY_ID_RESULTSETTYPE: 770 rValue <<= getResultSetType(); 771 break; 772 case PROPERTY_ID_FETCHDIRECTION: 773 rValue <<= getFetchDirection(); 774 break; 775 case PROPERTY_ID_FETCHSIZE: 776 rValue <<= getFetchSize(); 777 break; 778 } 779 } 780 // ------------------------------------------------------------------------- 781 void ODatabaseMetaDataResultSet::setProceduresMap() 782 { 783 784 for(sal_Int32 i=1;i<4;i++) 785 m_aColMapping.push_back(i); 786 m_aColMapping.push_back(5); 787 m_aColMapping.push_back(7); 788 m_aColMapping.push_back(8); 789 m_aColMapping.push_back(6); 790 m_aColMapping.push_back(4); 791 792 TInt2IntMap aMap; 793 aMap[DB_PT_UNKNOWN] = ProcedureResult::UNKNOWN; 794 aMap[DB_PT_PROCEDURE] = ProcedureResult::NONE; 795 aMap[DB_PT_FUNCTION] = ProcedureResult::RETURN; 796 m_aValueRange[4] = aMap; 797 798 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this); 799 pMetaData->setProceduresMap(); 800 m_xMetaData = pMetaData; 801 } 802 // ------------------------------------------------------------------------- 803 void ODatabaseMetaDataResultSet::setCatalogsMap() 804 { 805 m_aColMapping.push_back(1); 806 807 m_xMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this); 808 } 809 // ------------------------------------------------------------------------- 810 void ODatabaseMetaDataResultSet::setSchemasMap() 811 { 812 m_aColMapping.push_back(2); 813 814 m_xMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this); 815 } 816 // ------------------------------------------------------------------------- 817 void ODatabaseMetaDataResultSet::setColumnPrivilegesMap() 818 { 819 820 m_aColMapping.push_back(3); 821 m_aColMapping.push_back(4); 822 m_aColMapping.push_back(5); 823 m_aColMapping.push_back(6); 824 m_aColMapping.push_back(2); 825 m_aColMapping.push_back(9); 826 m_aColMapping.push_back(10); 827 828 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this); 829 pMetaData->setColumnPrivilegesMap(); 830 m_xMetaData = pMetaData; 831 } 832 // ------------------------------------------------------------------------- 833 void ODatabaseMetaDataResultSet::setColumnsMap() 834 { 835 836 for(sal_Int32 i=1;i<5;++i) 837 m_aColMapping.push_back(i); 838 839 m_aColMapping.push_back(12); 840 m_aColMapping.push_back(12); // is used as TYPE_NAME 841 842 m_aColMapping.push_back(14); 843 m_aColMapping.push_back(6); 844 m_aColMapping.push_back(17); 845 m_aColMapping.push_back(18); 846 847 m_aColMapping.push_back(11); 848 m_aColMapping.push_back(29); 849 m_aColMapping.push_back(9); 850 m_aColMapping.push_back(18); 851 m_aColMapping.push_back(18); 852 853 m_aColMapping.push_back(15); 854 m_aColMapping.push_back(7); 855 m_aColMapping.push_back(11); 856 857 TInt2IntMap aMap; 858 aMap[adEmpty] = ADOS::MapADOType2Jdbc(adEmpty); 859 aMap[adTinyInt] = ADOS::MapADOType2Jdbc(adTinyInt); 860 aMap[adSmallInt] = ADOS::MapADOType2Jdbc(adSmallInt); 861 aMap[adInteger] = ADOS::MapADOType2Jdbc(adInteger); 862 aMap[adBigInt] = ADOS::MapADOType2Jdbc(adBigInt); 863 aMap[adUnsignedTinyInt] = ADOS::MapADOType2Jdbc(adUnsignedTinyInt); 864 aMap[adUnsignedSmallInt]= ADOS::MapADOType2Jdbc(adUnsignedSmallInt); 865 aMap[adUnsignedInt] = ADOS::MapADOType2Jdbc(adUnsignedInt); 866 aMap[adUnsignedBigInt] = ADOS::MapADOType2Jdbc(adUnsignedBigInt); 867 aMap[adSingle] = ADOS::MapADOType2Jdbc(adSingle); 868 aMap[adDouble] = ADOS::MapADOType2Jdbc(adDouble); 869 aMap[adCurrency] = ADOS::MapADOType2Jdbc(adCurrency); 870 aMap[adDecimal] = ADOS::MapADOType2Jdbc(adDecimal); 871 aMap[adNumeric] = ADOS::MapADOType2Jdbc(adNumeric); 872 aMap[adBoolean] = ADOS::MapADOType2Jdbc(adBoolean); 873 aMap[adError] = ADOS::MapADOType2Jdbc(adError); 874 aMap[adUserDefined] = ADOS::MapADOType2Jdbc(adUserDefined); 875 aMap[adVariant] = ADOS::MapADOType2Jdbc(adVariant); 876 aMap[adIDispatch] = ADOS::MapADOType2Jdbc(adIDispatch); 877 aMap[adIUnknown] = ADOS::MapADOType2Jdbc(adIUnknown); 878 aMap[adGUID] = ADOS::MapADOType2Jdbc(adGUID); 879 aMap[adDate] = ADOS::MapADOType2Jdbc(adDate); 880 aMap[adDBDate] = ADOS::MapADOType2Jdbc(adDBDate); 881 aMap[adDBTime] = ADOS::MapADOType2Jdbc(adDBTime); 882 aMap[adDBTimeStamp] = ADOS::MapADOType2Jdbc(adDBTimeStamp); 883 aMap[adBSTR] = ADOS::MapADOType2Jdbc(adBSTR); 884 aMap[adChar] = ADOS::MapADOType2Jdbc(adChar); 885 aMap[adVarChar] = ADOS::MapADOType2Jdbc(adVarChar); 886 aMap[adLongVarChar] = ADOS::MapADOType2Jdbc(adLongVarChar); 887 aMap[adWChar] = ADOS::MapADOType2Jdbc(adWChar); 888 aMap[adVarWChar] = ADOS::MapADOType2Jdbc(adVarWChar); 889 aMap[adLongVarWChar] = ADOS::MapADOType2Jdbc(adLongVarWChar); 890 aMap[adBinary] = ADOS::MapADOType2Jdbc(adBinary); 891 aMap[adVarBinary] = ADOS::MapADOType2Jdbc(adVarBinary); 892 aMap[adLongVarBinary] = ADOS::MapADOType2Jdbc(adLongVarBinary); 893 aMap[adChapter] = ADOS::MapADOType2Jdbc(adChapter); 894 aMap[adFileTime] = ADOS::MapADOType2Jdbc(adFileTime); 895 aMap[adPropVariant] = ADOS::MapADOType2Jdbc(adPropVariant); 896 aMap[adVarNumeric] = ADOS::MapADOType2Jdbc(adVarNumeric); 897 // aMap[adArray] = ADOS::MapADOType2Jdbc(adArray); 898 899 m_aValueRange[12] = aMap; 900 901 ::std::map< sal_Int32,::rtl::OUString> aMap2; 902 aMap2[0] = ::rtl::OUString::createFromAscii("YES"); 903 aMap2[1] = ::rtl::OUString::createFromAscii("NO"); 904 m_aIntValueRange[18] = aMap2; 905 906 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this); 907 pMetaData->setColumnsMap(); 908 m_xMetaData = pMetaData; 909 } 910 // ------------------------------------------------------------------------- 911 void ODatabaseMetaDataResultSet::setTablesMap() 912 { 913 914 for(sal_Int32 i=1;i<5;i++) 915 m_aColMapping.push_back(i); 916 m_aColMapping.push_back(6); 917 918 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this); 919 pMetaData->setTablesMap(); 920 m_xMetaData = pMetaData; 921 } 922 // ------------------------------------------------------------------------- 923 void ODatabaseMetaDataResultSet::setProcedureColumnsMap() 924 { 925 926 for(sal_Int32 i=1;i<5;i++) 927 m_aColMapping.push_back(i); 928 m_aColMapping.push_back(6); 929 m_aColMapping.push_back(10); 930 m_aColMapping.push_back(16); 931 m_aColMapping.push_back(13); 932 m_aColMapping.push_back(11); 933 m_aColMapping.push_back(12); 934 935 m_aColMapping.push_back(9); 936 m_aColMapping.push_back(14); 937 938 TInt2IntMap aMap; 939 aMap[DBTYPE_EMPTY] = DataType::SQLNULL; 940 aMap[DBTYPE_NULL] = DataType::SQLNULL; 941 aMap[DBTYPE_I2] = DataType::SMALLINT; 942 aMap[DBTYPE_I4] = DataType::INTEGER; 943 aMap[DBTYPE_R4] = DataType::FLOAT; 944 aMap[DBTYPE_R8] = DataType::DOUBLE; 945 aMap[DBTYPE_CY] = DataType::BIGINT; 946 aMap[DBTYPE_DATE] = DataType::DATE; 947 aMap[DBTYPE_BSTR] = DataType::VARCHAR; 948 aMap[DBTYPE_IDISPATCH] = DataType::OBJECT; 949 aMap[DBTYPE_ERROR] = DataType::OTHER; 950 aMap[DBTYPE_BOOL] = DataType::BIT; 951 aMap[DBTYPE_VARIANT] = DataType::STRUCT; 952 aMap[DBTYPE_IUNKNOWN] = DataType::OTHER; 953 aMap[DBTYPE_DECIMAL] = DataType::DECIMAL; 954 aMap[DBTYPE_UI1] = DataType::TINYINT; 955 aMap[DBTYPE_ARRAY] = DataType::ARRAY; 956 aMap[DBTYPE_BYREF] = DataType::REF; 957 aMap[DBTYPE_I1] = DataType::CHAR; 958 aMap[DBTYPE_UI2] = DataType::SMALLINT; 959 aMap[DBTYPE_UI4] = DataType::INTEGER; 960 961 // aMap[The] = ; 962 // aMap[in] = ; 963 aMap[DBTYPE_I8] = DataType::BIGINT; 964 aMap[DBTYPE_UI8] = DataType::BIGINT; 965 aMap[DBTYPE_GUID] = DataType::OTHER; 966 aMap[DBTYPE_VECTOR] = DataType::OTHER; 967 aMap[DBTYPE_FILETIME] = DataType::OTHER; 968 aMap[DBTYPE_RESERVED] = DataType::OTHER; 969 970 // aMap[The] = ; 971 aMap[DBTYPE_BYTES] = DataType::VARBINARY; 972 aMap[DBTYPE_STR] = DataType::LONGVARCHAR; 973 aMap[DBTYPE_WSTR] = DataType::LONGVARCHAR; 974 aMap[DBTYPE_NUMERIC] = DataType::NUMERIC; 975 aMap[DBTYPE_UDT] = DataType::OTHER; 976 aMap[DBTYPE_DBDATE] = DataType::DATE; 977 aMap[DBTYPE_DBTIME] = DataType::TIME; 978 aMap[DBTYPE_DBTIMESTAMP] = DataType::TIMESTAMP; 979 aMap[DBTYPE_HCHAPTER] = DataType::OTHER; 980 aMap[DBTYPE_PROPVARIANT] = DataType::OTHER; 981 aMap[DBTYPE_VARNUMERIC] = DataType::NUMERIC; 982 983 m_aValueRange[10] = aMap; 984 985 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this); 986 pMetaData->setProcedureColumnsMap(); 987 m_xMetaData = pMetaData; 988 } 989 // ------------------------------------------------------------------------- 990 void ODatabaseMetaDataResultSet::setPrimaryKeysMap() 991 { 992 993 sal_Int32 i=1; 994 for(;i<5;i++) 995 m_aColMapping.push_back(i); 996 m_aColMapping.push_back(7); 997 m_aColMapping.push_back(8); 998 999 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this); 1000 pMetaData->setProcedureColumnsMap(); 1001 m_xMetaData = pMetaData; 1002 } 1003 // ------------------------------------------------------------------------- 1004 void ODatabaseMetaDataResultSet::setIndexInfoMap() 1005 { 1006 1007 sal_Int32 i=1; 1008 for(;i<4;i++) 1009 m_aColMapping.push_back(i); 1010 m_aColMapping.push_back(8); 1011 m_aColMapping.push_back(4); 1012 m_aColMapping.push_back(6); 1013 m_aColMapping.push_back(10); 1014 m_aColMapping.push_back(17); 1015 m_aColMapping.push_back(18); 1016 m_aColMapping.push_back(21); 1017 m_aColMapping.push_back(22); 1018 m_aColMapping.push_back(23); 1019 m_aColMapping.push_back(24); 1020 1021 TInt2IntMap aMap; 1022 aMap[DBPROPVAL_IT_HASH] = IndexType::HASHED; 1023 aMap[DBPROPVAL_IT_CONTENT] = IndexType::OTHER; 1024 aMap[DBPROPVAL_IT_OTHER] = IndexType::OTHER; 1025 aMap[DBPROPVAL_IT_BTREE] = IndexType::OTHER; 1026 1027 m_aValueRange[10] = aMap; 1028 1029 TInt2IntMap aMap2; 1030 aMap[0] = 1; 1031 aMap[1] = 0; 1032 m_aValueRange[8] = aMap2; 1033 1034 ::std::map< sal_Int32,::rtl::OUString> aMap3; 1035 aMap3[0] = ::rtl::OUString(); 1036 aMap3[DB_COLLATION_ASC] = ::rtl::OUString::createFromAscii("A"); 1037 aMap3[DB_COLLATION_DESC] = ::rtl::OUString::createFromAscii("D"); 1038 1039 m_aIntValueRange[21] = aMap3; 1040 1041 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this); 1042 pMetaData->setIndexInfoMap(); 1043 m_xMetaData = pMetaData; 1044 } 1045 // ------------------------------------------------------------------------- 1046 void ODatabaseMetaDataResultSet::setTablePrivilegesMap() 1047 { 1048 1049 sal_Int32 i=3; 1050 for(;i<6;i++) 1051 m_aColMapping.push_back(i); 1052 m_aColMapping.push_back(1); 1053 m_aColMapping.push_back(2); 1054 m_aColMapping.push_back(6); 1055 m_aColMapping.push_back(7); 1056 1057 ::std::map< sal_Int32,::rtl::OUString> aMap; 1058 aMap[0] = ::rtl::OUString::createFromAscii("YES"); 1059 aMap[1] = ::rtl::OUString::createFromAscii("NO"); 1060 m_aIntValueRange[7] = aMap; 1061 1062 1063 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this); 1064 pMetaData->setTablePrivilegesMap(); 1065 m_xMetaData = pMetaData; 1066 } 1067 // ------------------------------------------------------------------------- 1068 void ODatabaseMetaDataResultSet::setCrossReferenceMap() 1069 { 1070 1071 sal_Int32 i=1; 1072 for(;i<5;i++) 1073 m_aColMapping.push_back(i); 1074 for(i=7;i<11;i++) 1075 m_aColMapping.push_back(i); 1076 1077 m_aColMapping.push_back(13); 1078 m_aColMapping.push_back(14); 1079 m_aColMapping.push_back(15); 1080 m_aColMapping.push_back(17); 1081 m_aColMapping.push_back(16); 1082 m_aColMapping.push_back(18); 1083 1084 ::std::map< ::rtl::OUString,sal_Int32> aMap; 1085 aMap[ ::rtl::OUString::createFromAscii("CASCADE")] = KeyRule::CASCADE; 1086 aMap[ ::rtl::OUString::createFromAscii("RESTRICT")] = KeyRule::RESTRICT; 1087 aMap[ ::rtl::OUString::createFromAscii("SET NULL")] = KeyRule::SET_NULL; 1088 aMap[ ::rtl::OUString::createFromAscii("SET DEFAULT")] = KeyRule::SET_DEFAULT; 1089 aMap[ ::rtl::OUString::createFromAscii("NO ACTION")] = KeyRule::NO_ACTION; 1090 1091 m_aStrValueRange[14] = aMap; 1092 m_aStrValueRange[15] = aMap; 1093 1094 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this); 1095 pMetaData->setCrossReferenceMap(); 1096 m_xMetaData = pMetaData; 1097 } 1098 // ------------------------------------------------------------------------- 1099 void ODatabaseMetaDataResultSet::setTypeInfoMap(sal_Bool _bJetEngine) 1100 { 1101 sal_Int32 i=1; 1102 for(;i<19;i++) 1103 m_aColMapping.push_back(i); 1104 1105 ::std::map< ::rtl::OUString,sal_Int32> aMap1; 1106 aMap1[ ::rtl::OUString()] = 10; 1107 1108 m_aStrValueRange[18] = aMap1; 1109 1110 TInt2IntMap aMap; 1111 aMap[adEmpty] = ADOS::MapADOType2Jdbc(adEmpty); 1112 aMap[adTinyInt] = ADOS::MapADOType2Jdbc(adTinyInt); 1113 aMap[adSmallInt] = ADOS::MapADOType2Jdbc(adSmallInt); 1114 aMap[adInteger] = ADOS::MapADOType2Jdbc(adInteger); 1115 aMap[adBigInt] = ADOS::MapADOType2Jdbc(adBigInt); 1116 aMap[adUnsignedTinyInt] = ADOS::MapADOType2Jdbc(adUnsignedTinyInt); 1117 aMap[adUnsignedSmallInt]= ADOS::MapADOType2Jdbc(adUnsignedSmallInt); 1118 aMap[adUnsignedInt] = ADOS::MapADOType2Jdbc(adUnsignedInt); 1119 aMap[adUnsignedBigInt] = ADOS::MapADOType2Jdbc(adUnsignedBigInt); 1120 aMap[adSingle] = ADOS::MapADOType2Jdbc(adSingle); 1121 aMap[adDouble] = ADOS::MapADOType2Jdbc(adDouble); 1122 aMap[adCurrency] = ADOS::MapADOType2Jdbc(adCurrency); 1123 aMap[adDecimal] = ADOS::MapADOType2Jdbc(adDecimal); 1124 aMap[adNumeric] = ADOS::MapADOType2Jdbc(adNumeric); 1125 aMap[adBoolean] = ADOS::MapADOType2Jdbc(adBoolean); 1126 aMap[adError] = ADOS::MapADOType2Jdbc(adError); 1127 aMap[adUserDefined] = ADOS::MapADOType2Jdbc(adUserDefined); 1128 aMap[adVariant] = ADOS::MapADOType2Jdbc(adVariant); 1129 aMap[adIDispatch] = ADOS::MapADOType2Jdbc(adIDispatch); 1130 aMap[adIUnknown] = ADOS::MapADOType2Jdbc(adIUnknown); 1131 aMap[adGUID] = ADOS::MapADOType2Jdbc(adGUID); 1132 aMap[adDate] = _bJetEngine ? ADOS::MapADOType2Jdbc(adDBTimeStamp) : ADOS::MapADOType2Jdbc(adDate); 1133 aMap[adDBDate] = ADOS::MapADOType2Jdbc(adDBDate); 1134 aMap[adDBTime] = ADOS::MapADOType2Jdbc(adDBTime); 1135 aMap[adDBTimeStamp] = ADOS::MapADOType2Jdbc(adDBTimeStamp); 1136 aMap[adBSTR] = ADOS::MapADOType2Jdbc(adBSTR); 1137 aMap[adChar] = ADOS::MapADOType2Jdbc(adChar); 1138 aMap[adVarChar] = ADOS::MapADOType2Jdbc(adVarChar); 1139 aMap[adLongVarChar] = ADOS::MapADOType2Jdbc(adLongVarChar); 1140 aMap[adWChar] = ADOS::MapADOType2Jdbc(adWChar); 1141 aMap[adVarWChar] = ADOS::MapADOType2Jdbc(adVarWChar); 1142 aMap[adLongVarWChar] = ADOS::MapADOType2Jdbc(adLongVarWChar); 1143 aMap[adBinary] = ADOS::MapADOType2Jdbc(adBinary); 1144 aMap[adVarBinary] = ADOS::MapADOType2Jdbc(adVarBinary); 1145 aMap[adLongVarBinary] = ADOS::MapADOType2Jdbc(adLongVarBinary); 1146 aMap[adChapter] = ADOS::MapADOType2Jdbc(adChapter); 1147 aMap[adFileTime] = ADOS::MapADOType2Jdbc(adFileTime); 1148 aMap[adPropVariant] = ADOS::MapADOType2Jdbc(adPropVariant); 1149 aMap[adVarNumeric] = ADOS::MapADOType2Jdbc(adVarNumeric); 1150 // aMap[adArray] = ADOS::MapADOType2Jdbc(adArray); 1151 1152 m_aValueRange[2] = aMap; 1153 1154 TInt2IntMap aColumnValueMapping; 1155 aColumnValueMapping[VARIANT_FALSE] = ColumnValue::NO_NULLS; 1156 aColumnValueMapping[VARIANT_TRUE] = ColumnValue::NULLABLE; 1157 m_aValueRange[7] = aColumnValueMapping; 1158 1159 // now adjust the column mapping 1160 // OJ 24.01.2002 96860 1161 TInt2IntMap aSerachMapping; 1162 aSerachMapping[DB_UNSEARCHABLE] = ColumnSearch::NONE; 1163 aSerachMapping[DB_LIKE_ONLY] = ColumnSearch::CHAR; 1164 aSerachMapping[DB_ALL_EXCEPT_LIKE] = ColumnSearch::BASIC; 1165 aSerachMapping[DB_SEARCHABLE] = ColumnSearch::FULL; 1166 1167 m_aValueRange[9] = aSerachMapping; 1168 1169 TInt2IntMap aCurrencyMapping; 1170 m_aValueRange[11] = aCurrencyMapping; 1171 1172 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this); 1173 pMetaData->setTypeInfoMap(); 1174 m_xMetaData = pMetaData; 1175 } 1176 // ----------------------------------------------------------------------------- 1177 void SAL_CALL ODatabaseMetaDataResultSet::acquire() throw() 1178 { 1179 ODatabaseMetaDataResultSet_BASE::acquire(); 1180 } 1181 // ----------------------------------------------------------------------------- 1182 void SAL_CALL ODatabaseMetaDataResultSet::release() throw() 1183 { 1184 ODatabaseMetaDataResultSet_BASE::release(); 1185 } 1186 // ----------------------------------------------------------------------------- 1187 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL ODatabaseMetaDataResultSet::getPropertySetInfo( ) 1188 { 1189 return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper()); 1190 } 1191 // ----------------------------------------------------------------------------- 1192 OLEVariant ODatabaseMetaDataResultSet::getValue(sal_Int32 columnIndex ) 1193 { 1194 ::osl::MutexGuard aGuard( m_aMutex ); 1195 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 1196 1197 checkRecordSet(); 1198 1199 WpADOField aField = ADOS::getField(m_pRecordSet,columnIndex); 1200 aField.get_Value(m_aValue); 1201 return m_aValue; 1202 } 1203 // ----------------------------------------------------------------------------- 1204