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