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_odbcbase.hxx" 26 #include "TConnection.hxx" 27 28 #ifndef _CONNECTIVITY_ADO_ADATABASEMETADATARESULTSET_HXX_ 29 #include "odbc/ODatabaseMetaDataResultSet.hxx" 30 #endif 31 #include <com/sun/star/sdbc/DataType.hpp> 32 #include <com/sun/star/sdbc/KeyRule.hpp> 33 #include <com/sun/star/sdbc/ProcedureResult.hpp> 34 #include <com/sun/star/sdbc/IndexType.hpp> 35 #include <comphelper/property.hxx> 36 #include <com/sun/star/lang/DisposedException.hpp> 37 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp> 38 #include <com/sun/star/sdbc/ResultSetType.hpp> 39 #include <com/sun/star/sdbc/FetchDirection.hpp> 40 #include <cppuhelper/typeprovider.hxx> 41 #include <comphelper/sequence.hxx> 42 #include "odbc/OResultSetMetaData.hxx" 43 #include "odbc/OTools.hxx" 44 #include <comphelper/types.hxx> 45 #include "FDatabaseMetaDataResultSetMetaData.hxx" 46 #include <connectivity/dbexception.hxx> 47 48 using namespace ::comphelper; 49 50 51 using namespace connectivity::odbc; 52 using namespace cppu; 53 //------------------------------------------------------------------------------ 54 using namespace ::com::sun::star::lang; 55 using namespace com::sun::star::uno; 56 using namespace com::sun::star::beans; 57 using namespace com::sun::star::sdbc; 58 using namespace com::sun::star::util; 59 60 // ------------------------------------------------------------------------- 61 ODatabaseMetaDataResultSet::ODatabaseMetaDataResultSet(OConnection* _pConnection) 62 :ODatabaseMetaDataResultSet_BASE(m_aMutex) 63 ,OPropertySetHelper(ODatabaseMetaDataResultSet_BASE::rBHelper) 64 65 ,m_aStatementHandle(_pConnection->createStatementHandle()) 66 ,m_aStatement(NULL) 67 ,m_xMetaData(NULL) 68 ,m_pRowStatusArray(NULL) 69 ,m_pConnection(_pConnection) 70 ,m_nTextEncoding(_pConnection->getTextEncoding()) 71 ,m_nRowPos(-1) 72 ,m_nLastColumnPos(0) 73 ,m_nDriverColumnCount(0) 74 ,m_nCurrentFetchState(0) 75 ,m_bWasNull(sal_True) 76 ,m_bEOF(sal_False) 77 ,m_bFreeHandle(sal_False) 78 { 79 OSL_ENSURE(m_pConnection,"ODatabaseMetaDataResultSet::ODatabaseMetaDataResultSet: No parent set!"); 80 osl_incrementInterlockedCount( &m_refCount ); 81 m_pConnection->acquire(); 82 m_pRowStatusArray = new SQLUSMALLINT[1]; // the default value 83 osl_decrementInterlockedCount( &m_refCount ); 84 // allocBuffer(); 85 } 86 87 // ------------------------------------------------------------------------- 88 ODatabaseMetaDataResultSet::~ODatabaseMetaDataResultSet() 89 { 90 OSL_ENSURE(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed,"Object wasn't disposed!"); 91 if(!ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed) 92 { 93 osl_incrementInterlockedCount( &m_refCount ); 94 dispose(); 95 } 96 delete [] m_pRowStatusArray; 97 } 98 // ------------------------------------------------------------------------- 99 void ODatabaseMetaDataResultSet::disposing(void) 100 { 101 OPropertySetHelper::disposing(); 102 103 ::osl::MutexGuard aGuard(m_aMutex); 104 if(m_bFreeHandle) 105 m_pConnection->freeStatementHandle(m_aStatementHandle); 106 107 m_aStatement = NULL; 108 m_xMetaData.clear(); 109 m_pConnection->release(); 110 } 111 // ------------------------------------------------------------------------- 112 Any SAL_CALL ODatabaseMetaDataResultSet::queryInterface( const Type & rType ) 113 { 114 Any aRet = OPropertySetHelper::queryInterface(rType); 115 return aRet.hasValue() ? aRet : ODatabaseMetaDataResultSet_BASE::queryInterface(rType); 116 } 117 // ----------------------------------------------------------------------------- 118 Reference< XPropertySetInfo > SAL_CALL ODatabaseMetaDataResultSet::getPropertySetInfo( ) 119 { 120 return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper()); 121 } 122 // ----------------------------------------------------------------------------- 123 void SAL_CALL ODatabaseMetaDataResultSet::acquire() throw() 124 { 125 ODatabaseMetaDataResultSet_BASE::acquire(); 126 } 127 // ----------------------------------------------------------------------------- 128 void SAL_CALL ODatabaseMetaDataResultSet::release() throw() 129 { 130 ODatabaseMetaDataResultSet_BASE::release(); 131 } 132 // ------------------------------------------------------------------------- 133 Sequence< Type > SAL_CALL ODatabaseMetaDataResultSet::getTypes( ) 134 { 135 ::cppu::OTypeCollection aTypes( ::getCppuType( (const Reference< XMultiPropertySet > *)0 ), 136 ::getCppuType( (const Reference< XFastPropertySet > *)0 ), 137 ::getCppuType( (const Reference< XPropertySet > *)0 )); 138 139 return ::comphelper::concatSequences(aTypes.getTypes(),ODatabaseMetaDataResultSet_BASE::getTypes()); 140 } 141 // ----------------------------------------------------------------------------- 142 sal_Int32 ODatabaseMetaDataResultSet::mapColumn (sal_Int32 column) 143 { 144 sal_Int32 map = column; 145 146 if (!m_aColMapping.empty()) 147 { 148 // Validate column number 149 map = m_aColMapping[column]; 150 } 151 152 return map; 153 } 154 // ------------------------------------------------------------------------- 155 156 sal_Int32 SAL_CALL ODatabaseMetaDataResultSet::findColumn( const ::rtl::OUString& columnName ) 157 { 158 159 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 160 ::osl::MutexGuard aGuard( m_aMutex ); 161 162 163 Reference< XResultSetMetaData > xMeta = getMetaData(); 164 sal_Int32 nLen = xMeta->getColumnCount(); 165 sal_Int32 i = 1; 166 for(;i<=nLen;++i) 167 if(xMeta->isCaseSensitive(i) ? columnName == xMeta->getColumnName(i) : 168 columnName.equalsIgnoreAsciiCase(xMeta->getColumnName(i))) 169 break; 170 return i; 171 } 172 // ------------------------------------------------------------------------- 173 Reference< ::com::sun::star::io::XInputStream > SAL_CALL ODatabaseMetaDataResultSet::getBinaryStream( sal_Int32 /*columnIndex*/ ) 174 { 175 ::dbtools::throwFunctionNotSupportedException( "XRow::getBinaryStream", *this ); 176 return NULL; 177 } 178 // ------------------------------------------------------------------------- 179 Reference< ::com::sun::star::io::XInputStream > SAL_CALL ODatabaseMetaDataResultSet::getCharacterStream( sal_Int32 /*columnIndex*/ ) 180 { 181 ::dbtools::throwFunctionNotSupportedException( "XRow::getCharacterStream", *this ); 182 return NULL; 183 } 184 185 // ------------------------------------------------------------------------- 186 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::getBoolean( sal_Int32 columnIndex ) 187 { 188 189 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 190 ::osl::MutexGuard aGuard( m_aMutex ); 191 192 columnIndex = mapColumn(columnIndex); 193 194 sal_Bool bRet = sal_False; 195 if(columnIndex <= m_nDriverColumnCount) 196 { 197 sal_Int32 nType = getMetaData()->getColumnType(columnIndex); 198 switch(nType) 199 { 200 case DataType::BIT: 201 { 202 sal_Int8 nValue = 0; 203 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_BIT,m_bWasNull,**this,&nValue,sizeof nValue); 204 bRet = nValue != 0; 205 } 206 break; 207 default: 208 bRet = getInt(columnIndex) != 0; 209 } 210 } 211 return bRet; 212 } 213 // ------------------------------------------------------------------------- 214 215 sal_Int8 SAL_CALL ODatabaseMetaDataResultSet::getByte( sal_Int32 columnIndex ) 216 { 217 218 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 219 ::osl::MutexGuard aGuard( m_aMutex ); 220 221 222 columnIndex = mapColumn(columnIndex); 223 sal_Int8 nVal = 0; 224 if(columnIndex <= m_nDriverColumnCount) 225 { 226 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_TINYINT,m_bWasNull,**this,&nVal,sizeof nVal); 227 228 ::std::map<sal_Int32, ::connectivity::TInt2IntMap >::iterator aValueRangeIter; 229 if ( !m_aValueRange.empty() && (aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end()) 230 return sal_Int8((*aValueRangeIter).second[(sal_Int32)nVal]); 231 } 232 else 233 m_bWasNull = sal_True; 234 return nVal; 235 } 236 // ------------------------------------------------------------------------- 237 238 Sequence< sal_Int8 > SAL_CALL ODatabaseMetaDataResultSet::getBytes( sal_Int32 columnIndex ) 239 { 240 241 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 242 ::osl::MutexGuard aGuard( m_aMutex ); 243 244 245 columnIndex = mapColumn(columnIndex); 246 if(columnIndex <= m_nDriverColumnCount) 247 { 248 sal_Int32 nType = getMetaData()->getColumnType(columnIndex); 249 switch(nType) 250 { 251 case DataType::VARCHAR: 252 case DataType::LONGVARCHAR: 253 { 254 ::rtl::OUString aRet = OTools::getStringValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_BINARY,m_bWasNull,**this,m_nTextEncoding); 255 return Sequence<sal_Int8>(reinterpret_cast<const sal_Int8*>(aRet.getStr()),sizeof(sal_Unicode)*aRet.getLength()); 256 } 257 } 258 return OTools::getBytesValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_BINARY,m_bWasNull,**this); 259 } 260 else 261 m_bWasNull = sal_True; 262 return Sequence<sal_Int8>(); 263 } 264 // ------------------------------------------------------------------------- 265 266 ::com::sun::star::util::Date SAL_CALL ODatabaseMetaDataResultSet::getDate( sal_Int32 columnIndex ) 267 { 268 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 269 ::osl::MutexGuard aGuard( m_aMutex ); 270 271 272 columnIndex = mapColumn(columnIndex); 273 if(columnIndex <= m_nDriverColumnCount) 274 { 275 DATE_STRUCT aDate; 276 aDate.day = 0; 277 aDate.month = 0; 278 aDate.year = 0; 279 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,m_pConnection->useOldDateFormat() ? SQL_C_DATE : SQL_C_TYPE_DATE,m_bWasNull,**this,&aDate,sizeof aDate); 280 return Date(aDate.day,aDate.month,aDate.year); 281 } 282 else 283 m_bWasNull = sal_True; 284 return Date(); 285 } 286 // ------------------------------------------------------------------------- 287 288 double SAL_CALL ODatabaseMetaDataResultSet::getDouble( sal_Int32 columnIndex ) 289 { 290 291 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 292 ::osl::MutexGuard aGuard( m_aMutex ); 293 294 295 columnIndex = mapColumn(columnIndex); 296 double nValue(0.0); 297 if(columnIndex <= m_nDriverColumnCount) 298 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_DOUBLE,m_bWasNull,**this,&nValue,sizeof nValue); 299 else 300 m_bWasNull = sal_True; 301 return nValue; 302 } 303 // ------------------------------------------------------------------------- 304 305 float SAL_CALL ODatabaseMetaDataResultSet::getFloat( sal_Int32 columnIndex ) 306 { 307 308 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 309 ::osl::MutexGuard aGuard( m_aMutex ); 310 311 312 columnIndex = mapColumn(columnIndex); 313 float nVal(0); 314 if(columnIndex <= m_nDriverColumnCount) 315 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_FLOAT,m_bWasNull,**this,&nVal,sizeof nVal); 316 else 317 m_bWasNull = sal_True; 318 return nVal; 319 } 320 // ------------------------------------------------------------------------- 321 322 sal_Int32 SAL_CALL ODatabaseMetaDataResultSet::getInt( sal_Int32 columnIndex ) 323 { 324 325 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 326 ::osl::MutexGuard aGuard( m_aMutex ); 327 328 329 columnIndex = mapColumn(columnIndex); 330 sal_Int32 nVal = 0; 331 if(columnIndex <= m_nDriverColumnCount) 332 { 333 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_LONG,m_bWasNull,**this,&nVal,sizeof nVal); 334 335 ::std::map<sal_Int32, ::connectivity::TInt2IntMap >::iterator aValueRangeIter; 336 if ( !m_aValueRange.empty() && (aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end()) 337 return (*aValueRangeIter).second[(sal_Int32)nVal]; 338 } 339 else 340 m_bWasNull = sal_True; 341 return nVal; 342 } 343 // ------------------------------------------------------------------------- 344 345 sal_Int32 SAL_CALL ODatabaseMetaDataResultSet::getRow( ) 346 { 347 return 0; 348 } 349 // ------------------------------------------------------------------------- 350 351 sal_Int64 SAL_CALL ODatabaseMetaDataResultSet::getLong( sal_Int32 /*columnIndex*/ ) 352 { 353 ::dbtools::throwFunctionNotSupportedException( "XRow::getLong", *this ); 354 return 0; 355 } 356 // ------------------------------------------------------------------------- 357 358 Reference< XResultSetMetaData > SAL_CALL ODatabaseMetaDataResultSet::getMetaData( ) 359 { 360 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 361 ::osl::MutexGuard aGuard( m_aMutex ); 362 return m_xMetaData.is() ? m_xMetaData : (m_xMetaData = new OResultSetMetaData(m_pConnection,m_aStatementHandle)); 363 } 364 // ------------------------------------------------------------------------- 365 Reference< XArray > SAL_CALL ODatabaseMetaDataResultSet::getArray( sal_Int32 /*columnIndex*/ ) 366 { 367 ::dbtools::throwFunctionNotSupportedException( "XRow::getArray", *this ); 368 return NULL; 369 } 370 // ------------------------------------------------------------------------- 371 Reference< XClob > SAL_CALL ODatabaseMetaDataResultSet::getClob( sal_Int32 /*columnIndex*/ ) 372 { 373 ::dbtools::throwFunctionNotSupportedException( "XRow::getClob", *this ); 374 return NULL; 375 } 376 // ------------------------------------------------------------------------- 377 Reference< XBlob > SAL_CALL ODatabaseMetaDataResultSet::getBlob( sal_Int32 /*columnIndex*/ ) 378 { 379 ::dbtools::throwFunctionNotSupportedException( "XRow::getBlob", *this ); 380 return NULL; 381 } 382 // ------------------------------------------------------------------------- 383 384 Reference< XRef > SAL_CALL ODatabaseMetaDataResultSet::getRef( sal_Int32 /*columnIndex*/ ) 385 { 386 ::dbtools::throwFunctionNotSupportedException( "XRow::getRef", *this ); 387 return NULL; 388 } 389 // ------------------------------------------------------------------------- 390 391 Any SAL_CALL ODatabaseMetaDataResultSet::getObject( sal_Int32 /*columnIndex*/, const Reference< ::com::sun::star::container::XNameAccess >& /*typeMap*/ ) 392 { 393 ::dbtools::throwFunctionNotSupportedException( "XRow::getObject", *this ); 394 return Any(); 395 } 396 // ------------------------------------------------------------------------- 397 398 sal_Int16 SAL_CALL ODatabaseMetaDataResultSet::getShort( sal_Int32 columnIndex ) 399 { 400 401 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 402 ::osl::MutexGuard aGuard( m_aMutex ); 403 404 columnIndex = mapColumn(columnIndex); 405 sal_Int16 nVal = 0; 406 if(columnIndex <= m_nDriverColumnCount) 407 { 408 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_SHORT,m_bWasNull,**this,&nVal,sizeof nVal); 409 410 ::std::map<sal_Int32, ::connectivity::TInt2IntMap >::iterator aValueRangeIter; 411 if ( !m_aValueRange.empty() && (aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end()) 412 return sal_Int16((*aValueRangeIter).second[(sal_Int32)nVal]); 413 } 414 else 415 m_bWasNull = sal_True; 416 return nVal; 417 } 418 // ------------------------------------------------------------------------- 419 420 ::rtl::OUString SAL_CALL ODatabaseMetaDataResultSet::getString( sal_Int32 columnIndex ) 421 { 422 423 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 424 ::osl::MutexGuard aGuard( m_aMutex ); 425 426 427 columnIndex = mapColumn(columnIndex); 428 ::rtl::OUString aVal; 429 if(columnIndex <= m_nDriverColumnCount) 430 aVal = OTools::getStringValue(m_pConnection,m_aStatementHandle,columnIndex,impl_getColumnType_nothrow(columnIndex),m_bWasNull,**this,m_nTextEncoding); 431 else 432 m_bWasNull = sal_True; 433 434 return aVal; 435 } 436 437 // ------------------------------------------------------------------------- 438 439 440 ::com::sun::star::util::Time SAL_CALL ODatabaseMetaDataResultSet::getTime( sal_Int32 columnIndex ) 441 { 442 443 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 444 ::osl::MutexGuard aGuard( m_aMutex ); 445 446 447 columnIndex = mapColumn(columnIndex); 448 TIME_STRUCT aTime={0,0,0}; 449 if(columnIndex <= m_nDriverColumnCount) 450 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,m_pConnection->useOldDateFormat() ? SQL_C_TIME : SQL_C_TYPE_TIME,m_bWasNull,**this,&aTime,sizeof aTime); 451 else 452 m_bWasNull = sal_True; 453 return Time(0,aTime.second,aTime.minute,aTime.hour); 454 } 455 // ------------------------------------------------------------------------- 456 457 458 ::com::sun::star::util::DateTime SAL_CALL ODatabaseMetaDataResultSet::getTimestamp( sal_Int32 columnIndex ) 459 { 460 461 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 462 ::osl::MutexGuard aGuard( m_aMutex ); 463 464 465 columnIndex = mapColumn(columnIndex); 466 TIMESTAMP_STRUCT aTime={0,0,0,0,0,0,0}; 467 if(columnIndex <= m_nDriverColumnCount) 468 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,m_pConnection->useOldDateFormat() ? SQL_C_TIMESTAMP : SQL_C_TYPE_TIMESTAMP,m_bWasNull,**this,&aTime,sizeof aTime); 469 else 470 m_bWasNull = sal_True; 471 return DateTime((sal_uInt16)aTime.fraction*1000,aTime.second,aTime.minute,aTime.hour,aTime.day,aTime.month,aTime.year); 472 } 473 // ------------------------------------------------------------------------- 474 475 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isAfterLast( ) 476 { 477 478 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 479 ::osl::MutexGuard aGuard( m_aMutex ); 480 481 482 return m_nCurrentFetchState == SQL_NO_DATA; 483 } 484 // ------------------------------------------------------------------------- 485 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isFirst( ) 486 { 487 488 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 489 ::osl::MutexGuard aGuard( m_aMutex ); 490 491 492 return m_nRowPos == 1; 493 } 494 // ------------------------------------------------------------------------- 495 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isLast( ) 496 { 497 498 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 499 ::osl::MutexGuard aGuard( m_aMutex ); 500 501 502 return m_bEOF && m_nCurrentFetchState != SQL_NO_DATA; 503 } 504 // ------------------------------------------------------------------------- 505 void SAL_CALL ODatabaseMetaDataResultSet::beforeFirst( ) 506 { 507 508 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 509 ::osl::MutexGuard aGuard( m_aMutex ); 510 511 512 if(first()) 513 previous(); 514 m_nCurrentFetchState = SQL_SUCCESS; 515 } 516 // ------------------------------------------------------------------------- 517 void SAL_CALL ODatabaseMetaDataResultSet::afterLast( ) 518 { 519 520 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 521 ::osl::MutexGuard aGuard( m_aMutex ); 522 523 524 if(last()) 525 next(); 526 m_bEOF = sal_True; 527 } 528 // ------------------------------------------------------------------------- 529 530 void SAL_CALL ODatabaseMetaDataResultSet::close( ) 531 { 532 { 533 534 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 535 ::osl::MutexGuard aGuard( m_aMutex ); 536 537 } 538 dispose(); 539 } 540 // ------------------------------------------------------------------------- 541 542 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::first( ) 543 { 544 545 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 546 ::osl::MutexGuard aGuard( m_aMutex ); 547 548 549 m_nCurrentFetchState = N3SQLFetchScroll(m_aStatementHandle,SQL_FETCH_FIRST,0); 550 OTools::ThrowException(m_pConnection,m_nCurrentFetchState,m_aStatementHandle,SQL_HANDLE_STMT,*this); 551 sal_Bool bRet = ( m_nCurrentFetchState == SQL_SUCCESS || m_nCurrentFetchState == SQL_SUCCESS_WITH_INFO ); 552 if( bRet ) 553 m_nRowPos = 1; 554 return bRet; 555 } 556 // ------------------------------------------------------------------------- 557 558 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::last( ) 559 { 560 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed ); 561 ::osl::MutexGuard aGuard( m_aMutex ); 562 563 564 m_nCurrentFetchState = N3SQLFetchScroll(m_aStatementHandle,SQL_FETCH_LAST,0); 565 OTools::ThrowException(m_pConnection,m_nCurrentFetchState,m_aStatementHandle,SQL_HANDLE_STMT,*this); 566 // here I know definitely that I stand on the last record 567 return (m_nCurrentFetchState == SQL_SUCCESS || m_nCurrentFetchState == SQL_SUCCESS_WITH_INFO); 568 } 569 // ------------------------------------------------------------------------- 570 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::absolute( sal_Int32 row ) 571 { 572 573 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 574 ::osl::MutexGuard aGuard( m_aMutex ); 575 576 577 m_nCurrentFetchState = N3SQLFetchScroll(m_aStatementHandle,SQL_FETCH_ABSOLUTE,row); 578 OTools::ThrowException(m_pConnection,m_nCurrentFetchState,m_aStatementHandle,SQL_HANDLE_STMT,*this); 579 sal_Bool bRet = m_nCurrentFetchState == SQL_SUCCESS || m_nCurrentFetchState == SQL_SUCCESS_WITH_INFO; 580 if(bRet) 581 m_nRowPos = row; 582 return bRet; 583 } 584 // ------------------------------------------------------------------------- 585 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::relative( sal_Int32 row ) 586 { 587 588 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 589 ::osl::MutexGuard aGuard( m_aMutex ); 590 591 592 m_nCurrentFetchState = N3SQLFetchScroll(m_aStatementHandle,SQL_FETCH_RELATIVE,row); 593 OTools::ThrowException(m_pConnection,m_nCurrentFetchState,m_aStatementHandle,SQL_HANDLE_STMT,*this); 594 sal_Bool bRet = m_nCurrentFetchState == SQL_SUCCESS || m_nCurrentFetchState == SQL_SUCCESS_WITH_INFO; 595 if(bRet) 596 m_nRowPos += row; 597 return bRet; 598 } 599 // ------------------------------------------------------------------------- 600 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::previous( ) 601 { 602 603 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 604 ::osl::MutexGuard aGuard( m_aMutex ); 605 606 607 m_nCurrentFetchState = N3SQLFetchScroll(m_aStatementHandle,SQL_FETCH_PRIOR,0); 608 OTools::ThrowException(m_pConnection,m_nCurrentFetchState,m_aStatementHandle,SQL_HANDLE_STMT,*this); 609 sal_Bool bRet = m_nCurrentFetchState == SQL_SUCCESS || m_nCurrentFetchState == SQL_SUCCESS_WITH_INFO; 610 if(bRet) 611 --m_nRowPos; 612 return bRet; 613 } 614 // ------------------------------------------------------------------------- 615 Reference< XInterface > SAL_CALL ODatabaseMetaDataResultSet::getStatement( ) 616 { 617 return NULL; 618 } 619 // ------------------------------------------------------------------------- 620 621 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::rowDeleted( ) 622 { 623 624 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 625 ::osl::MutexGuard aGuard( m_aMutex ); 626 627 628 return m_pRowStatusArray[0] == SQL_ROW_DELETED; 629 } 630 // ------------------------------------------------------------------------- 631 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::rowInserted( ) 632 { 633 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 634 ::osl::MutexGuard aGuard( m_aMutex ); 635 636 637 return m_pRowStatusArray[0] == SQL_ROW_ADDED; 638 } 639 // ------------------------------------------------------------------------- 640 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::rowUpdated( ) 641 { 642 643 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 644 ::osl::MutexGuard aGuard( m_aMutex ); 645 646 647 return m_pRowStatusArray[0] == SQL_ROW_UPDATED; 648 } 649 // ------------------------------------------------------------------------- 650 651 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isBeforeFirst( ) 652 { 653 654 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 655 ::osl::MutexGuard aGuard( m_aMutex ); 656 657 658 return m_nRowPos == 0; 659 } 660 // ------------------------------------------------------------------------- 661 662 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::next( ) 663 { 664 665 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 666 ::osl::MutexGuard aGuard( m_aMutex ); 667 668 669 // m_nCurrentFetchState = N3SQLFetchScroll(m_aStatementHandle,SQL_FETCH_NEXT,0); 670 m_nCurrentFetchState = N3SQLFetch(m_aStatementHandle); 671 OTools::ThrowException(m_pConnection,m_nCurrentFetchState,m_aStatementHandle,SQL_HANDLE_STMT,*this); 672 return m_nCurrentFetchState == SQL_SUCCESS || m_nCurrentFetchState == SQL_SUCCESS_WITH_INFO; 673 } 674 // ------------------------------------------------------------------------- 675 676 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::wasNull( ) 677 { 678 679 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 680 ::osl::MutexGuard aGuard( m_aMutex ); 681 682 683 return m_bWasNull; 684 } 685 // ------------------------------------------------------------------------- 686 void SAL_CALL ODatabaseMetaDataResultSet::refreshRow( ) 687 { 688 689 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 690 ::osl::MutexGuard aGuard( m_aMutex ); 691 692 } 693 // ------------------------------------------------------------------------- 694 695 void SAL_CALL ODatabaseMetaDataResultSet::cancel( ) 696 { 697 698 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed); 699 ::osl::MutexGuard aGuard( m_aMutex ); 700 701 702 OTools::ThrowException(m_pConnection,N3SQLCancel(m_aStatementHandle),m_aStatementHandle,SQL_HANDLE_STMT,*this); 703 } 704 // ------------------------------------------------------------------------- 705 void SAL_CALL ODatabaseMetaDataResultSet::clearWarnings( ) 706 { 707 } 708 // ------------------------------------------------------------------------- 709 Any SAL_CALL ODatabaseMetaDataResultSet::getWarnings( ) 710 { 711 return Any(); 712 } 713 //------------------------------------------------------------------------------ 714 sal_Int32 ODatabaseMetaDataResultSet::getResultSetConcurrency() const 715 { 716 return ResultSetConcurrency::READ_ONLY; 717 } 718 //------------------------------------------------------------------------------ 719 sal_Int32 ODatabaseMetaDataResultSet::getResultSetType() const 720 { 721 return ResultSetType::FORWARD_ONLY; 722 } 723 //------------------------------------------------------------------------------ 724 sal_Int32 ODatabaseMetaDataResultSet::getFetchDirection() const 725 { 726 return FetchDirection::FORWARD; 727 } 728 //------------------------------------------------------------------------------ 729 sal_Int32 ODatabaseMetaDataResultSet::getFetchSize() const 730 { 731 sal_Int32 nValue=1; 732 return nValue; 733 } 734 //------------------------------------------------------------------------------ 735 ::rtl::OUString ODatabaseMetaDataResultSet::getCursorName() const 736 { 737 return ::rtl::OUString(); 738 } 739 740 // ------------------------------------------------------------------------- 741 ::cppu::IPropertyArrayHelper* ODatabaseMetaDataResultSet::createArrayHelper( ) const 742 { 743 744 Sequence< com::sun::star::beans::Property > aProps(5); 745 com::sun::star::beans::Property* pProperties = aProps.getArray(); 746 sal_Int32 nPos = 0; 747 DECL_PROP0(CURSORNAME, ::rtl::OUString); 748 DECL_PROP0(FETCHDIRECTION, sal_Int32); 749 DECL_PROP0(FETCHSIZE, sal_Int32); 750 DECL_PROP0(RESULTSETCONCURRENCY,sal_Int32); 751 DECL_PROP0(RESULTSETTYPE, sal_Int32); 752 753 return new ::cppu::OPropertyArrayHelper(aProps); 754 } 755 // ------------------------------------------------------------------------- 756 ::cppu::IPropertyArrayHelper & ODatabaseMetaDataResultSet::getInfoHelper() 757 { 758 return *const_cast<ODatabaseMetaDataResultSet*>(this)->getArrayHelper(); 759 } 760 // ------------------------------------------------------------------------- 761 sal_Bool ODatabaseMetaDataResultSet::convertFastPropertyValue( 762 Any & rConvertedValue, 763 Any & rOldValue, 764 sal_Int32 nHandle, 765 const Any& rValue ) 766 { 767 switch(nHandle) 768 { 769 case PROPERTY_ID_CURSORNAME: 770 case PROPERTY_ID_RESULTSETCONCURRENCY: 771 case PROPERTY_ID_RESULTSETTYPE: 772 throw ::com::sun::star::lang::IllegalArgumentException(); 773 case PROPERTY_ID_FETCHDIRECTION: 774 return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchDirection()); 775 case PROPERTY_ID_FETCHSIZE: 776 return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchSize()); 777 default: 778 ; 779 } 780 return sal_False; 781 } 782 // ------------------------------------------------------------------------- 783 void ODatabaseMetaDataResultSet::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const Any& /*rValue*/ ) 784 { 785 switch(nHandle) 786 { 787 case PROPERTY_ID_CURSORNAME: 788 case PROPERTY_ID_RESULTSETCONCURRENCY: 789 case PROPERTY_ID_RESULTSETTYPE: 790 case PROPERTY_ID_FETCHDIRECTION: 791 case PROPERTY_ID_FETCHSIZE: 792 throw Exception(); 793 default: 794 OSL_ENSURE(0,"setFastPropertyValue_NoBroadcast: Illegal handle value!"); 795 } 796 } 797 // ------------------------------------------------------------------------- 798 void ODatabaseMetaDataResultSet::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const 799 { 800 switch(nHandle) 801 { 802 case PROPERTY_ID_CURSORNAME: 803 rValue <<= getCursorName(); 804 break; 805 case PROPERTY_ID_RESULTSETCONCURRENCY: 806 rValue <<= getResultSetConcurrency(); 807 break; 808 case PROPERTY_ID_RESULTSETTYPE: 809 rValue <<= getResultSetType(); 810 break; 811 case PROPERTY_ID_FETCHDIRECTION: 812 rValue <<= getFetchDirection(); 813 break; 814 case PROPERTY_ID_FETCHSIZE: 815 rValue <<= getFetchSize(); 816 break; 817 } 818 } 819 // ------------------------------------------------------------------------- 820 void ODatabaseMetaDataResultSet::openTypeInfo() 821 { 822 TInt2IntMap aMap; 823 aMap[SQL_BIT] = DataType::BIT; 824 aMap[SQL_TINYINT] = DataType::TINYINT; 825 aMap[SQL_SMALLINT] = DataType::SMALLINT; 826 aMap[SQL_INTEGER] = DataType::INTEGER; 827 aMap[SQL_FLOAT] = DataType::FLOAT; 828 aMap[SQL_REAL] = DataType::REAL; 829 aMap[SQL_DOUBLE] = DataType::DOUBLE; 830 aMap[SQL_BIGINT] = DataType::BIGINT; 831 832 aMap[SQL_CHAR] = DataType::CHAR; 833 aMap[SQL_WCHAR] = DataType::CHAR; 834 aMap[SQL_VARCHAR] = DataType::VARCHAR; 835 aMap[SQL_WVARCHAR] = DataType::VARCHAR; 836 aMap[SQL_LONGVARCHAR] = DataType::LONGVARCHAR; 837 aMap[SQL_WLONGVARCHAR] = DataType::LONGVARCHAR; 838 839 aMap[SQL_TYPE_DATE] = DataType::DATE; 840 aMap[SQL_DATE] = DataType::DATE; 841 aMap[SQL_TYPE_TIME] = DataType::TIME; 842 aMap[SQL_TIME] = DataType::TIME; 843 aMap[SQL_TYPE_TIMESTAMP] = DataType::TIMESTAMP; 844 aMap[SQL_TIMESTAMP] = DataType::TIMESTAMP; 845 846 aMap[SQL_DECIMAL] = DataType::DECIMAL; 847 aMap[SQL_NUMERIC] = DataType::NUMERIC; 848 849 aMap[SQL_BINARY] = DataType::BINARY; 850 aMap[SQL_VARBINARY] = DataType::VARBINARY; 851 aMap[SQL_LONGVARBINARY] = DataType::LONGVARBINARY; 852 853 aMap[SQL_GUID] = DataType::VARBINARY; 854 855 856 m_aValueRange[2] = aMap; 857 858 OTools::ThrowException(m_pConnection,N3SQLGetTypeInfo(m_aStatementHandle, SQL_ALL_TYPES),m_aStatementHandle,SQL_HANDLE_STMT,*this); 859 checkColumnCount(); 860 } 861 //----------------------------------------------------------------------------- 862 void ODatabaseMetaDataResultSet::openTables(const Any& catalog, const ::rtl::OUString& schemaPattern, 863 const ::rtl::OUString& tableNamePattern, 864 const Sequence< ::rtl::OUString >& types ) 865 { 866 m_bFreeHandle = sal_True; 867 ::rtl::OString aPKQ,aPKO,aPKN,aCOL; 868 const ::rtl::OUString *pSchemaPat = NULL; 869 870 if(schemaPattern.toChar() != '%') 871 pSchemaPat = &schemaPattern; 872 else 873 pSchemaPat = NULL; 874 875 if ( catalog.hasValue() ) 876 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding); 877 aPKO = ::rtl::OUStringToOString(schemaPattern,m_nTextEncoding); 878 879 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL, 880 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL, 881 *pPKN = (aPKN = ::rtl::OUStringToOString(tableNamePattern,m_nTextEncoding)).getStr(); 882 883 884 const char *pCOL = NULL; 885 const char* pComma = ","; 886 const ::rtl::OUString* pBegin = types.getConstArray(); 887 const ::rtl::OUString* pEnd = pBegin + types.getLength(); 888 for(;pBegin != pEnd;++pBegin) 889 { 890 aCOL += ::rtl::OUStringToOString(*pBegin,m_nTextEncoding); 891 aCOL += pComma; 892 } 893 if ( aCOL.getLength() ) 894 { 895 aCOL = aCOL.replaceAt(aCOL.getLength()-1,1,pComma); 896 pCOL = aCOL.getStr(); 897 } 898 else 899 pCOL = SQL_ALL_TABLE_TYPES; 900 901 SQLRETURN nRetcode = N3SQLTables(m_aStatementHandle, 902 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0, 903 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0, 904 (SDB_ODBC_CHAR *) pPKN, SQL_NTS, 905 (SDB_ODBC_CHAR *) pCOL, pCOL ? SQL_NTS : 0); 906 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this); 907 checkColumnCount(); 908 909 } 910 //----------------------------------------------------------------------------- 911 void ODatabaseMetaDataResultSet::openTablesTypes( ) 912 { 913 m_bFreeHandle = sal_True; 914 SQLRETURN nRetcode = N3SQLTables(m_aStatementHandle, 915 0,0, 916 0,0, 917 0,0, 918 (SDB_ODBC_CHAR *) SQL_ALL_TABLE_TYPES,SQL_NTS); 919 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this); 920 921 m_aColMapping.clear(); 922 m_aColMapping.push_back(-1); 923 m_aColMapping.push_back(4); 924 m_xMetaData = new OResultSetMetaData(m_pConnection,m_aStatementHandle,m_aColMapping); 925 checkColumnCount(); 926 } 927 // ------------------------------------------------------------------------- 928 void ODatabaseMetaDataResultSet::openCatalogs() 929 { 930 m_bFreeHandle = sal_True; 931 SQLRETURN nRetcode = N3SQLTables(m_aStatementHandle, 932 (SDB_ODBC_CHAR *) SQL_ALL_CATALOGS,SQL_NTS, 933 (SDB_ODBC_CHAR *) "",SQL_NTS, 934 (SDB_ODBC_CHAR *) "",SQL_NTS, 935 (SDB_ODBC_CHAR *) "",SQL_NTS); 936 937 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this); 938 939 m_aColMapping.clear(); 940 m_aColMapping.push_back(-1); 941 m_aColMapping.push_back(1); 942 m_xMetaData = new OResultSetMetaData(m_pConnection,m_aStatementHandle,m_aColMapping); 943 checkColumnCount(); 944 } 945 // ------------------------------------------------------------------------- 946 void ODatabaseMetaDataResultSet::openSchemas() 947 { 948 m_bFreeHandle = sal_True; 949 SQLRETURN nRetcode = N3SQLTables(m_aStatementHandle, 950 (SDB_ODBC_CHAR *) "",SQL_NTS, 951 (SDB_ODBC_CHAR *) SQL_ALL_SCHEMAS,SQL_NTS, 952 (SDB_ODBC_CHAR *) "",SQL_NTS, 953 (SDB_ODBC_CHAR *) "",SQL_NTS); 954 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this); 955 956 m_aColMapping.clear(); 957 m_aColMapping.push_back(-1); 958 m_aColMapping.push_back(2); 959 m_xMetaData = new OResultSetMetaData(m_pConnection,m_aStatementHandle,m_aColMapping); 960 checkColumnCount(); 961 } 962 // ------------------------------------------------------------------------- 963 void ODatabaseMetaDataResultSet::openColumnPrivileges( const Any& catalog, const ::rtl::OUString& schema, 964 const ::rtl::OUString& table, const ::rtl::OUString& columnNamePattern ) 965 { 966 const ::rtl::OUString *pSchemaPat = NULL; 967 968 if(schema.toChar() != '%') 969 pSchemaPat = &schema; 970 else 971 pSchemaPat = NULL; 972 973 m_bFreeHandle = sal_True; 974 ::rtl::OString aPKQ,aPKO,aPKN,aCOL; 975 976 if ( catalog.hasValue() ) 977 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding); 978 aPKO = ::rtl::OUStringToOString(schema,m_nTextEncoding); 979 980 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL, 981 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL, 982 *pPKN = (aPKN = ::rtl::OUStringToOString(table,m_nTextEncoding)).getStr(), 983 *pCOL = (aCOL = ::rtl::OUStringToOString(columnNamePattern,m_nTextEncoding)).getStr(); 984 985 986 SQLRETURN nRetcode = N3SQLColumnPrivileges(m_aStatementHandle, 987 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0, 988 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0 , 989 (SDB_ODBC_CHAR *) pPKN, SQL_NTS, 990 (SDB_ODBC_CHAR *) pCOL, SQL_NTS); 991 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this); 992 993 checkColumnCount(); 994 } 995 // ------------------------------------------------------------------------- 996 void ODatabaseMetaDataResultSet::openColumns( const Any& catalog, const ::rtl::OUString& schemaPattern, 997 const ::rtl::OUString& tableNamePattern, const ::rtl::OUString& columnNamePattern ) 998 { 999 const ::rtl::OUString *pSchemaPat = NULL; 1000 1001 if(schemaPattern.toChar() != '%') 1002 pSchemaPat = &schemaPattern; 1003 else 1004 pSchemaPat = NULL; 1005 1006 m_bFreeHandle = sal_True; 1007 ::rtl::OString aPKQ,aPKO,aPKN,aCOL; 1008 if ( catalog.hasValue() ) 1009 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding); 1010 aPKO = ::rtl::OUStringToOString(schemaPattern,m_nTextEncoding); 1011 1012 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL, 1013 *pPKO = pSchemaPat && pSchemaPat->getLength() && pSchemaPat->getLength() ? aPKO.getStr() : NULL, 1014 *pPKN = (aPKN = ::rtl::OUStringToOString(tableNamePattern,m_nTextEncoding)).getStr(), 1015 *pCOL = (aCOL = ::rtl::OUStringToOString(columnNamePattern,m_nTextEncoding)).getStr(); 1016 1017 1018 SQLRETURN nRetcode = N3SQLColumns(m_aStatementHandle, 1019 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0, 1020 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0, 1021 (SDB_ODBC_CHAR *) pPKN, SQL_NTS, 1022 (SDB_ODBC_CHAR *) pCOL, SQL_NTS); 1023 1024 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this); 1025 TInt2IntMap aMap; 1026 aMap[SQL_BIT] = DataType::BIT; 1027 aMap[SQL_TINYINT] = DataType::TINYINT; 1028 aMap[SQL_SMALLINT] = DataType::SMALLINT; 1029 aMap[SQL_INTEGER] = DataType::INTEGER; 1030 aMap[SQL_FLOAT] = DataType::FLOAT; 1031 aMap[SQL_REAL] = DataType::REAL; 1032 aMap[SQL_DOUBLE] = DataType::DOUBLE; 1033 aMap[SQL_BIGINT] = DataType::BIGINT; 1034 1035 aMap[SQL_CHAR] = DataType::CHAR; 1036 aMap[SQL_WCHAR] = DataType::CHAR; 1037 aMap[SQL_VARCHAR] = DataType::VARCHAR; 1038 aMap[SQL_WVARCHAR] = DataType::VARCHAR; 1039 aMap[SQL_LONGVARCHAR] = DataType::LONGVARCHAR; 1040 aMap[SQL_WLONGVARCHAR] = DataType::LONGVARCHAR; 1041 1042 aMap[SQL_TYPE_DATE] = DataType::DATE; 1043 aMap[SQL_DATE] = DataType::DATE; 1044 aMap[SQL_TYPE_TIME] = DataType::TIME; 1045 aMap[SQL_TIME] = DataType::TIME; 1046 aMap[SQL_TYPE_TIMESTAMP] = DataType::TIMESTAMP; 1047 aMap[SQL_TIMESTAMP] = DataType::TIMESTAMP; 1048 1049 aMap[SQL_DECIMAL] = DataType::DECIMAL; 1050 aMap[SQL_NUMERIC] = DataType::NUMERIC; 1051 1052 aMap[SQL_BINARY] = DataType::BINARY; 1053 aMap[SQL_VARBINARY] = DataType::VARBINARY; 1054 aMap[SQL_LONGVARBINARY] = DataType::LONGVARBINARY; 1055 1056 aMap[SQL_GUID] = DataType::VARBINARY; 1057 1058 m_aValueRange[5] = aMap; 1059 checkColumnCount(); 1060 } 1061 // ------------------------------------------------------------------------- 1062 void ODatabaseMetaDataResultSet::openProcedureColumns( const Any& catalog, const ::rtl::OUString& schemaPattern, 1063 const ::rtl::OUString& procedureNamePattern,const ::rtl::OUString& columnNamePattern ) 1064 { 1065 const ::rtl::OUString *pSchemaPat = NULL; 1066 1067 if(schemaPattern.toChar() != '%') 1068 pSchemaPat = &schemaPattern; 1069 else 1070 pSchemaPat = NULL; 1071 1072 m_bFreeHandle = sal_True; 1073 ::rtl::OString aPKQ,aPKO,aPKN,aCOL; 1074 if ( catalog.hasValue() ) 1075 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding); 1076 aPKO = ::rtl::OUStringToOString(schemaPattern,m_nTextEncoding); 1077 1078 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL, 1079 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL, 1080 *pPKN = (aPKN = ::rtl::OUStringToOString(procedureNamePattern,m_nTextEncoding)).getStr(), 1081 *pCOL = (aCOL = ::rtl::OUStringToOString(columnNamePattern,m_nTextEncoding)).getStr(); 1082 1083 1084 SQLRETURN nRetcode = N3SQLProcedureColumns(m_aStatementHandle, 1085 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0, 1086 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0 , 1087 (SDB_ODBC_CHAR *) pPKN, SQL_NTS, 1088 (SDB_ODBC_CHAR *) pCOL, SQL_NTS); 1089 1090 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this); 1091 checkColumnCount(); 1092 } 1093 // ------------------------------------------------------------------------- 1094 void ODatabaseMetaDataResultSet::openProcedures(const Any& catalog, const ::rtl::OUString& schemaPattern, 1095 const ::rtl::OUString& procedureNamePattern) 1096 { 1097 const ::rtl::OUString *pSchemaPat = NULL; 1098 1099 if(schemaPattern.toChar() != '%') 1100 pSchemaPat = &schemaPattern; 1101 else 1102 pSchemaPat = NULL; 1103 1104 m_bFreeHandle = sal_True; 1105 ::rtl::OString aPKQ,aPKO,aPKN,aCOL; 1106 1107 if ( catalog.hasValue() ) 1108 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding); 1109 aPKO = ::rtl::OUStringToOString(schemaPattern,m_nTextEncoding); 1110 1111 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL, 1112 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL, 1113 *pPKN = (aPKN = ::rtl::OUStringToOString(procedureNamePattern,m_nTextEncoding)).getStr(); 1114 1115 1116 SQLRETURN nRetcode = N3SQLProcedures(m_aStatementHandle, 1117 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0, 1118 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0 , 1119 (SDB_ODBC_CHAR *) pPKN, SQL_NTS); 1120 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this); 1121 checkColumnCount(); 1122 } 1123 // ------------------------------------------------------------------------- 1124 void ODatabaseMetaDataResultSet::openSpecialColumns(sal_Bool _bRowVer,const Any& catalog, const ::rtl::OUString& schema, 1125 const ::rtl::OUString& table,sal_Int32 scope, sal_Bool nullable ) 1126 { 1127 const ::rtl::OUString *pSchemaPat = NULL; 1128 1129 if(schema.toChar() != '%') 1130 pSchemaPat = &schema; 1131 else 1132 pSchemaPat = NULL; 1133 1134 m_bFreeHandle = sal_True; 1135 ::rtl::OString aPKQ,aPKO,aPKN,aCOL; 1136 if ( catalog.hasValue() ) 1137 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding); 1138 aPKO = ::rtl::OUStringToOString(schema,m_nTextEncoding); 1139 1140 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL, 1141 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL, 1142 *pPKN = (aPKN = ::rtl::OUStringToOString(table,m_nTextEncoding)).getStr(); 1143 1144 1145 SQLRETURN nRetcode = N3SQLSpecialColumns(m_aStatementHandle,_bRowVer ? SQL_ROWVER : SQL_BEST_ROWID, 1146 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0, 1147 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0 , 1148 (SDB_ODBC_CHAR *) pPKN, SQL_NTS, 1149 (SQLSMALLINT)scope, 1150 nullable ? SQL_NULLABLE : SQL_NO_NULLS); 1151 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this); 1152 checkColumnCount(); 1153 } 1154 // ------------------------------------------------------------------------- 1155 void ODatabaseMetaDataResultSet::openVersionColumns(const Any& catalog, const ::rtl::OUString& schema, 1156 const ::rtl::OUString& table) 1157 { 1158 openSpecialColumns(sal_True,catalog,schema,table,SQL_SCOPE_TRANSACTION,sal_False); 1159 } 1160 // ------------------------------------------------------------------------- 1161 void ODatabaseMetaDataResultSet::openBestRowIdentifier( const Any& catalog, const ::rtl::OUString& schema, 1162 const ::rtl::OUString& table,sal_Int32 scope,sal_Bool nullable ) 1163 { 1164 openSpecialColumns(sal_False,catalog,schema,table,scope,nullable); 1165 } 1166 // ------------------------------------------------------------------------- 1167 void ODatabaseMetaDataResultSet::openForeignKeys( const Any& catalog, const ::rtl::OUString* schema, 1168 const ::rtl::OUString* table, 1169 const Any& catalog2, const ::rtl::OUString* schema2, 1170 const ::rtl::OUString* table2) 1171 { 1172 m_bFreeHandle = sal_True; 1173 1174 ::rtl::OString aPKQ,aPKO,aPKN, aFKQ, aFKO, aFKN; 1175 if ( catalog.hasValue() ) 1176 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding); 1177 if ( catalog2.hasValue() ) 1178 aFKQ = ::rtl::OUStringToOString(comphelper::getString(catalog2),m_nTextEncoding); 1179 1180 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL, 1181 *pPKO = schema && schema->getLength() ? ::rtl::OUStringToOString(*schema,m_nTextEncoding).getStr() : NULL, 1182 *pPKN = table ? (aPKN = ::rtl::OUStringToOString(*table,m_nTextEncoding)).getStr(): NULL, 1183 *pFKQ = catalog2.hasValue() && aFKQ.getLength() ? aFKQ.getStr() : NULL, 1184 *pFKO = schema2 && schema2->getLength() ? (aFKO = ::rtl::OUStringToOString(*schema2,m_nTextEncoding)).getStr() : NULL, 1185 *pFKN = table2 ? (aFKN = ::rtl::OUStringToOString(*table2,m_nTextEncoding)).getStr() : NULL; 1186 1187 1188 SQLRETURN nRetcode = N3SQLForeignKeys(m_aStatementHandle, 1189 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0, 1190 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0, 1191 (SDB_ODBC_CHAR *) pPKN, pPKN ? SQL_NTS : 0, 1192 (SDB_ODBC_CHAR *) pFKQ, (catalog2.hasValue() && aFKQ.getLength()) ? SQL_NTS : 0, 1193 (SDB_ODBC_CHAR *) pFKO, pFKO ? SQL_NTS : 0, 1194 (SDB_ODBC_CHAR *) pFKN, SQL_NTS 1195 ); 1196 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this); 1197 checkColumnCount(); 1198 } 1199 // ------------------------------------------------------------------------- 1200 void ODatabaseMetaDataResultSet::openImportedKeys(const Any& catalog, const ::rtl::OUString& schema, 1201 const ::rtl::OUString& table) 1202 { 1203 1204 openForeignKeys(Any(),NULL,NULL,catalog,!schema.compareToAscii("%") ? &schema : NULL,&table); 1205 } 1206 // ------------------------------------------------------------------------- 1207 void ODatabaseMetaDataResultSet::openExportedKeys(const Any& catalog, const ::rtl::OUString& schema, 1208 const ::rtl::OUString& table) 1209 { 1210 openForeignKeys(catalog,!schema.compareToAscii("%") ? &schema : NULL,&table,Any(),NULL,NULL); 1211 } 1212 // ------------------------------------------------------------------------- 1213 void ODatabaseMetaDataResultSet::openPrimaryKeys(const Any& catalog, const ::rtl::OUString& schema, 1214 const ::rtl::OUString& table) 1215 { 1216 const ::rtl::OUString *pSchemaPat = NULL; 1217 1218 if(schema.toChar() != '%') 1219 pSchemaPat = &schema; 1220 else 1221 pSchemaPat = NULL; 1222 1223 m_bFreeHandle = sal_True; 1224 ::rtl::OString aPKQ,aPKO,aPKN,aCOL; 1225 1226 if ( catalog.hasValue() ) 1227 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding); 1228 aPKO = ::rtl::OUStringToOString(schema,m_nTextEncoding); 1229 1230 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL, 1231 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL, 1232 *pPKN = (aPKN = ::rtl::OUStringToOString(table,m_nTextEncoding)).getStr(); 1233 1234 1235 SQLRETURN nRetcode = N3SQLPrimaryKeys(m_aStatementHandle, 1236 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0, 1237 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0 , 1238 (SDB_ODBC_CHAR *) pPKN, SQL_NTS); 1239 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this); 1240 checkColumnCount(); 1241 } 1242 // ------------------------------------------------------------------------- 1243 void ODatabaseMetaDataResultSet::openTablePrivileges(const Any& catalog, const ::rtl::OUString& schemaPattern, 1244 const ::rtl::OUString& tableNamePattern) 1245 { 1246 const ::rtl::OUString *pSchemaPat = NULL; 1247 1248 if(schemaPattern.toChar() != '%') 1249 pSchemaPat = &schemaPattern; 1250 else 1251 pSchemaPat = NULL; 1252 1253 m_bFreeHandle = sal_True; 1254 ::rtl::OString aPKQ,aPKO,aPKN; 1255 1256 if ( catalog.hasValue() ) 1257 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding); 1258 aPKO = ::rtl::OUStringToOString(schemaPattern,m_nTextEncoding); 1259 1260 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL, 1261 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL, 1262 *pPKN = (aPKN = ::rtl::OUStringToOString(tableNamePattern,m_nTextEncoding)).getStr(); 1263 1264 1265 SQLRETURN nRetcode = N3SQLTablePrivileges(m_aStatementHandle, 1266 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0, 1267 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0 , 1268 (SDB_ODBC_CHAR *) pPKN, SQL_NTS); 1269 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this); 1270 checkColumnCount(); 1271 } 1272 // ------------------------------------------------------------------------- 1273 void ODatabaseMetaDataResultSet::openIndexInfo( const Any& catalog, const ::rtl::OUString& schema, 1274 const ::rtl::OUString& table,sal_Bool unique,sal_Bool approximate ) 1275 { 1276 const ::rtl::OUString *pSchemaPat = NULL; 1277 1278 if(schema.toChar() != '%') 1279 pSchemaPat = &schema; 1280 else 1281 pSchemaPat = NULL; 1282 1283 m_bFreeHandle = sal_True; 1284 ::rtl::OString aPKQ,aPKO,aPKN; 1285 1286 if ( catalog.hasValue() ) 1287 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding); 1288 aPKO = ::rtl::OUStringToOString(schema,m_nTextEncoding); 1289 1290 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL, 1291 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL, 1292 *pPKN = (aPKN = ::rtl::OUStringToOString(table,m_nTextEncoding)).getStr(); 1293 1294 1295 SQLRETURN nRetcode = N3SQLStatistics(m_aStatementHandle, 1296 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0, 1297 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0 , 1298 (SDB_ODBC_CHAR *) pPKN, SQL_NTS, 1299 unique ? SQL_INDEX_UNIQUE : SQL_INDEX_ALL, 1300 approximate); 1301 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this); 1302 checkColumnCount(); 1303 } 1304 // ------------------------------------------------------------------------- 1305 void ODatabaseMetaDataResultSet::checkColumnCount() 1306 { 1307 sal_Int16 nNumResultCols=0; 1308 OTools::ThrowException(m_pConnection,N3SQLNumResultCols(m_aStatementHandle,&nNumResultCols),m_aStatementHandle,SQL_HANDLE_STMT,*this); 1309 m_nDriverColumnCount = nNumResultCols; 1310 } 1311 // ----------------------------------------------------------------------------- 1312 1313 SWORD ODatabaseMetaDataResultSet::impl_getColumnType_nothrow(sal_Int32 columnIndex) 1314 { 1315 ::std::map<sal_Int32,SWORD>::iterator aFind = m_aODBCColumnTypes.find(columnIndex); 1316 if ( aFind == m_aODBCColumnTypes.end() ) 1317 aFind = m_aODBCColumnTypes.insert(::std::map<sal_Int32,SWORD>::value_type(columnIndex,OResultSetMetaData::getColumnODBCType(m_pConnection,m_aStatementHandle,*this,columnIndex))).first; 1318 return aFind->second; 1319 } 1320