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_dbtools.hxx" 26 27 #include "connectivity/CommonTools.hxx" 28 #include "diagnose_ex.h" 29 #include "TConnection.hxx" 30 #include "connectivity/ParameterCont.hxx" 31 32 /** === begin UNO includes === **/ 33 #include <com/sun/star/awt/XWindow.hpp> 34 #include <com/sun/star/beans/PropertyAttribute.hpp> 35 #include <com/sun/star/container/XChild.hpp> 36 #include <com/sun/star/form/FormComponentType.hpp> 37 #include <com/sun/star/io/XInputStream.hpp> 38 #include <com/sun/star/lang/DisposedException.hpp> 39 #include <com/sun/star/lang/XMultiServiceFactory.hpp> 40 #include <com/sun/star/sdb/BooleanComparisonMode.hpp> 41 #include <com/sun/star/sdb/CommandType.hpp> 42 #include <com/sun/star/sdb/ParametersRequest.hpp> 43 #include <com/sun/star/sdb/RowSetVetoException.hpp> 44 #include <com/sun/star/sdb/SQLContext.hpp> 45 #include <com/sun/star/sdb/XCompletedConnection.hpp> 46 #include <com/sun/star/sdb/XInteractionSupplyParameters.hpp> 47 #include <com/sun/star/sdb/XOfficeDatabaseDocument.hpp> 48 #include <com/sun/star/sdb/XParametersSupplier.hpp> 49 #include <com/sun/star/sdb/XQueriesSupplier.hpp> 50 #include <com/sun/star/sdb/XSingleSelectQueryComposer.hpp> 51 #include <com/sun/star/sdbc/DataType.hpp> 52 #include <com/sun/star/sdbc/XConnection.hpp> 53 #include <com/sun/star/sdbc/XDataSource.hpp> 54 #include <com/sun/star/sdbc/XDriverManager.hpp> 55 #include <com/sun/star/sdbc/XParameters.hpp> 56 #include <com/sun/star/sdbc/XRow.hpp> 57 #include <com/sun/star/sdbc/XRowSet.hpp> 58 #include <com/sun/star/sdbc/XRowUpdate.hpp> 59 #include <com/sun/star/sdbcx/KeyType.hpp> 60 #include <com/sun/star/sdbcx/Privilege.hpp> 61 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp> 62 #include <com/sun/star/sdbcx/XKeysSupplier.hpp> 63 #include <com/sun/star/sdbcx/XTablesSupplier.hpp> 64 #include <com/sun/star/task/XInteractionHandler.hpp> 65 #include <com/sun/star/task/XInteractionRequest.hpp> 66 #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp> 67 #include <com/sun/star/uno/XNamingService.hpp> 68 #include <com/sun/star/util/NumberFormat.hpp> 69 #include <com/sun/star/util/XNumberFormatsSupplier.hpp> 70 #include <com/sun/star/util/XNumberFormatTypes.hpp> 71 /** === end UNO includes === **/ 72 73 #include <comphelper/extract.hxx> 74 #include <comphelper/interaction.hxx> 75 #include <comphelper/property.hxx> 76 #include <connectivity/conncleanup.hxx> 77 #include <connectivity/dbconversion.hxx> 78 #include <connectivity/dbexception.hxx> 79 #include <connectivity/dbtools.hxx> 80 #include <connectivity/statementcomposer.hxx> 81 #include <osl/diagnose.h> 82 #include <rtl/ustrbuf.hxx> 83 #include <tools/diagnose_ex.h> 84 85 #include "resource/common_res.hrc" 86 #include "resource/sharedresources.hxx" 87 #include "OSubComponent.hxx" 88 89 #include <algorithm> 90 #include <iterator> 91 92 using namespace ::comphelper; 93 using namespace ::com::sun::star::uno; 94 using namespace ::com::sun::star::io; 95 using namespace ::com::sun::star::awt; 96 using namespace ::com::sun::star::ui::dialogs; 97 using namespace ::com::sun::star::util; 98 using namespace ::com::sun::star::lang; 99 using namespace ::com::sun::star::beans; 100 using namespace ::com::sun::star::container; 101 using namespace ::com::sun::star::sdb; 102 using namespace ::com::sun::star::sdbc; 103 using namespace ::com::sun::star::sdbcx; 104 using namespace ::com::sun::star::form; 105 using namespace connectivity; 106 107 //......................................................................... 108 namespace dbtools 109 { 110 //......................................................................... 111 112 using namespace ::com::sun::star::uno; 113 using namespace ::com::sun::star::beans; 114 using namespace ::com::sun::star::util; 115 using namespace ::com::sun::star::task; 116 using namespace ::com::sun::star::uno; 117 using namespace ::com::sun::star::lang; 118 using namespace ::com::sun::star::sdbc; 119 using namespace ::com::sun::star::task; 120 // using namespace cppu; 121 // using namespace osl; 122 123 //============================================================================== 124 //============================================================================== 125 namespace 126 { 127 typedef sal_Bool (SAL_CALL XDatabaseMetaData::*FMetaDataSupport)(); 128 } 129 //============================================================================== 130 //============================================================================== 131 sal_Int32 getDefaultNumberFormat(const Reference< XPropertySet >& _xColumn, 132 const Reference< XNumberFormatTypes >& _xTypes, 133 const Locale& _rLocale) 134 { 135 OSL_ENSURE(_xTypes.is() && _xColumn.is(), "dbtools::getDefaultNumberFormat: invalid arg !"); 136 if (!_xTypes.is() || !_xColumn.is()) 137 return NumberFormat::UNDEFINED; 138 139 sal_Int32 nDataType = 0; 140 sal_Int32 nScale = 0; 141 try 142 { 143 // determine the datatype of the column 144 _xColumn->getPropertyValue(::rtl::OUString::createFromAscii("Type")) >>= nDataType; 145 146 if (DataType::NUMERIC == nDataType || DataType::DECIMAL == nDataType) 147 _xColumn->getPropertyValue(::rtl::OUString::createFromAscii("Scale")) >>= nScale; 148 } 149 catch (Exception&) 150 { 151 return NumberFormat::UNDEFINED; 152 } 153 return getDefaultNumberFormat(nDataType, 154 nScale, 155 ::cppu::any2bool(_xColumn->getPropertyValue(::rtl::OUString::createFromAscii("IsCurrency"))), 156 _xTypes, 157 _rLocale); 158 } 159 160 //------------------------------------------------------------------ 161 sal_Int32 getDefaultNumberFormat(sal_Int32 _nDataType, 162 sal_Int32 _nScale, 163 sal_Bool _bIsCurrency, 164 const Reference< XNumberFormatTypes >& _xTypes, 165 const Locale& _rLocale) 166 { 167 OSL_ENSURE(_xTypes.is() , "dbtools::getDefaultNumberFormat: invalid arg !"); 168 if (!_xTypes.is()) 169 return NumberFormat::UNDEFINED; 170 171 sal_Int32 nFormat = 0; 172 sal_Int32 nNumberType = _bIsCurrency ? NumberFormat::CURRENCY : NumberFormat::NUMBER; 173 switch (_nDataType) 174 { 175 case DataType::BIT: 176 case DataType::BOOLEAN: 177 nFormat = _xTypes->getStandardFormat(NumberFormat::LOGICAL, _rLocale); 178 break; 179 case DataType::TINYINT: 180 case DataType::SMALLINT: 181 case DataType::INTEGER: 182 case DataType::BIGINT: 183 case DataType::FLOAT: 184 case DataType::REAL: 185 case DataType::DOUBLE: 186 case DataType::NUMERIC: 187 case DataType::DECIMAL: 188 { 189 try 190 { 191 nFormat = _xTypes->getStandardFormat((sal_Int16)nNumberType, _rLocale); 192 if(_nScale > 0) 193 { 194 // generate a new format if necessary 195 Reference< XNumberFormats > xFormats(_xTypes, UNO_QUERY); 196 ::rtl::OUString sNewFormat = xFormats->generateFormat( 0L, _rLocale, sal_False, sal_False, (sal_Int16)_nScale, sal_True); 197 198 // and add it to the formatter if necessary 199 nFormat = xFormats->queryKey(sNewFormat, _rLocale, sal_False); 200 if (nFormat == (sal_Int32)-1) 201 nFormat = xFormats->addNew(sNewFormat, _rLocale); 202 } 203 } 204 catch (Exception&) 205 { 206 nFormat = _xTypes->getStandardFormat((sal_Int16)nNumberType, _rLocale); 207 } 208 } break; 209 case DataType::CHAR: 210 case DataType::VARCHAR: 211 case DataType::LONGVARCHAR: 212 case DataType::CLOB: 213 nFormat = _xTypes->getStandardFormat(NumberFormat::TEXT, _rLocale); 214 break; 215 case DataType::DATE: 216 nFormat = _xTypes->getStandardFormat(NumberFormat::DATE, _rLocale); 217 break; 218 case DataType::TIME: 219 nFormat = _xTypes->getStandardFormat(NumberFormat::TIME, _rLocale); 220 break; 221 case DataType::TIMESTAMP: 222 nFormat = _xTypes->getStandardFormat(NumberFormat::DATETIME, _rLocale); 223 break; 224 case DataType::BINARY: 225 case DataType::VARBINARY: 226 case DataType::LONGVARBINARY: 227 case DataType::SQLNULL: 228 case DataType::OTHER: 229 case DataType::OBJECT: 230 case DataType::DISTINCT: 231 case DataType::STRUCT: 232 case DataType::ARRAY: 233 case DataType::BLOB: 234 case DataType::REF: 235 default: 236 nFormat = _xTypes->getStandardFormat(NumberFormat::UNDEFINED, _rLocale); 237 //nFormat = NumberFormat::UNDEFINED; 238 } 239 return nFormat; 240 } 241 242 //============================================================================== 243 //------------------------------------------------------------------------------ 244 Reference< XConnection> findConnection(const Reference< XInterface >& xParent) 245 { 246 Reference< XConnection> xConnection(xParent, UNO_QUERY); 247 if (!xConnection.is()) 248 { 249 Reference< XChild> xChild(xParent, UNO_QUERY); 250 if (xChild.is()) 251 xConnection = findConnection(xChild->getParent()); 252 } 253 return xConnection; 254 } 255 256 //------------------------------------------------------------------------------ 257 Reference< XDataSource> getDataSource_allowException( 258 const ::rtl::OUString& _rsTitleOrPath, 259 const Reference< XMultiServiceFactory >& _rxFactory ) 260 { 261 ENSURE_OR_RETURN( _rsTitleOrPath.getLength(), "getDataSource_allowException: invalid arg !", NULL ); 262 263 Reference< XNameAccess> xDatabaseContext( 264 _rxFactory->createInstance( 265 ::rtl::OUString::createFromAscii( "com.sun.star.sdb.DatabaseContext" ) ),UNO_QUERY ); 266 OSL_ENSURE( xDatabaseContext.is(), "getDataSource_allowException: could not obtain the database context!" ); 267 268 return Reference< XDataSource >( xDatabaseContext->getByName( _rsTitleOrPath ), UNO_QUERY ); 269 } 270 271 //------------------------------------------------------------------------------ 272 Reference< XDataSource > getDataSource( 273 const ::rtl::OUString& _rsTitleOrPath, 274 const Reference< XMultiServiceFactory >& _rxFactory ) 275 { 276 Reference< XDataSource > xDS; 277 try 278 { 279 xDS = getDataSource_allowException( _rsTitleOrPath, _rxFactory ); 280 } 281 catch( const Exception& ) 282 { 283 DBG_UNHANDLED_EXCEPTION(); 284 } 285 286 return xDS; 287 } 288 289 //------------------------------------------------------------------------------ 290 Reference< XConnection > getConnection_allowException( 291 const ::rtl::OUString& _rsTitleOrPath, 292 const ::rtl::OUString& _rsUser, 293 const ::rtl::OUString& _rsPwd, 294 const Reference< XMultiServiceFactory>& _rxFactory) 295 { 296 Reference< XDataSource> xDataSource( getDataSource_allowException(_rsTitleOrPath, _rxFactory) ); 297 Reference<XConnection> xConnection; 298 if (xDataSource.is()) 299 { 300 // do it with interaction handler 301 if(!_rsUser.getLength() || !_rsPwd.getLength()) 302 { 303 Reference<XPropertySet> xProp(xDataSource,UNO_QUERY); 304 ::rtl::OUString sPwd, sUser; 305 sal_Bool bPwdReq = sal_False; 306 try 307 { 308 xProp->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PASSWORD)) >>= sPwd; 309 bPwdReq = ::cppu::any2bool(xProp->getPropertyValue(::rtl::OUString::createFromAscii("IsPasswordRequired"))); 310 xProp->getPropertyValue(::rtl::OUString::createFromAscii("User")) >>= sUser; 311 } 312 catch(Exception&) 313 { 314 OSL_ENSURE(sal_False, "dbtools::getConnection: error while retrieving data source properties!"); 315 } 316 if(bPwdReq && !sPwd.getLength()) 317 { // password required, but empty -> connect using an interaction handler 318 Reference<XCompletedConnection> xConnectionCompletion(xProp, UNO_QUERY); 319 if (xConnectionCompletion.is()) 320 { // instantiate the default SDB interaction handler 321 Reference< XInteractionHandler > xHandler(_rxFactory->createInstance(::rtl::OUString::createFromAscii("com.sun.star.task.InteractionHandler")), UNO_QUERY); 322 OSL_ENSURE(xHandler.is(), "dbtools::getConnection service com.sun.star.task.InteractionHandler not available!"); 323 if (xHandler.is()) 324 { 325 xConnection = xConnectionCompletion->connectWithCompletion(xHandler); 326 } 327 } 328 } 329 else 330 xConnection = xDataSource->getConnection(sUser, sPwd); 331 } 332 if(!xConnection.is()) // try to get one if not already have one, just to make sure 333 xConnection = xDataSource->getConnection(_rsUser, _rsPwd); 334 } 335 return xConnection; 336 } 337 338 //------------------------------------------------------------------------------ 339 Reference< XConnection> getConnection_withFeedback(const ::rtl::OUString& _rDataSourceName, 340 const ::rtl::OUString& _rUser, const ::rtl::OUString& _rPwd, const Reference< XMultiServiceFactory>& _rxFactory) 341 { 342 Reference< XConnection > xReturn; 343 try 344 { 345 xReturn = getConnection_allowException(_rDataSourceName, _rUser, _rPwd, _rxFactory); 346 } 347 catch(SQLException&) 348 { 349 // allowed to pass 350 throw; 351 } 352 catch(Exception&) 353 { 354 OSL_ENSURE(sal_False, "::dbtools::getConnection_withFeedback: unexpected (non-SQL) exception caught!"); 355 } 356 return xReturn; 357 } 358 359 //------------------------------------------------------------------------------ 360 Reference< XConnection> getConnection( 361 const ::rtl::OUString& _rsTitleOrPath, 362 const ::rtl::OUString& _rsUser, 363 const ::rtl::OUString& _rsPwd, 364 const Reference< XMultiServiceFactory>& _rxFactory) 365 { 366 Reference< XConnection > xReturn; 367 try 368 { 369 xReturn = getConnection_allowException(_rsTitleOrPath, _rsUser, _rsPwd, _rxFactory); 370 } 371 catch(Exception&) 372 { 373 } 374 375 // TODO: if there were not dozens of places which rely on getConnection not throwing an exception .... 376 // I would change this ... 377 378 return xReturn; 379 } 380 381 //------------------------------------------------------------------------------ 382 Reference< XConnection> getConnection(const Reference< XRowSet>& _rxRowSet) 383 { 384 Reference< XConnection> xReturn; 385 Reference< XPropertySet> xRowSetProps(_rxRowSet, UNO_QUERY); 386 if (xRowSetProps.is()) 387 xRowSetProps->getPropertyValue(::rtl::OUString::createFromAscii("ActiveConnection")) >>= xReturn; 388 return xReturn; 389 } 390 391 //------------------------------------------------------------------------------ 392 // helper function which allows to implement both the connectRowset and the ensureRowSetConnection semantics 393 // if connectRowset (which is deprecated) is removed, this function and one of its parameters are 394 // not needed anymore, the whole implementation can be moved into ensureRowSetConnection then) 395 SharedConnection lcl_connectRowSet(const Reference< XRowSet>& _rxRowSet, const Reference< XMultiServiceFactory>& _rxFactory, 396 bool _bSetAsActiveConnection, bool _bAttachAutoDisposer ) 397 { 398 SharedConnection xConnection; 399 400 do 401 { 402 Reference< XPropertySet> xRowSetProps(_rxRowSet, UNO_QUERY); 403 if ( !xRowSetProps.is() ) 404 break; 405 406 // 1. already connected? 407 Reference< XConnection > xExistingConn( 408 xRowSetProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ActiveConnection" ) ) ), 409 UNO_QUERY ); 410 411 if ( xExistingConn.is() 412 // 2. embedded in a database? 413 || isEmbeddedInDatabase( _rxRowSet, xExistingConn ) 414 // 3. is there a connection in the parent hierarchy? 415 || ( xExistingConn = findConnection( _rxRowSet ) ).is() 416 ) 417 { 418 if ( _bSetAsActiveConnection ) 419 { 420 xRowSetProps->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ActiveConnection" ) ), makeAny( xExistingConn ) ); 421 // no auto disposer needed, since we did not create the connection 422 } 423 424 xConnection.reset( xExistingConn, SharedConnection::NoTakeOwnership ); 425 break; 426 } 427 428 // build a connection with it's current settings (4. data source name, or 5. URL) 429 430 const ::rtl::OUString sUserProp = ::rtl::OUString::createFromAscii("User"); 431 ::rtl::OUString sDataSourceName; 432 xRowSetProps->getPropertyValue(::rtl::OUString::createFromAscii("DataSourceName")) >>= sDataSourceName; 433 ::rtl::OUString sURL; 434 xRowSetProps->getPropertyValue(::rtl::OUString::createFromAscii("URL")) >>= sURL; 435 436 Reference< XConnection > xPureConnection; 437 if (sDataSourceName.getLength()) 438 { // the row set's data source property is set 439 // -> try to connect, get user and pwd setting for that 440 ::rtl::OUString sUser, sPwd; 441 442 if (hasProperty(sUserProp, xRowSetProps)) 443 xRowSetProps->getPropertyValue(sUserProp) >>= sUser; 444 if (hasProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PASSWORD), xRowSetProps)) 445 xRowSetProps->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PASSWORD)) >>= sPwd; 446 447 xPureConnection = getConnection_allowException( sDataSourceName, sUser, sPwd, _rxFactory ); 448 } 449 else if (sURL.getLength()) 450 { // the row set has no data source, but a connection url set 451 // -> try to connection with that url 452 Reference< XDriverManager > xDriverManager( 453 _rxFactory->createInstance( ::rtl::OUString::createFromAscii("com.sun.star.sdbc.ConnectionPool")), UNO_QUERY); 454 if (xDriverManager.is()) 455 { 456 ::rtl::OUString sUser, sPwd; 457 if (hasProperty(sUserProp, xRowSetProps)) 458 xRowSetProps->getPropertyValue(sUserProp) >>= sUser; 459 if (hasProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PASSWORD), xRowSetProps)) 460 xRowSetProps->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PASSWORD)) >>= sPwd; 461 if (sUser.getLength()) 462 { // use user and pwd together with the url 463 Sequence< PropertyValue> aInfo(2); 464 aInfo.getArray()[0].Name = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("user")); 465 aInfo.getArray()[0].Value <<= sUser; 466 aInfo.getArray()[1].Name = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("password")); 467 aInfo.getArray()[1].Value <<= sPwd; 468 xPureConnection = xDriverManager->getConnectionWithInfo( sURL, aInfo ); 469 } 470 else 471 // just use the url 472 xPureConnection = xDriverManager->getConnection( sURL ); 473 } 474 } 475 xConnection.reset( 476 xPureConnection, 477 _bAttachAutoDisposer ? SharedConnection::NoTakeOwnership : SharedConnection::TakeOwnership 478 /* take ownership if and only if we're *not* going to auto-dispose the connection */ 479 ); 480 481 // now if we created a connection, forward it to the row set 482 if ( xConnection.is() && _bSetAsActiveConnection ) 483 { 484 try 485 { 486 if ( _bAttachAutoDisposer ) 487 { 488 OAutoConnectionDisposer* pAutoDispose = new OAutoConnectionDisposer( _rxRowSet, xConnection ); 489 Reference< XPropertyChangeListener > xEnsureDelete(pAutoDispose); 490 } 491 else 492 xRowSetProps->setPropertyValue( 493 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ActiveConnection" ) ), 494 makeAny( xConnection.getTyped() ) 495 ); 496 } 497 catch(Exception&) 498 { 499 OSL_ENSURE(0,"EXception when we set the new active connection!"); 500 } 501 } 502 } 503 while ( false ); 504 505 return xConnection; 506 } 507 508 //------------------------------------------------------------------------------ 509 Reference< XConnection> connectRowset(const Reference< XRowSet>& _rxRowSet, const Reference< XMultiServiceFactory>& _rxFactory, 510 sal_Bool _bSetAsActiveConnection ) 511 { 512 SharedConnection xConnection = lcl_connectRowSet( _rxRowSet, _rxFactory, _bSetAsActiveConnection, true ); 513 return xConnection.getTyped(); 514 } 515 516 //------------------------------------------------------------------------------ 517 SharedConnection ensureRowSetConnection(const Reference< XRowSet>& _rxRowSet, const Reference< XMultiServiceFactory>& _rxFactory, 518 bool _bUseAutoConnectionDisposer ) 519 { 520 return lcl_connectRowSet( _rxRowSet, _rxFactory, true, _bUseAutoConnectionDisposer ); 521 } 522 523 //------------------------------------------------------------------------------ 524 Reference< XNameAccess> getTableFields(const Reference< XConnection>& _rxConn,const ::rtl::OUString& _rName) 525 { 526 Reference< XComponent > xDummy; 527 return getFieldsByCommandDescriptor( _rxConn, CommandType::TABLE, _rName, xDummy ); 528 } 529 //------------------------------------------------------------------------------ 530 Reference< XNameAccess> getPrimaryKeyColumns_throw(const Any& i_aTable) 531 { 532 const Reference< XPropertySet > xTable(i_aTable,UNO_QUERY_THROW); 533 return getPrimaryKeyColumns_throw(xTable); 534 } 535 //------------------------------------------------------------------------------ 536 Reference< XNameAccess> getPrimaryKeyColumns_throw(const Reference< XPropertySet >& i_xTable) 537 { 538 Reference<XNameAccess> xKeyColumns; 539 const Reference<XKeysSupplier> xKeySup(i_xTable,UNO_QUERY); 540 if ( xKeySup.is() ) 541 { 542 const Reference<XIndexAccess> xKeys = xKeySup->getKeys(); 543 if ( xKeys.is() ) 544 { 545 ::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap(); 546 const ::rtl::OUString sPropName = rPropMap.getNameByIndex(PROPERTY_ID_TYPE); 547 Reference<XPropertySet> xProp; 548 const sal_Int32 nCount = xKeys->getCount(); 549 for(sal_Int32 i = 0;i< nCount;++i) 550 { 551 xProp.set(xKeys->getByIndex(i),UNO_QUERY_THROW); 552 if ( xProp.is() ) 553 { 554 sal_Int32 nKeyType = 0; 555 xProp->getPropertyValue(sPropName) >>= nKeyType; 556 if(KeyType::PRIMARY == nKeyType) 557 { 558 const Reference<XColumnsSupplier> xKeyColsSup(xProp,UNO_QUERY_THROW); 559 xKeyColumns = xKeyColsSup->getColumns(); 560 break; 561 } 562 } 563 } 564 } 565 } 566 567 return xKeyColumns; 568 } 569 570 //------------------------------------------------------------------------------ 571 namespace 572 { 573 enum FieldLookupState 574 { 575 HANDLE_TABLE, HANDLE_QUERY, HANDLE_SQL, RETRIEVE_OBJECT, RETRIEVE_COLUMNS, DONE, FAILED 576 }; 577 } 578 579 //------------------------------------------------------------------------------ 580 Reference< XNameAccess > getFieldsByCommandDescriptor( const Reference< XConnection >& _rxConnection, 581 const sal_Int32 _nCommandType, const ::rtl::OUString& _rCommand, 582 Reference< XComponent >& _rxKeepFieldsAlive, SQLExceptionInfo* _pErrorInfo ) SAL_THROW( ( ) ) 583 { 584 OSL_PRECOND( _rxConnection.is(), "::dbtools::getFieldsByCommandDescriptor: invalid connection!" ); 585 OSL_PRECOND( ( CommandType::TABLE == _nCommandType ) || ( CommandType::QUERY == _nCommandType ) || ( CommandType::COMMAND == _nCommandType ), 586 "::dbtools::getFieldsByCommandDescriptor: invalid command type!" ); 587 OSL_PRECOND( _rCommand.getLength(), "::dbtools::getFieldsByCommandDescriptor: invalid command (empty)!" ); 588 589 Reference< XNameAccess > xFields; 590 591 // reset the error 592 if ( _pErrorInfo ) 593 *_pErrorInfo = SQLExceptionInfo(); 594 // reset the ownership holder 595 _rxKeepFieldsAlive.clear(); 596 597 // go for the fields 598 try 599 { 600 // some kind of state machine to ease the sharing of code 601 FieldLookupState eState = FAILED; 602 switch ( _nCommandType ) 603 { 604 case CommandType::TABLE: 605 eState = HANDLE_TABLE; 606 break; 607 case CommandType::QUERY: 608 eState = HANDLE_QUERY; 609 break; 610 case CommandType::COMMAND: 611 eState = HANDLE_SQL; 612 break; 613 } 614 615 // needed in various states: 616 Reference< XNameAccess > xObjectCollection; 617 Reference< XColumnsSupplier > xSupplyColumns; 618 619 // go! 620 while ( ( DONE != eState ) && ( FAILED != eState ) ) 621 { 622 switch ( eState ) 623 { 624 case HANDLE_TABLE: 625 { 626 // initial state for handling the tables 627 628 // get the table objects 629 Reference< XTablesSupplier > xSupplyTables( _rxConnection, UNO_QUERY ); 630 if ( xSupplyTables.is() ) 631 xObjectCollection = xSupplyTables->getTables(); 632 // if something went wrong 'til here, then this will be handled in the next state 633 634 // next state: get the object 635 eState = RETRIEVE_OBJECT; 636 } 637 break; 638 639 case HANDLE_QUERY: 640 { 641 // initial state for handling the tables 642 643 // get the table objects 644 Reference< XQueriesSupplier > xSupplyQueries( _rxConnection, UNO_QUERY ); 645 if ( xSupplyQueries.is() ) 646 xObjectCollection = xSupplyQueries->getQueries(); 647 // if something went wrong 'til here, then this will be handled in the next state 648 649 // next state: get the object 650 eState = RETRIEVE_OBJECT; 651 } 652 break; 653 654 case RETRIEVE_OBJECT: 655 // here we should have an object (aka query or table) collection, and are going 656 // to retrieve the desired object 657 658 // next state: default to FAILED 659 eState = FAILED; 660 661 OSL_ENSURE( xObjectCollection.is(), "::dbtools::getFieldsByCommandDescriptor: invalid connection (no sdb.Connection, or no Tables-/QueriesSupplier)!"); 662 if ( xObjectCollection.is() ) 663 { 664 if ( xObjectCollection.is() && xObjectCollection->hasByName( _rCommand ) ) 665 { 666 xObjectCollection->getByName( _rCommand ) >>= xSupplyColumns; 667 // (xSupplyColumns being NULL will be handled in the next state) 668 669 // next: go for the columns 670 eState = RETRIEVE_COLUMNS; 671 } 672 } 673 break; 674 675 case RETRIEVE_COLUMNS: 676 OSL_ENSURE( xSupplyColumns.is(), "::dbtools::getFieldsByCommandDescriptor: could not retrieve the columns supplier!" ); 677 678 // next state: default to FAILED 679 eState = FAILED; 680 681 if ( xSupplyColumns.is() ) 682 { 683 xFields = xSupplyColumns->getColumns(); 684 // that's it 685 eState = DONE; 686 } 687 break; 688 689 case HANDLE_SQL: 690 { 691 ::rtl::OUString sStatementToExecute( _rCommand ); 692 693 // well, the main problem here is to handle statements which contain a parameter 694 // If we would simply execute a parametrized statement, then this will fail because 695 // we cannot supply any parameter values. 696 // Thus, we try to analyze the statement, and to append a WHERE 0=1 filter criterion 697 // This should cause every driver to not really execute the statement, but to return 698 // an empty result set with the proper structure. We then can use this result set 699 // to retrieve the columns. 700 701 try 702 { 703 Reference< XMultiServiceFactory > xComposerFac( _rxConnection, UNO_QUERY ); 704 705 if ( xComposerFac.is() ) 706 { 707 Reference< XSingleSelectQueryComposer > xComposer(xComposerFac->createInstance( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdb.SingleSelectQueryComposer"))),UNO_QUERY); 708 if ( xComposer.is() ) 709 { 710 xComposer->setQuery( sStatementToExecute ); 711 712 // Now set the filter to a dummy restriction which will result in an empty 713 // result set. 714 xComposer->setFilter( ::rtl::OUString::createFromAscii( "0=1" ) ); 715 sStatementToExecute = xComposer->getQuery( ); 716 } 717 } 718 } 719 catch( const Exception& ) 720 { 721 // silent this error, this was just a try. If we're here, we did not change sStatementToExecute, 722 // so it will still be _rCommand, which then will be executed without being touched 723 } 724 725 // now execute 726 Reference< XPreparedStatement > xStatement = _rxConnection->prepareStatement( sStatementToExecute ); 727 // transfer ownership of this temporary object to the caller 728 _rxKeepFieldsAlive = _rxKeepFieldsAlive.query( xStatement ); 729 730 // set the "MaxRows" to 0. This is just in case our attempt to append a 0=1 filter 731 // failed - in this case, the MaxRows restriction should at least ensure that there 732 // is no data returned (which would be potentially expensive) 733 Reference< XPropertySet > xStatementProps( xStatement,UNO_QUERY ); 734 try 735 { 736 if ( xStatementProps.is() ) 737 xStatementProps->setPropertyValue( 738 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MaxRows" ) ), 739 makeAny( sal_Int32( 0 ) ) 740 ); 741 } 742 catch( const Exception& ) 743 { 744 OSL_ENSURE( sal_False, "::dbtools::getFieldsByCommandDescriptor: could not set the MaxRows!" ); 745 // oh damn. Not much of a chance to recover, we will no retrieve the complete 746 // full blown result set 747 } 748 749 xSupplyColumns = xSupplyColumns.query( xStatement->executeQuery() ); 750 // this should have given us a result set which does not contain any data, but 751 // the structural information we need 752 753 // so the next state is to get the columns 754 eState = RETRIEVE_COLUMNS; 755 } 756 break; 757 758 default: 759 OSL_ENSURE( sal_False, "::dbtools::getFieldsByCommandDescriptor: oops! unhandled state here!" ); 760 eState = FAILED; 761 } 762 } 763 } 764 catch( const SQLContext& e ) { if ( _pErrorInfo ) *_pErrorInfo = SQLExceptionInfo( e ); } 765 catch( const SQLWarning& e ) { if ( _pErrorInfo ) *_pErrorInfo = SQLExceptionInfo( e ); } 766 catch( const SQLException& e ) { if ( _pErrorInfo ) *_pErrorInfo = SQLExceptionInfo( e ); } 767 catch( const Exception& ) 768 { 769 OSL_ENSURE( sal_False, "::dbtools::getFieldsByCommandDescriptor: caught an exception while retrieving the fields!" ); 770 } 771 772 return xFields; 773 } 774 775 //------------------------------------------------------------------------------ 776 Sequence< ::rtl::OUString > getFieldNamesByCommandDescriptor( const Reference< XConnection >& _rxConnection, 777 const sal_Int32 _nCommandType, const ::rtl::OUString& _rCommand, 778 SQLExceptionInfo* _pErrorInfo ) SAL_THROW( ( ) ) 779 { 780 // get the container for the fields 781 Reference< XComponent > xKeepFieldsAlive; 782 Reference< XNameAccess > xFieldContainer = getFieldsByCommandDescriptor( _rxConnection, _nCommandType, _rCommand, xKeepFieldsAlive, _pErrorInfo ); 783 784 // get the names of the fields 785 Sequence< ::rtl::OUString > aNames; 786 if ( xFieldContainer.is() ) 787 aNames = xFieldContainer->getElementNames(); 788 789 // clean up any temporary objects which have been created 790 disposeComponent( xKeepFieldsAlive ); 791 792 // outta here 793 return aNames; 794 } 795 796 //------------------------------------------------------------------------------ 797 SQLContext prependContextInfo(const SQLException& _rException, const Reference< XInterface >& _rxContext, const ::rtl::OUString& _rContextDescription, const ::rtl::OUString& _rContextDetails) 798 { 799 return SQLContext( _rContextDescription, _rxContext, ::rtl::OUString(), 0, makeAny( _rException ), _rContextDetails ); 800 } 801 //------------------------------------------------------------------------------ 802 SQLException prependErrorInfo( const SQLException& _rChainedException, const Reference< XInterface >& _rxContext, 803 const ::rtl::OUString& _rAdditionalError, const StandardSQLState _eSQLState, const sal_Int32 _nErrorCode ) 804 { 805 return SQLException( _rAdditionalError, _rxContext, 806 _eSQLState == SQL_ERROR_UNSPECIFIED ? ::rtl::OUString() : getStandardSQLState( _eSQLState ), 807 _nErrorCode, makeAny( _rChainedException ) ); 808 } 809 810 //-------------------------------------------------------------------------- 811 namespace 812 { 813 struct NameComponentSupport 814 { 815 const bool bCatalogs; 816 const bool bSchemas; 817 818 NameComponentSupport( ) 819 :bCatalogs( true ) 820 ,bSchemas( true ) 821 { 822 } 823 824 NameComponentSupport( const bool _bCatalogs, const bool _bSchemas ) 825 :bCatalogs( _bCatalogs ) 826 ,bSchemas( _bSchemas ) 827 { 828 } 829 }; 830 831 NameComponentSupport lcl_getNameComponentSupport( const Reference< XDatabaseMetaData >& _rxMetaData, EComposeRule _eComposeRule ) 832 { 833 OSL_PRECOND( _rxMetaData.is(), "lcl_getNameComponentSupport: invalid meta data!" ); 834 835 FMetaDataSupport pCatalogCall = &XDatabaseMetaData::supportsCatalogsInDataManipulation; 836 FMetaDataSupport pSchemaCall = &XDatabaseMetaData::supportsSchemasInDataManipulation; 837 bool bIgnoreMetaData = false; 838 839 switch ( _eComposeRule ) 840 { 841 case eInTableDefinitions: 842 pCatalogCall = &XDatabaseMetaData::supportsCatalogsInTableDefinitions; 843 pSchemaCall = &XDatabaseMetaData::supportsSchemasInTableDefinitions; 844 break; 845 case eInIndexDefinitions: 846 pCatalogCall = &XDatabaseMetaData::supportsCatalogsInIndexDefinitions; 847 pSchemaCall = &XDatabaseMetaData::supportsSchemasInIndexDefinitions; 848 break; 849 case eInProcedureCalls: 850 pCatalogCall = &XDatabaseMetaData::supportsCatalogsInProcedureCalls; 851 pSchemaCall = &XDatabaseMetaData::supportsSchemasInProcedureCalls; 852 break; 853 case eInPrivilegeDefinitions: 854 pCatalogCall = &XDatabaseMetaData::supportsCatalogsInPrivilegeDefinitions; 855 pSchemaCall = &XDatabaseMetaData::supportsSchemasInPrivilegeDefinitions; 856 break; 857 case eComplete: 858 bIgnoreMetaData = true; 859 break; 860 case eInDataManipulation: 861 // already properly set above 862 break; 863 } 864 return NameComponentSupport( 865 bIgnoreMetaData ? true : (_rxMetaData.get()->*pCatalogCall)(), 866 bIgnoreMetaData ? true : (_rxMetaData.get()->*pSchemaCall)() 867 ); 868 } 869 } 870 871 //-------------------------------------------------------------------------- 872 static ::rtl::OUString impl_doComposeTableName( const Reference< XDatabaseMetaData >& _rxMetaData, 873 const ::rtl::OUString& _rCatalog, const ::rtl::OUString& _rSchema, const ::rtl::OUString& _rName, 874 sal_Bool _bQuote, EComposeRule _eComposeRule ) 875 { 876 OSL_ENSURE(_rxMetaData.is(), "impl_doComposeTableName : invalid meta data !"); 877 if ( !_rxMetaData.is() ) 878 return ::rtl::OUString(); 879 OSL_ENSURE(_rName.getLength(), "impl_doComposeTableName : at least the name should be non-empty !"); 880 881 const ::rtl::OUString sQuoteString = _rxMetaData->getIdentifierQuoteString(); 882 const NameComponentSupport aNameComps( lcl_getNameComponentSupport( _rxMetaData, _eComposeRule ) ); 883 884 ::rtl::OUStringBuffer aComposedName; 885 886 ::rtl::OUString sCatalogSep; 887 sal_Bool bCatlogAtStart = sal_True; 888 if ( _rCatalog.getLength() && aNameComps.bCatalogs ) 889 { 890 sCatalogSep = _rxMetaData->getCatalogSeparator(); 891 bCatlogAtStart = _rxMetaData->isCatalogAtStart(); 892 893 if ( bCatlogAtStart && sCatalogSep.getLength()) 894 { 895 aComposedName.append( _bQuote ? quoteName( sQuoteString, _rCatalog ) : _rCatalog ); 896 aComposedName.append( sCatalogSep ); 897 } 898 } 899 900 if ( _rSchema.getLength() && aNameComps.bSchemas ) 901 { 902 aComposedName.append( _bQuote ? quoteName( sQuoteString, _rSchema ) : _rSchema ); 903 aComposedName.appendAscii( "." ); 904 } 905 906 aComposedName.append( _bQuote ? quoteName( sQuoteString, _rName ) : _rName ); 907 908 if ( _rCatalog.getLength() 909 && !bCatlogAtStart 910 && sCatalogSep.getLength() 911 && aNameComps.bCatalogs 912 ) 913 { 914 aComposedName.append( sCatalogSep ); 915 aComposedName.append( _bQuote ? quoteName( sQuoteString, _rCatalog ) : _rCatalog ); 916 } 917 918 return aComposedName.makeStringAndClear(); 919 } 920 921 //------------------------------------------------------------------------------ 922 ::rtl::OUString quoteTableName(const Reference< XDatabaseMetaData>& _rxMeta 923 , const ::rtl::OUString& _rName 924 , EComposeRule _eComposeRule) 925 { 926 ::rtl::OUString sCatalog, sSchema, sTable; 927 qualifiedNameComponents(_rxMeta,_rName,sCatalog,sSchema,sTable,_eComposeRule); 928 return impl_doComposeTableName( _rxMeta, sCatalog, sSchema, sTable, sal_True, _eComposeRule ); 929 } 930 931 //------------------------------------------------------------------------------ 932 void qualifiedNameComponents(const Reference< XDatabaseMetaData >& _rxConnMetaData, const ::rtl::OUString& _rQualifiedName, ::rtl::OUString& _rCatalog, ::rtl::OUString& _rSchema, ::rtl::OUString& _rName,EComposeRule _eComposeRule) 933 { 934 OSL_ENSURE(_rxConnMetaData.is(), "QualifiedNameComponents : invalid meta data!"); 935 936 NameComponentSupport aNameComps( lcl_getNameComponentSupport( _rxConnMetaData, _eComposeRule ) ); 937 938 ::rtl::OUString sSeparator = _rxConnMetaData->getCatalogSeparator(); 939 940 ::rtl::OUString sName(_rQualifiedName); 941 // do we have catalogs ? 942 if ( aNameComps.bCatalogs ) 943 { 944 if (_rxConnMetaData->isCatalogAtStart()) 945 { 946 // search for the catalog name at the beginning 947 sal_Int32 nIndex = sName.indexOf(sSeparator); 948 if (-1 != nIndex) 949 { 950 _rCatalog = sName.copy(0, nIndex); 951 sName = sName.copy(nIndex + 1); 952 } 953 } 954 else 955 { 956 // Katalogname am Ende 957 sal_Int32 nIndex = sName.lastIndexOf(sSeparator); 958 if (-1 != nIndex) 959 { 960 _rCatalog = sName.copy(nIndex + 1); 961 sName = sName.copy(0, nIndex); 962 } 963 } 964 } 965 966 if ( aNameComps.bSchemas ) 967 { 968 sal_Int32 nIndex = sName.indexOf((sal_Unicode)'.'); 969 // OSL_ENSURE(-1 != nIndex, "QualifiedNameComponents : no schema separator!"); 970 if ( nIndex != -1 ) 971 _rSchema = sName.copy(0, nIndex); 972 sName = sName.copy(nIndex + 1); 973 } 974 975 _rName = sName; 976 } 977 978 //------------------------------------------------------------------------------ 979 Reference< XNumberFormatsSupplier> getNumberFormats( 980 const Reference< XConnection>& _rxConn, 981 sal_Bool _bAlloweDefault, 982 const Reference< XMultiServiceFactory>& _rxFactory) 983 { 984 // ask the parent of the connection (should be an DatabaseAccess) 985 Reference< XNumberFormatsSupplier> xReturn; 986 Reference< XChild> xConnAsChild(_rxConn, UNO_QUERY); 987 ::rtl::OUString sPropFormatsSupplier = ::rtl::OUString::createFromAscii("NumberFormatsSupplier"); 988 if (xConnAsChild.is()) 989 { 990 Reference< XPropertySet> xConnParentProps(xConnAsChild->getParent(), UNO_QUERY); 991 if (xConnParentProps.is() && hasProperty(sPropFormatsSupplier, xConnParentProps)) 992 xConnParentProps->getPropertyValue(sPropFormatsSupplier) >>= xReturn; 993 } 994 else if(_bAlloweDefault && _rxFactory.is()) 995 { 996 xReturn = Reference< XNumberFormatsSupplier>(_rxFactory->createInstance(::rtl::OUString::createFromAscii("com.sun.star.util.NumberFormatsSupplier")),UNO_QUERY); 997 } 998 return xReturn; 999 } 1000 1001 //============================================================================== 1002 //------------------------------------------------------------------------------ 1003 void TransferFormComponentProperties( 1004 const Reference< XPropertySet>& xOldProps, 1005 const Reference< XPropertySet>& xNewProps, 1006 const Locale& _rLocale) 1007 { 1008 try 1009 { 1010 OSL_ENSURE( xOldProps.is() && xNewProps.is(), "TransferFormComponentProperties: invalid source/dest!" ); 1011 if ( !xOldProps.is() || !xNewProps.is() ) 1012 return; 1013 1014 // kopieren wir erst mal alle Props, die in Quelle und Ziel vorhanden sind und identische Beschreibungen haben 1015 Reference< XPropertySetInfo> xOldInfo( xOldProps->getPropertySetInfo()); 1016 Reference< XPropertySetInfo> xNewInfo( xNewProps->getPropertySetInfo()); 1017 1018 Sequence< Property> aOldProperties = xOldInfo->getProperties(); 1019 Sequence< Property> aNewProperties = xNewInfo->getProperties(); 1020 int nNewLen = aNewProperties.getLength(); 1021 1022 Property* pOldProps = aOldProperties.getArray(); 1023 Property* pNewProps = aNewProperties.getArray(); 1024 1025 ::rtl::OUString sPropDefaultControl(::rtl::OUString::createFromAscii("DefaultControl")); 1026 ::rtl::OUString sPropLabelControl(::rtl::OUString::createFromAscii("LabelControl")); 1027 ::rtl::OUString sPropFormatsSupplier(::rtl::OUString::createFromAscii("FormatsSupplier")); 1028 ::rtl::OUString sPropCurrencySymbol(::rtl::OUString::createFromAscii("CurrencySymbol")); 1029 ::rtl::OUString sPropDecimals(::rtl::OUString::createFromAscii("Decimals")); 1030 ::rtl::OUString sPropEffectiveMin(::rtl::OUString::createFromAscii("EffectiveMin")); 1031 ::rtl::OUString sPropEffectiveMax(::rtl::OUString::createFromAscii("EffectiveMax")); 1032 ::rtl::OUString sPropEffectiveDefault(::rtl::OUString::createFromAscii("EffectiveDefault")); 1033 ::rtl::OUString sPropDefaultText(::rtl::OUString::createFromAscii("DefaultText")); 1034 ::rtl::OUString sPropDefaultDate(::rtl::OUString::createFromAscii("DefaultDate")); 1035 ::rtl::OUString sPropDefaultTime(::rtl::OUString::createFromAscii("DefaultTime")); 1036 ::rtl::OUString sPropValueMin(::rtl::OUString::createFromAscii("ValueMin")); 1037 ::rtl::OUString sPropValueMax(::rtl::OUString::createFromAscii("ValueMax")); 1038 ::rtl::OUString sPropDecimalAccuracy(::rtl::OUString::createFromAscii("DecimalAccuracy")); 1039 ::rtl::OUString sPropClassId(::rtl::OUString::createFromAscii("ClassId")); 1040 ::rtl::OUString sFormattedServiceName( ::rtl::OUString::createFromAscii( "com.sun.star.form.component.FormattedField" ) ); 1041 1042 for (sal_Int16 i=0; i<aOldProperties.getLength(); ++i) 1043 { 1044 if ( (!pOldProps[i].Name.equals(sPropDefaultControl)) 1045 && (!pOldProps[i].Name.equals(sPropLabelControl)) 1046 ) 1047 { 1048 // binaere Suche 1049 Property* pResult = ::std::lower_bound(pNewProps, pNewProps + nNewLen,pOldProps[i].Name, ::comphelper::PropertyStringLessFunctor()); 1050 if ( pResult 1051 && ( pResult != pNewProps + nNewLen && pResult->Name == pOldProps[i].Name ) 1052 && ( (pResult->Attributes & PropertyAttribute::READONLY) == 0 ) 1053 && ( pResult->Type.equals(pOldProps[i].Type)) ) 1054 { // Attribute stimmen ueberein und Property ist nicht read-only 1055 try 1056 { 1057 xNewProps->setPropertyValue(pResult->Name, xOldProps->getPropertyValue(pResult->Name)); 1058 } 1059 catch(IllegalArgumentException& e) 1060 { 1061 OSL_UNUSED( e ); 1062 #ifdef DBG_UTIL 1063 ::rtl::OUString sMessage = ::rtl::OUString::createFromAscii("TransferFormComponentProperties : could not transfer the value for property \""); 1064 sMessage += pResult->Name; 1065 sMessage += ::rtl::OUString::createFromAscii("\""); 1066 OSL_ENSURE(sal_False, ::rtl::OUStringToOString(sMessage, RTL_TEXTENCODING_ASCII_US)); 1067 #endif 1068 } 1069 } 1070 } 1071 } 1072 1073 1074 // fuer formatierte Felder (entweder alt oder neu) haben wir ein paar Sonderbehandlungen 1075 Reference< XServiceInfo > xSI( xOldProps, UNO_QUERY ); 1076 sal_Bool bOldIsFormatted = xSI.is() && xSI->supportsService( sFormattedServiceName ); 1077 xSI = Reference< XServiceInfo >( xNewProps, UNO_QUERY ); 1078 sal_Bool bNewIsFormatted = xSI.is() && xSI->supportsService( sFormattedServiceName ); 1079 1080 if (!bOldIsFormatted && !bNewIsFormatted) 1081 return; // nothing to do 1082 1083 if (bOldIsFormatted && bNewIsFormatted) 1084 // nein, wenn beide formatierte Felder sind, dann machen wir keinerlei Konvertierungen 1085 // Das geht zu weit ;) 1086 return; 1087 1088 if (bOldIsFormatted) 1089 { 1090 // aus dem eingestellten Format ein paar Properties rausziehen und zum neuen Set durchschleifen 1091 Any aFormatKey( xOldProps->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FORMATKEY)) ); 1092 if (aFormatKey.hasValue()) 1093 { 1094 Reference< XNumberFormatsSupplier> xSupplier; 1095 xOldProps->getPropertyValue(sPropFormatsSupplier) >>= xSupplier; 1096 if (xSupplier.is()) 1097 { 1098 Reference< XNumberFormats> xFormats(xSupplier->getNumberFormats()); 1099 Reference< XPropertySet> xFormat(xFormats->getByKey(getINT32(aFormatKey))); 1100 if (hasProperty(sPropCurrencySymbol, xFormat)) 1101 { 1102 Any aVal( xFormat->getPropertyValue(sPropCurrencySymbol) ); 1103 if (aVal.hasValue() && hasProperty(sPropCurrencySymbol, xNewProps)) 1104 // (wenn die Quelle das nicht gesetzt hat, dann auch nicht kopieren, um den 1105 // Default-Wert nicht zu ueberschreiben 1106 xNewProps->setPropertyValue(sPropCurrencySymbol, aVal); 1107 } 1108 if (hasProperty(sPropDecimals, xFormat) && hasProperty(sPropDecimals, xNewProps)) 1109 xNewProps->setPropertyValue(sPropDecimals, xFormat->getPropertyValue(sPropDecimals)); 1110 } 1111 } 1112 1113 // eine eventuelle-Min-Max-Konvertierung 1114 Any aEffectiveMin( xOldProps->getPropertyValue(sPropEffectiveMin) ); 1115 if (aEffectiveMin.hasValue()) 1116 { // im Gegensatz zu ValueMin kann EffectiveMin void sein 1117 if (hasProperty(sPropValueMin, xNewProps)) 1118 { 1119 OSL_ENSURE(aEffectiveMin.getValueType().getTypeClass() == TypeClass_DOUBLE, 1120 "TransferFormComponentProperties : invalid property type !"); 1121 xNewProps->setPropertyValue(sPropValueMin, aEffectiveMin); 1122 } 1123 } 1124 Any aEffectiveMax( xOldProps->getPropertyValue(sPropEffectiveMax) ); 1125 if (aEffectiveMax.hasValue()) 1126 { // analog 1127 if (hasProperty(sPropValueMax, xNewProps)) 1128 { 1129 OSL_ENSURE(aEffectiveMax.getValueType().getTypeClass() == TypeClass_DOUBLE, 1130 "TransferFormComponentProperties : invalid property type !"); 1131 xNewProps->setPropertyValue(sPropValueMax, aEffectiveMax); 1132 } 1133 } 1134 1135 // dann koennen wir noch Default-Werte konvertieren und uebernehmen 1136 Any aEffectiveDefault( xOldProps->getPropertyValue(sPropEffectiveDefault) ); 1137 if (aEffectiveDefault.hasValue()) 1138 { 1139 sal_Bool bIsString = aEffectiveDefault.getValueType().getTypeClass() == TypeClass_STRING; 1140 OSL_ENSURE(bIsString || aEffectiveDefault.getValueType().getTypeClass() == TypeClass_DOUBLE, 1141 "TransferFormComponentProperties : invalid property type !"); 1142 // die Effective-Properties sollten immer void oder string oder double sein .... 1143 1144 if (hasProperty(sPropDefaultDate, xNewProps) && !bIsString) 1145 { // (einen ::rtl::OUString in ein Datum zu konvertieren muss nicht immer klappen, denn das ganze kann ja an 1146 // eine Textspalte gebunden gewesen sein, aber mit einem double koennen wir was anfangen) 1147 Date aDate = DBTypeConversion::toDate(getDouble(aEffectiveDefault)); 1148 xNewProps->setPropertyValue(sPropDefaultDate, makeAny(aDate)); 1149 } 1150 1151 if (hasProperty(sPropDefaultTime, xNewProps) && !bIsString) 1152 { // voellig analog mit Zeit 1153 Time aTime = DBTypeConversion::toTime(getDouble(aEffectiveDefault)); 1154 xNewProps->setPropertyValue(sPropDefaultTime, makeAny(aTime)); 1155 } 1156 1157 if (hasProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DEFAULTVALUE), xNewProps) && !bIsString) 1158 { // hier koennen wir einfach das double durchreichen 1159 xNewProps->setPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DEFAULTVALUE), aEffectiveDefault); 1160 } 1161 1162 if (hasProperty(sPropDefaultText, xNewProps) && bIsString) 1163 { // und hier den ::rtl::OUString 1164 xNewProps->setPropertyValue(sPropDefaultText, aEffectiveDefault); 1165 } 1166 1167 // nyi: die Uebersetzung zwischen doubles und ::rtl::OUString wuerde noch mehr Moeglichkeien eroeffnen 1168 } 1169 } 1170 1171 // die andere Richtung : das neu Control soll formatiert sein 1172 if (bNewIsFormatted) 1173 { 1174 // zuerst die Formatierung 1175 // einen Supplier koennen wir nicht setzen, also muss das neue Set schon einen mitbringen 1176 Reference< XNumberFormatsSupplier> xSupplier; 1177 xNewProps->getPropertyValue(sPropFormatsSupplier) >>= xSupplier; 1178 if (xSupplier.is()) 1179 { 1180 Reference< XNumberFormats> xFormats(xSupplier->getNumberFormats()); 1181 1182 // Dezimal-Stellen 1183 sal_Int16 nDecimals = 2; 1184 if (hasProperty(sPropDecimalAccuracy, xOldProps)) 1185 xOldProps->getPropertyValue(sPropDecimalAccuracy) >>= nDecimals; 1186 1187 // Grund-Format (je nach ClassId des alten Sets) 1188 sal_Int32 nBaseKey = 0; 1189 if (hasProperty(sPropClassId, xOldProps)) 1190 { 1191 Reference< XNumberFormatTypes> xTypeList(xFormats, UNO_QUERY); 1192 if (xTypeList.is()) 1193 { 1194 sal_Int16 nClassId = 0; 1195 xOldProps->getPropertyValue(sPropClassId) >>= nClassId; 1196 switch (nClassId) 1197 { 1198 case FormComponentType::DATEFIELD : 1199 nBaseKey = xTypeList->getStandardFormat(NumberFormat::DATE, _rLocale); 1200 break; 1201 1202 case FormComponentType::TIMEFIELD : 1203 nBaseKey = xTypeList->getStandardFormat(NumberFormat::TIME, _rLocale); 1204 break; 1205 1206 case FormComponentType::CURRENCYFIELD : 1207 nBaseKey = xTypeList->getStandardFormat(NumberFormat::CURRENCY, _rLocale); 1208 break; 1209 } 1210 } 1211 } 1212 1213 // damit koennen wir ein neues Format basteln ... 1214 ::rtl::OUString sNewFormat = xFormats->generateFormat(nBaseKey, _rLocale, sal_False, sal_False, nDecimals, 0); 1215 // kein Tausender-Trennzeichen, negative Zahlen nicht in Rot, keine fuehrenden Nullen 1216 1217 // ... und zum FormatsSupplier hinzufuegen (wenn noetig) 1218 sal_Int32 nKey = xFormats->queryKey(sNewFormat, _rLocale, sal_False); 1219 if (nKey == (sal_Int32)-1) 1220 { // noch nicht vorhanden in meinem Formatter ... 1221 nKey = xFormats->addNew(sNewFormat, _rLocale); 1222 } 1223 1224 xNewProps->setPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FORMATKEY), makeAny((sal_Int32)nKey)); 1225 } 1226 1227 // min-/max-Werte 1228 Any aNewMin, aNewMax; 1229 if (hasProperty(sPropValueMin, xOldProps)) 1230 aNewMin = xOldProps->getPropertyValue(sPropValueMin); 1231 if (hasProperty(sPropValueMax, xOldProps)) 1232 aNewMax = xOldProps->getPropertyValue(sPropValueMax); 1233 xNewProps->setPropertyValue(sPropEffectiveMin, aNewMin); 1234 xNewProps->setPropertyValue(sPropEffectiveMax, aNewMax); 1235 1236 // Default-Wert 1237 Any aNewDefault; 1238 if (hasProperty(sPropDefaultDate, xOldProps)) 1239 { 1240 Any aDate( xOldProps->getPropertyValue(sPropDefaultDate) ); 1241 if (aDate.hasValue()) 1242 aNewDefault <<= DBTypeConversion::toDouble(*(Date*)aDate.getValue()); 1243 } 1244 1245 if (hasProperty(sPropDefaultTime, xOldProps)) 1246 { 1247 Any aTime( xOldProps->getPropertyValue(sPropDefaultTime) ); 1248 if (aTime.hasValue()) 1249 aNewDefault <<= DBTypeConversion::toDouble(*(Time*)aTime.getValue()); 1250 } 1251 1252 // double oder ::rtl::OUString werden direkt uebernommen 1253 if (hasProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DEFAULTVALUE), xOldProps)) 1254 aNewDefault = xOldProps->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DEFAULTVALUE)); 1255 if (hasProperty(sPropDefaultText, xOldProps)) 1256 aNewDefault = xOldProps->getPropertyValue(sPropDefaultText); 1257 1258 if (aNewDefault.hasValue()) 1259 xNewProps->setPropertyValue(sPropEffectiveDefault, aNewDefault); 1260 } 1261 } 1262 catch(const Exception&) 1263 { 1264 OSL_ENSURE( sal_False, "TransferFormComponentProperties: caught an exception!" ); 1265 } 1266 } 1267 1268 //------------------------------------------------------------------------------ 1269 sal_Bool canInsert(const Reference< XPropertySet>& _rxCursorSet) 1270 { 1271 return ((_rxCursorSet.is() && (getINT32(_rxCursorSet->getPropertyValue(::rtl::OUString::createFromAscii("Privileges"))) & Privilege::INSERT) != 0)); 1272 } 1273 1274 //------------------------------------------------------------------------------ 1275 sal_Bool canUpdate(const Reference< XPropertySet>& _rxCursorSet) 1276 { 1277 return ((_rxCursorSet.is() && (getINT32(_rxCursorSet->getPropertyValue(::rtl::OUString::createFromAscii("Privileges"))) & Privilege::UPDATE) != 0)); 1278 } 1279 1280 //------------------------------------------------------------------------------ 1281 sal_Bool canDelete(const Reference< XPropertySet>& _rxCursorSet) 1282 { 1283 return ((_rxCursorSet.is() && (getINT32(_rxCursorSet->getPropertyValue(::rtl::OUString::createFromAscii("Privileges"))) & Privilege::DELETE) != 0)); 1284 } 1285 // ----------------------------------------------------------------------------- 1286 Reference< XDataSource> findDataSource(const Reference< XInterface >& _xParent) 1287 { 1288 Reference< XOfficeDatabaseDocument> xDatabaseDocument(_xParent, UNO_QUERY); 1289 Reference< XDataSource> xDataSource; 1290 if ( xDatabaseDocument.is() ) 1291 xDataSource = xDatabaseDocument->getDataSource(); 1292 if ( !xDataSource.is() ) 1293 xDataSource.set(_xParent, UNO_QUERY); 1294 if (!xDataSource.is()) 1295 { 1296 Reference< XChild> xChild(_xParent, UNO_QUERY); 1297 if ( xChild.is() ) 1298 xDataSource = findDataSource(xChild->getParent()); 1299 } 1300 return xDataSource; 1301 } 1302 1303 //------------------------------------------------------------------------------ 1304 ::rtl::OUString getComposedRowSetStatement( const Reference< XPropertySet >& _rxRowSet, const Reference< XMultiServiceFactory>& _rxFactory, 1305 sal_Bool _bUseRowSetFilter, sal_Bool _bUseRowSetOrder, Reference< XSingleSelectQueryComposer >* _pxComposer ) 1306 { 1307 ::rtl::OUString sStatement; 1308 try 1309 { 1310 Reference< XConnection> xConn = connectRowset( Reference< XRowSet >( _rxRowSet, UNO_QUERY ), _rxFactory, sal_True ); 1311 if ( xConn.is() ) // implies _rxRowSet.is() 1312 { 1313 // build the statement the row set is based on (can't use the ActiveCommand property of the set 1314 // as this reflects the status after the last execute, not the currently set properties) 1315 1316 sal_Int32 nCommandType = CommandType::COMMAND; 1317 ::rtl::OUString sCommand; 1318 sal_Bool bEscapeProcessing = sal_False; 1319 1320 OSL_VERIFY( _rxRowSet->getPropertyValue( ::rtl::OUString::createFromAscii( "CommandType" ) ) >>= nCommandType ); 1321 OSL_VERIFY( _rxRowSet->getPropertyValue( ::rtl::OUString::createFromAscii( "Command" ) ) >>= sCommand ); 1322 OSL_VERIFY( _rxRowSet->getPropertyValue( ::rtl::OUString::createFromAscii( "EscapeProcessing" ) ) >>= bEscapeProcessing ); 1323 1324 StatementComposer aComposer( xConn, sCommand, nCommandType, bEscapeProcessing ); 1325 // append sort 1326 if ( _bUseRowSetOrder ) 1327 aComposer.setOrder( getString( _rxRowSet->getPropertyValue( ::rtl::OUString::createFromAscii( "Order" ) ) ) ); 1328 1329 // append filter 1330 if ( _bUseRowSetFilter ) 1331 { 1332 sal_Bool bApplyFilter = sal_True; 1333 _rxRowSet->getPropertyValue( ::rtl::OUString::createFromAscii( "ApplyFilter" ) ) >>= bApplyFilter; 1334 if ( bApplyFilter ) 1335 aComposer.setFilter( getString( _rxRowSet->getPropertyValue( ::rtl::OUString::createFromAscii( "Filter" ) ) ) ); 1336 } 1337 1338 sStatement = aComposer.getQuery(); 1339 1340 if ( _pxComposer ) 1341 { 1342 *_pxComposer = aComposer.getComposer(); 1343 aComposer.setDisposeComposer( false ); 1344 } 1345 } 1346 } 1347 catch( const SQLException& ) 1348 { 1349 throw; 1350 } 1351 catch( const Exception& ) 1352 { 1353 DBG_UNHANDLED_EXCEPTION(); 1354 } 1355 1356 return sStatement; 1357 } 1358 1359 //------------------------------------------------------------------------------ 1360 ::rtl::OUString getComposedRowSetStatement( 1361 const Reference< XPropertySet >& _rxRowSet, const Reference< XMultiServiceFactory>& _rxFactory, 1362 sal_Bool _bUseRowSetFilter, sal_Bool _bUseRowSetOrder ) 1363 { 1364 return getComposedRowSetStatement( _rxRowSet, _rxFactory, _bUseRowSetFilter, _bUseRowSetOrder, NULL ); 1365 } 1366 1367 //------------------------------------------------------------------------------ 1368 Reference< XSingleSelectQueryComposer > getCurrentSettingsComposer( 1369 const Reference< XPropertySet>& _rxRowSetProps, 1370 const Reference< XMultiServiceFactory>& _rxFactory) 1371 { 1372 Reference< XSingleSelectQueryComposer > xReturn; 1373 try 1374 { 1375 getComposedRowSetStatement( _rxRowSetProps, _rxFactory, sal_True, sal_True, &xReturn ); 1376 } 1377 catch( const SQLException& ) 1378 { 1379 throw; 1380 } 1381 catch( const Exception& ) 1382 { 1383 OSL_ENSURE( sal_False, "::getCurrentSettingsComposer : caught an exception !" ); 1384 } 1385 1386 return xReturn; 1387 } 1388 //-------------------------------------------------------------------------- 1389 ::rtl::OUString composeTableName( const Reference< XDatabaseMetaData >& _rxMetaData, 1390 const ::rtl::OUString& _rCatalog, 1391 const ::rtl::OUString& _rSchema, 1392 const ::rtl::OUString& _rName, 1393 sal_Bool _bQuote, 1394 EComposeRule _eComposeRule) 1395 { 1396 return impl_doComposeTableName( _rxMetaData, _rCatalog, _rSchema, _rName, _bQuote, _eComposeRule ); 1397 } 1398 1399 // ----------------------------------------------------------------------------- 1400 ::rtl::OUString composeTableNameForSelect( const Reference< XConnection >& _rxConnection, 1401 const ::rtl::OUString& _rCatalog, const ::rtl::OUString& _rSchema, const ::rtl::OUString& _rName ) 1402 { 1403 sal_Bool bUseCatalogInSelect = isDataSourcePropertyEnabled( _rxConnection, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UseCatalogInSelect" ) ), sal_True ); 1404 sal_Bool bUseSchemaInSelect = isDataSourcePropertyEnabled( _rxConnection, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UseSchemaInSelect" ) ), sal_True ); 1405 1406 return impl_doComposeTableName( 1407 _rxConnection->getMetaData(), 1408 bUseCatalogInSelect ? _rCatalog : ::rtl::OUString(), 1409 bUseSchemaInSelect ? _rSchema : ::rtl::OUString(), 1410 _rName, 1411 true, 1412 eInDataManipulation 1413 ); 1414 } 1415 1416 // ----------------------------------------------------------------------------- 1417 namespace 1418 { 1419 static void lcl_getTableNameComponents( const Reference<XPropertySet>& _xTable, 1420 ::rtl::OUString& _out_rCatalog, ::rtl::OUString& _out_rSchema, ::rtl::OUString& _out_rName ) 1421 { 1422 ::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap(); 1423 Reference< XPropertySetInfo > xInfo = _xTable->getPropertySetInfo(); 1424 if ( xInfo.is() 1425 && xInfo->hasPropertyByName(rPropMap.getNameByIndex(PROPERTY_ID_NAME)) ) 1426 { 1427 1428 ::rtl::OUString aCatalog; 1429 ::rtl::OUString aSchema; 1430 ::rtl::OUString aTable; 1431 if ( xInfo->hasPropertyByName(rPropMap.getNameByIndex(PROPERTY_ID_CATALOGNAME)) 1432 && xInfo->hasPropertyByName(rPropMap.getNameByIndex(PROPERTY_ID_SCHEMANAME)) ) 1433 { 1434 _xTable->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_CATALOGNAME)) >>= _out_rCatalog; 1435 _xTable->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_SCHEMANAME)) >>= _out_rSchema; 1436 } 1437 _xTable->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_NAME)) >>= _out_rName; 1438 } 1439 else 1440 OSL_ENSURE( false, "::dbtools::lcl_getTableNameComponents: this is no table object!" ); 1441 } 1442 } 1443 1444 // ----------------------------------------------------------------------------- 1445 ::rtl::OUString composeTableNameForSelect( const Reference< XConnection >& _rxConnection, const Reference<XPropertySet>& _xTable ) 1446 { 1447 ::rtl::OUString sCatalog, sSchema, sName; 1448 lcl_getTableNameComponents( _xTable, sCatalog, sSchema, sName ); 1449 1450 return composeTableNameForSelect( _rxConnection, sCatalog, sSchema, sName ); 1451 } 1452 1453 // ----------------------------------------------------------------------------- 1454 ::rtl::OUString composeTableName(const Reference<XDatabaseMetaData>& _xMetaData, 1455 const Reference<XPropertySet>& _xTable, 1456 EComposeRule _eComposeRule, 1457 bool _bSuppressCatalog, 1458 bool _bSuppressSchema, 1459 bool _bQuote ) 1460 { 1461 ::rtl::OUString sCatalog, sSchema, sName; 1462 lcl_getTableNameComponents( _xTable, sCatalog, sSchema, sName ); 1463 1464 return impl_doComposeTableName( 1465 _xMetaData, 1466 _bSuppressCatalog ? ::rtl::OUString() : sCatalog, 1467 _bSuppressSchema ? ::rtl::OUString() : sSchema, 1468 sName, 1469 _bQuote, 1470 _eComposeRule 1471 ); 1472 } 1473 // ----------------------------------------------------------------------------- 1474 sal_Int32 getSearchColumnFlag( const Reference< XConnection>& _rxConn,sal_Int32 _nDataType) 1475 { 1476 sal_Int32 nSearchFlag = 0; 1477 Reference<XResultSet> xSet = _rxConn->getMetaData()->getTypeInfo(); 1478 if(xSet.is()) 1479 { 1480 Reference<XRow> xRow(xSet,UNO_QUERY); 1481 while(xSet->next()) 1482 { 1483 if(xRow->getInt(2) == _nDataType) 1484 { 1485 nSearchFlag = xRow->getInt(9); 1486 break; 1487 } 1488 } 1489 } 1490 return nSearchFlag; 1491 } 1492 1493 // ----------------------------------------------------------------------------- 1494 ::rtl::OUString createUniqueName( const Sequence< ::rtl::OUString >& _rNames, const ::rtl::OUString& _rBaseName, sal_Bool _bStartWithNumber ) 1495 { 1496 ::std::set< ::rtl::OUString > aUsedNames; 1497 ::std::copy( 1498 _rNames.getConstArray(), 1499 _rNames.getConstArray() + _rNames.getLength(), 1500 ::std::insert_iterator< ::std::set< ::rtl::OUString > >( aUsedNames, aUsedNames.end() ) 1501 ); 1502 1503 ::rtl::OUString sName( _rBaseName ); 1504 sal_Int32 nPos = 1; 1505 if ( _bStartWithNumber ) 1506 sName += ::rtl::OUString::valueOf( nPos ); 1507 1508 while ( aUsedNames.find( sName ) != aUsedNames.end() ) 1509 { 1510 sName = _rBaseName; 1511 sName += ::rtl::OUString::valueOf( ++nPos ); 1512 } 1513 return sName; 1514 } 1515 1516 // ----------------------------------------------------------------------------- 1517 ::rtl::OUString createUniqueName(const Reference<XNameAccess>& _rxContainer,const ::rtl::OUString& _rBaseName,sal_Bool _bStartWithNumber) 1518 { 1519 Sequence< ::rtl::OUString > aElementNames; 1520 1521 OSL_ENSURE( _rxContainer.is(), "createUniqueName: invalid container!" ); 1522 if ( _rxContainer.is() ) 1523 aElementNames = _rxContainer->getElementNames(); 1524 1525 return createUniqueName( aElementNames, _rBaseName, _bStartWithNumber ); 1526 } 1527 1528 // ----------------------------------------------------------------------------- 1529 void showError(const SQLExceptionInfo& _rInfo, 1530 const Reference< XWindow>& _xParent, 1531 const Reference< XMultiServiceFactory >& _xFactory) 1532 { 1533 if (_rInfo.isValid()) 1534 { 1535 try 1536 { 1537 Sequence< Any > aArgs(2); 1538 aArgs[0] <<= PropertyValue(::rtl::OUString::createFromAscii("SQLException"), 0, _rInfo.get(), PropertyState_DIRECT_VALUE); 1539 aArgs[1] <<= PropertyValue(::rtl::OUString::createFromAscii("ParentWindow"), 0, makeAny(_xParent), PropertyState_DIRECT_VALUE); 1540 1541 static ::rtl::OUString s_sDialogServiceName = ::rtl::OUString::createFromAscii("com.sun.star.sdb.ErrorMessageDialog"); 1542 Reference< XExecutableDialog > xErrorDialog( 1543 _xFactory->createInstanceWithArguments(s_sDialogServiceName, aArgs), UNO_QUERY); 1544 if (xErrorDialog.is()) 1545 xErrorDialog->execute(); 1546 else 1547 { 1548 OSL_ENSURE(0,"dbtools::showError: no XExecutableDialog found!"); 1549 } 1550 } 1551 catch(Exception&) 1552 { 1553 OSL_ENSURE(0,"showError: could not display the error message!"); 1554 } 1555 } 1556 } 1557 1558 // ------------------------------------------------------------------------- 1559 sal_Bool implUpdateObject(const Reference< XRowUpdate >& _rxUpdatedObject, 1560 const sal_Int32 _nColumnIndex, const Any& _rValue) 1561 { 1562 sal_Bool bSuccessfullyReRouted = sal_True; 1563 switch (_rValue.getValueTypeClass()) 1564 { 1565 case TypeClass_ANY: 1566 { 1567 Any aInnerValue; 1568 _rValue >>= aInnerValue; 1569 bSuccessfullyReRouted = implUpdateObject(_rxUpdatedObject, _nColumnIndex, aInnerValue); 1570 } 1571 break; 1572 1573 case TypeClass_VOID: 1574 _rxUpdatedObject->updateNull(_nColumnIndex); 1575 break; 1576 1577 case TypeClass_STRING: 1578 _rxUpdatedObject->updateString(_nColumnIndex, *(rtl::OUString*)_rValue.getValue()); 1579 break; 1580 1581 case TypeClass_BOOLEAN: 1582 _rxUpdatedObject->updateBoolean(_nColumnIndex, *(sal_Bool *)_rValue.getValue()); 1583 break; 1584 1585 case TypeClass_BYTE: 1586 _rxUpdatedObject->updateByte(_nColumnIndex, *(sal_Int8 *)_rValue.getValue()); 1587 break; 1588 1589 case TypeClass_UNSIGNED_SHORT: 1590 case TypeClass_SHORT: 1591 _rxUpdatedObject->updateShort(_nColumnIndex, *(sal_Int16*)_rValue.getValue()); 1592 break; 1593 1594 case TypeClass_CHAR: 1595 _rxUpdatedObject->updateString(_nColumnIndex,::rtl::OUString((sal_Unicode *)_rValue.getValue(),1)); 1596 break; 1597 1598 case TypeClass_UNSIGNED_LONG: 1599 case TypeClass_LONG: 1600 _rxUpdatedObject->updateInt(_nColumnIndex, *(sal_Int32*)_rValue.getValue()); 1601 break; 1602 1603 case TypeClass_HYPER: 1604 { 1605 sal_Int64 nValue = 0; 1606 OSL_VERIFY( _rValue >>= nValue ); 1607 _rxUpdatedObject->updateLong( _nColumnIndex, nValue ); 1608 } 1609 break; 1610 1611 case TypeClass_FLOAT: 1612 _rxUpdatedObject->updateFloat(_nColumnIndex, *(float*)_rValue.getValue()); 1613 break; 1614 1615 case TypeClass_DOUBLE: 1616 _rxUpdatedObject->updateDouble(_nColumnIndex, *(double*)_rValue.getValue()); 1617 break; 1618 1619 case TypeClass_SEQUENCE: 1620 if (_rValue.getValueType() == ::getCppuType((const Sequence< sal_Int8 > *)0)) 1621 _rxUpdatedObject->updateBytes(_nColumnIndex, *(Sequence<sal_Int8>*)_rValue.getValue()); 1622 else 1623 bSuccessfullyReRouted = sal_False; 1624 break; 1625 case TypeClass_STRUCT: 1626 if (_rValue.getValueType() == ::getCppuType((const DateTime*)0)) 1627 _rxUpdatedObject->updateTimestamp(_nColumnIndex, *(DateTime*)_rValue.getValue()); 1628 else if (_rValue.getValueType() == ::getCppuType((const Date*)0)) 1629 _rxUpdatedObject->updateDate(_nColumnIndex, *(Date*)_rValue.getValue()); 1630 else if (_rValue.getValueType() == ::getCppuType((const Time*)0)) 1631 _rxUpdatedObject->updateTime(_nColumnIndex, *(Time*)_rValue.getValue()); 1632 else 1633 bSuccessfullyReRouted = sal_False; 1634 break; 1635 1636 case TypeClass_INTERFACE: 1637 if (_rValue.getValueType() == ::getCppuType(static_cast<Reference< XInputStream>*>(NULL))) 1638 { 1639 Reference< XInputStream > xStream; 1640 _rValue >>= xStream; 1641 _rxUpdatedObject->updateBinaryStream(_nColumnIndex, xStream, xStream->available()); 1642 break; 1643 } 1644 // run through 1645 default: 1646 bSuccessfullyReRouted = sal_False; 1647 } 1648 1649 return bSuccessfullyReRouted; 1650 } 1651 // ------------------------------------------------------------------------- 1652 sal_Bool implSetObject( const Reference< XParameters >& _rxParameters, 1653 const sal_Int32 _nColumnIndex, const Any& _rValue) 1654 { 1655 sal_Bool bSuccessfullyReRouted = sal_True; 1656 switch (_rValue.getValueTypeClass()) 1657 { 1658 case TypeClass_HYPER: 1659 { 1660 sal_Int64 nValue = 0; 1661 OSL_VERIFY( _rValue >>= nValue ); 1662 _rxParameters->setLong( _nColumnIndex, nValue ); 1663 } 1664 break; 1665 1666 case TypeClass_ANY: 1667 { 1668 Any aInnerValue; 1669 _rValue >>= aInnerValue; 1670 bSuccessfullyReRouted = implSetObject(_rxParameters, _nColumnIndex, aInnerValue); 1671 } 1672 break; 1673 1674 case TypeClass_VOID: 1675 _rxParameters->setNull(_nColumnIndex,DataType::VARCHAR); 1676 break; 1677 1678 case TypeClass_STRING: 1679 _rxParameters->setString(_nColumnIndex, *(rtl::OUString*)_rValue.getValue()); 1680 break; 1681 1682 case TypeClass_BOOLEAN: 1683 _rxParameters->setBoolean(_nColumnIndex, *(sal_Bool *)_rValue.getValue()); 1684 break; 1685 1686 case TypeClass_BYTE: 1687 _rxParameters->setByte(_nColumnIndex, *(sal_Int8 *)_rValue.getValue()); 1688 break; 1689 1690 case TypeClass_UNSIGNED_SHORT: 1691 case TypeClass_SHORT: 1692 _rxParameters->setShort(_nColumnIndex, *(sal_Int16*)_rValue.getValue()); 1693 break; 1694 1695 case TypeClass_CHAR: 1696 _rxParameters->setString(_nColumnIndex, ::rtl::OUString((sal_Unicode *)_rValue.getValue(),1)); 1697 break; 1698 1699 case TypeClass_UNSIGNED_LONG: 1700 case TypeClass_LONG: 1701 _rxParameters->setInt(_nColumnIndex, *(sal_Int32*)_rValue.getValue()); 1702 break; 1703 1704 case TypeClass_FLOAT: 1705 _rxParameters->setFloat(_nColumnIndex, *(float*)_rValue.getValue()); 1706 break; 1707 1708 case TypeClass_DOUBLE: 1709 _rxParameters->setDouble(_nColumnIndex, *(double*)_rValue.getValue()); 1710 break; 1711 1712 case TypeClass_SEQUENCE: 1713 if (_rValue.getValueType() == ::getCppuType((const Sequence< sal_Int8 > *)0)) 1714 { 1715 _rxParameters->setBytes(_nColumnIndex, *(Sequence<sal_Int8>*)_rValue.getValue()); 1716 } 1717 else 1718 bSuccessfullyReRouted = sal_False; 1719 break; 1720 case TypeClass_STRUCT: 1721 if (_rValue.getValueType() == ::getCppuType((const DateTime*)0)) 1722 _rxParameters->setTimestamp(_nColumnIndex, *(DateTime*)_rValue.getValue()); 1723 else if (_rValue.getValueType() == ::getCppuType((const Date*)0)) 1724 _rxParameters->setDate(_nColumnIndex, *(Date*)_rValue.getValue()); 1725 else if (_rValue.getValueType() == ::getCppuType((const Time*)0)) 1726 _rxParameters->setTime(_nColumnIndex, *(Time*)_rValue.getValue()); 1727 else 1728 bSuccessfullyReRouted = sal_False; 1729 break; 1730 1731 case TypeClass_INTERFACE: 1732 if (_rValue.getValueType() == ::getCppuType(static_cast<Reference< XInputStream>*>(NULL))) 1733 { 1734 Reference< XInputStream > xStream; 1735 _rValue >>= xStream; 1736 _rxParameters->setBinaryStream(_nColumnIndex, xStream, xStream->available()); 1737 break; 1738 } 1739 // run through 1740 default: 1741 bSuccessfullyReRouted = sal_False; 1742 1743 } 1744 1745 return bSuccessfullyReRouted; 1746 } 1747 1748 //.................................................................. 1749 namespace 1750 { 1751 class OParameterWrapper : public ::cppu::WeakImplHelper1< XIndexAccess > 1752 { 1753 ::std::bit_vector m_aSet; 1754 Reference<XIndexAccess> m_xSource; 1755 public: 1756 OParameterWrapper(const ::std::bit_vector& _aSet,const Reference<XIndexAccess>& _xSource) : m_aSet(_aSet),m_xSource(_xSource){} 1757 private: 1758 // ::com::sun::star::container::XElementAccess 1759 virtual Type SAL_CALL getElementType() 1760 { 1761 return m_xSource->getElementType(); 1762 } 1763 virtual sal_Bool SAL_CALL hasElements( ) 1764 { 1765 if ( m_aSet.empty() ) 1766 return m_xSource->hasElements(); 1767 return (::std::find(m_aSet.begin(),m_aSet.end(),false) != m_aSet.end()); 1768 } 1769 // ::com::sun::star::container::XIndexAccess 1770 virtual sal_Int32 SAL_CALL getCount( ) 1771 { 1772 if ( m_aSet.empty() ) 1773 return m_xSource->getCount(); 1774 return std_bitset_count(m_aSet.begin(),m_aSet.end(),false); 1775 } 1776 virtual Any SAL_CALL getByIndex( sal_Int32 Index ) 1777 { 1778 if ( m_aSet.empty() ) 1779 return m_xSource->getByIndex(Index); 1780 if ( m_aSet.size() < (size_t)Index ) 1781 throw IndexOutOfBoundsException(); 1782 1783 ::std::bit_vector::iterator aIter = m_aSet.begin(); 1784 ::std::bit_vector::iterator aEnd = m_aSet.end(); 1785 sal_Int32 i = 0; 1786 sal_Int32 nParamPos = -1; 1787 for(; aIter != aEnd && i <= Index; ++aIter) 1788 { 1789 ++nParamPos; 1790 if ( !*aIter ) 1791 { 1792 ++i; 1793 } 1794 } 1795 return m_xSource->getByIndex(nParamPos); 1796 } 1797 }; 1798 } 1799 1800 // ----------------------------------------------------------------------------- 1801 void askForParameters(const Reference< XSingleSelectQueryComposer >& _xComposer, 1802 const Reference<XParameters>& _xParameters, 1803 const Reference< XConnection>& _xConnection, 1804 const Reference< XInteractionHandler >& _rxHandler, 1805 const ::std::bit_vector& _aParametersSet) 1806 { 1807 OSL_ENSURE(_xComposer.is(),"dbtools::askForParameters XSQLQueryComposer is null!"); 1808 OSL_ENSURE(_xParameters.is(),"dbtools::askForParameters XParameters is null!"); 1809 OSL_ENSURE(_xConnection.is(),"dbtools::askForParameters XConnection is null!"); 1810 OSL_ENSURE(_rxHandler.is(),"dbtools::askForParameters XInteractionHandler is null!"); 1811 1812 // we have to set this here again because getCurrentSettingsComposer can force a setpropertyvalue 1813 Reference<XParametersSupplier> xParameters = Reference<XParametersSupplier> (_xComposer, UNO_QUERY); 1814 1815 Reference<XIndexAccess> xParamsAsIndicies = xParameters.is() ? xParameters->getParameters() : Reference<XIndexAccess>(); 1816 Reference<XNameAccess> xParamsAsNames(xParamsAsIndicies, UNO_QUERY); 1817 sal_Int32 nParamCount = xParamsAsIndicies.is() ? xParamsAsIndicies->getCount() : 0; 1818 ::std::bit_vector aNewParameterSet( _aParametersSet ); 1819 if ( nParamCount || std_bitset_count(aNewParameterSet.begin(),aNewParameterSet.end(),true) != nParamCount ) 1820 { 1821 static const ::rtl::OUString PROPERTY_NAME(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)); 1822 aNewParameterSet.resize(nParamCount ,false); 1823 typedef ::std::map< ::rtl::OUString, ::std::vector<sal_Int32> > TParameterPositions; 1824 TParameterPositions aParameterNames; 1825 for(sal_Int32 i = 0; i < nParamCount; ++i) 1826 { 1827 Reference<XPropertySet> xParam(xParamsAsIndicies->getByIndex(i),UNO_QUERY); 1828 ::rtl::OUString sName; 1829 xParam->getPropertyValue(PROPERTY_NAME) >>= sName; 1830 1831 TParameterPositions::iterator aFind = aParameterNames.find(sName); 1832 if ( aFind != aParameterNames.end() ) 1833 aNewParameterSet[i] = true; 1834 aParameterNames[sName].push_back(i+1); 1835 } 1836 // build an interaction request 1837 // two continuations (Ok and Cancel) 1838 OInteractionAbort* pAbort = new OInteractionAbort; 1839 OParameterContinuation* pParams = new OParameterContinuation; 1840 // the request 1841 ParametersRequest aRequest; 1842 Reference<XIndexAccess> xWrappedParameters = new OParameterWrapper(aNewParameterSet,xParamsAsIndicies); 1843 aRequest.Parameters = xWrappedParameters; 1844 aRequest.Connection = _xConnection; 1845 OInteractionRequest* pRequest = new OInteractionRequest(makeAny(aRequest)); 1846 Reference< XInteractionRequest > xRequest(pRequest); 1847 // some knittings 1848 pRequest->addContinuation(pAbort); 1849 pRequest->addContinuation(pParams); 1850 1851 // execute the request 1852 _rxHandler->handle(xRequest); 1853 1854 if (!pParams->wasSelected()) 1855 { 1856 // canceled by the user (i.e. (s)he canceled the dialog) 1857 RowSetVetoException e; 1858 e.ErrorCode = ParameterInteractionCancelled; 1859 throw e; 1860 } 1861 1862 // now transfer the values from the continuation object to the parameter columns 1863 Sequence< PropertyValue > aFinalValues = pParams->getValues(); 1864 const PropertyValue* pFinalValues = aFinalValues.getConstArray(); 1865 for (sal_Int32 i=0; i<aFinalValues.getLength(); ++i, ++pFinalValues) 1866 { 1867 Reference< XPropertySet > xParamColumn(xWrappedParameters->getByIndex(i),UNO_QUERY); 1868 if (xParamColumn.is()) 1869 { 1870 ::rtl::OUString sName; 1871 xParamColumn->getPropertyValue(PROPERTY_NAME) >>= sName; 1872 OSL_ENSURE(sName.equals(pFinalValues->Name), "::dbaui::askForParameters: inconsistent parameter names!"); 1873 1874 // determine the field type and ... 1875 sal_Int32 nParamType = 0; 1876 xParamColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE)) >>= nParamType; 1877 // ... the scale of the parameter column 1878 sal_Int32 nScale = 0; 1879 if (hasProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE), xParamColumn)) 1880 xParamColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE)) >>= nScale; 1881 // (the index of the parameters is one-based) 1882 TParameterPositions::iterator aFind = aParameterNames.find(pFinalValues->Name); 1883 ::std::vector<sal_Int32>::iterator aIterPos = aFind->second.begin(); 1884 ::std::vector<sal_Int32>::iterator aEndPos = aFind->second.end(); 1885 for(;aIterPos != aEndPos;++aIterPos) 1886 { 1887 if ( _aParametersSet.empty() || !_aParametersSet[(*aIterPos)-1] ) 1888 { 1889 _xParameters->setObjectWithInfo(*aIterPos, pFinalValues->Value, nParamType, nScale); 1890 } 1891 } 1892 } 1893 } 1894 } 1895 } 1896 // ----------------------------------------------------------------------------- 1897 void setObjectWithInfo(const Reference<XParameters>& _xParams, 1898 sal_Int32 parameterIndex, 1899 const Any& x, 1900 sal_Int32 sqlType, 1901 sal_Int32 scale) 1902 { 1903 ORowSetValue aVal; 1904 aVal.fill(x); 1905 setObjectWithInfo(_xParams,parameterIndex,aVal,sqlType,scale); 1906 } 1907 // ----------------------------------------------------------------------------- 1908 void setObjectWithInfo(const Reference<XParameters>& _xParams, 1909 sal_Int32 parameterIndex, 1910 const ::connectivity::ORowSetValue& _rValue, 1911 sal_Int32 sqlType, 1912 sal_Int32 scale) 1913 { 1914 if ( _rValue.isNull() ) 1915 _xParams->setNull(parameterIndex,sqlType); 1916 else 1917 { 1918 switch(sqlType) 1919 { 1920 case DataType::DECIMAL: 1921 case DataType::NUMERIC: 1922 _xParams->setObjectWithInfo(parameterIndex,_rValue.makeAny(),sqlType,scale); 1923 break; 1924 case DataType::CHAR: 1925 case DataType::VARCHAR: 1926 case DataType::LONGVARCHAR: 1927 _xParams->setString(parameterIndex,_rValue); 1928 break; 1929 case DataType::CLOB: 1930 { 1931 Any x(_rValue.makeAny()); 1932 ::rtl::OUString sValue; 1933 if ( x >>= sValue ) 1934 _xParams->setString(parameterIndex,sValue); 1935 else 1936 { 1937 Reference< XClob > xClob; 1938 if(x >>= xClob) 1939 _xParams->setClob(parameterIndex,xClob); 1940 else 1941 { 1942 Reference< ::com::sun::star::io::XInputStream > xStream; 1943 if(x >>= xStream) 1944 _xParams->setCharacterStream(parameterIndex,xStream,xStream->available()); 1945 } 1946 } 1947 } 1948 break; 1949 case DataType::BIGINT: 1950 if ( _rValue.isSigned() ) 1951 _xParams->setLong(parameterIndex,_rValue); 1952 else 1953 _xParams->setString(parameterIndex,_rValue); 1954 break; 1955 1956 case DataType::FLOAT: 1957 _xParams->setFloat(parameterIndex,_rValue); 1958 break; 1959 case DataType::REAL: 1960 case DataType::DOUBLE: 1961 _xParams->setDouble(parameterIndex,_rValue); 1962 break; 1963 case DataType::DATE: 1964 _xParams->setDate(parameterIndex,_rValue); 1965 break; 1966 case DataType::TIME: 1967 _xParams->setTime(parameterIndex,_rValue); 1968 break; 1969 case DataType::TIMESTAMP: 1970 _xParams->setTimestamp(parameterIndex,_rValue); 1971 break; 1972 case DataType::BINARY: 1973 case DataType::VARBINARY: 1974 case DataType::LONGVARBINARY: 1975 case DataType::BLOB: 1976 { 1977 Any x(_rValue.makeAny()); 1978 Sequence< sal_Int8> aBytes; 1979 if(x >>= aBytes) 1980 _xParams->setBytes(parameterIndex,aBytes); 1981 else 1982 { 1983 Reference< XBlob > xBlob; 1984 if(x >>= xBlob) 1985 _xParams->setBlob(parameterIndex,xBlob); 1986 else 1987 { 1988 Reference< XClob > xClob; 1989 if(x >>= xClob) 1990 _xParams->setClob(parameterIndex,xClob); 1991 else 1992 { 1993 Reference< ::com::sun::star::io::XInputStream > xBinStream; 1994 if(x >>= xBinStream) 1995 _xParams->setBinaryStream(parameterIndex,xBinStream,xBinStream->available()); 1996 } 1997 } 1998 } 1999 } 2000 break; 2001 case DataType::BIT: 2002 case DataType::BOOLEAN: 2003 _xParams->setBoolean(parameterIndex,_rValue); 2004 break; 2005 case DataType::TINYINT: 2006 if ( _rValue.isSigned() ) 2007 _xParams->setByte(parameterIndex,_rValue); 2008 else 2009 _xParams->setShort(parameterIndex,_rValue); 2010 break; 2011 case DataType::SMALLINT: 2012 if ( _rValue.isSigned() ) 2013 _xParams->setShort(parameterIndex,_rValue); 2014 else 2015 _xParams->setInt(parameterIndex,_rValue); 2016 break; 2017 case DataType::INTEGER: 2018 if ( _rValue.isSigned() ) 2019 _xParams->setInt(parameterIndex,_rValue); 2020 else 2021 _xParams->setLong(parameterIndex,_rValue); 2022 break; 2023 default: 2024 { 2025 ::connectivity::SharedResources aResources; 2026 const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution( 2027 STR_UNKNOWN_PARA_TYPE, 2028 "$position$", ::rtl::OUString::valueOf(parameterIndex) 2029 ) ); 2030 ::dbtools::throwGenericSQLException(sError,NULL); 2031 } 2032 } 2033 } 2034 } 2035 2036 // -------------------------------------------------------------------- 2037 void getBoleanComparisonPredicate( const ::rtl::OUString& _rExpression, const sal_Bool _bValue, const sal_Int32 _nBooleanComparisonMode, 2038 ::rtl::OUStringBuffer& _out_rSQLPredicate ) 2039 { 2040 switch ( _nBooleanComparisonMode ) 2041 { 2042 case BooleanComparisonMode::IS_LITERAL: 2043 _out_rSQLPredicate.append( _rExpression ); 2044 if ( _bValue ) 2045 _out_rSQLPredicate.appendAscii( " IS TRUE" ); 2046 else 2047 _out_rSQLPredicate.appendAscii( " IS FALSE" ); 2048 break; 2049 2050 case BooleanComparisonMode::EQUAL_LITERAL: 2051 _out_rSQLPredicate.append( _rExpression ); 2052 _out_rSQLPredicate.appendAscii( _bValue ? " = TRUE" : " = FALSE" ); 2053 break; 2054 2055 case BooleanComparisonMode::ACCESS_COMPAT: 2056 if ( _bValue ) 2057 { 2058 _out_rSQLPredicate.appendAscii( " NOT ( ( " ); 2059 _out_rSQLPredicate.append( _rExpression ); 2060 _out_rSQLPredicate.appendAscii( " = 0 ) OR ( " ); 2061 _out_rSQLPredicate.append( _rExpression ); 2062 _out_rSQLPredicate.appendAscii( " IS NULL ) )" ); 2063 } 2064 else 2065 { 2066 _out_rSQLPredicate.append( _rExpression ); 2067 _out_rSQLPredicate.appendAscii( " = 0" ); 2068 } 2069 break; 2070 2071 case BooleanComparisonMode::EQUAL_INTEGER: 2072 // fall through 2073 default: 2074 _out_rSQLPredicate.append( _rExpression ); 2075 _out_rSQLPredicate.appendAscii( _bValue ? " = 1" : " = 0" ); 2076 break; 2077 } 2078 } 2079 2080 //......................................................................... 2081 } // namespace dbtools 2082 //......................................................................... 2083 2084 //......................................................................... 2085 namespace connectivity 2086 { 2087 //......................................................................... 2088 2089 void release(oslInterlockedCount& _refCount, 2090 ::cppu::OBroadcastHelper& rBHelper, 2091 Reference< XInterface >& _xInterface, 2092 ::com::sun::star::lang::XComponent* _pObject) 2093 { 2094 if (osl_decrementInterlockedCount( &_refCount ) == 0) 2095 { 2096 osl_incrementInterlockedCount( &_refCount ); 2097 2098 if (!rBHelper.bDisposed && !rBHelper.bInDispose) 2099 { 2100 // remember the parent 2101 Reference< XInterface > xParent; 2102 { 2103 ::osl::MutexGuard aGuard( rBHelper.rMutex ); 2104 xParent = _xInterface; 2105 _xInterface = NULL; 2106 } 2107 2108 // First dispose 2109 _pObject->dispose(); 2110 2111 // only the alive ref holds the object 2112 OSL_ASSERT( _refCount == 1 ); 2113 2114 // release the parent in the ~ 2115 if (xParent.is()) 2116 { 2117 ::osl::MutexGuard aGuard( rBHelper.rMutex ); 2118 _xInterface = xParent; 2119 } 2120 2121 // // destroy the object if xHoldAlive decrement the refcount to 0 2122 // m_pDerivedImplementation->WEAK::release(); 2123 } 2124 } 2125 else 2126 osl_incrementInterlockedCount( &_refCount ); 2127 } 2128 2129 void checkDisposed(sal_Bool _bThrow) 2130 { 2131 if (_bThrow) 2132 throw DisposedException(); 2133 2134 } 2135 // ------------------------------------------------------------------------- 2136 OSQLColumns::Vector::const_iterator find( OSQLColumns::Vector::const_iterator __first, 2137 OSQLColumns::Vector::const_iterator __last, 2138 const ::rtl::OUString& _rVal, 2139 const ::comphelper::UStringMixEqual& _rCase) 2140 { 2141 ::rtl::OUString sName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME); 2142 return find(__first,__last,sName,_rVal,_rCase); 2143 } 2144 // ------------------------------------------------------------------------- 2145 OSQLColumns::Vector::const_iterator findRealName( OSQLColumns::Vector::const_iterator __first, 2146 OSQLColumns::Vector::const_iterator __last, 2147 const ::rtl::OUString& _rVal, 2148 const ::comphelper::UStringMixEqual& _rCase) 2149 { 2150 ::rtl::OUString sRealName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_REALNAME); 2151 return find(__first,__last,sRealName,_rVal,_rCase); 2152 } 2153 // ------------------------------------------------------------------------- 2154 OSQLColumns::Vector::const_iterator find( OSQLColumns::Vector::const_iterator __first, 2155 OSQLColumns::Vector::const_iterator __last, 2156 const ::rtl::OUString& _rProp, 2157 const ::rtl::OUString& _rVal, 2158 const ::comphelper::UStringMixEqual& _rCase) 2159 { 2160 while (__first != __last && !_rCase(getString((*__first)->getPropertyValue(_rProp)),_rVal)) 2161 ++__first; 2162 return __first; 2163 } 2164 2165 // ----------------------------------------------------------------------------- 2166 } //namespace connectivity 2167 // ----------------------------------------------------------------------------- 2168