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 #include "connectivity/TTableHelper.hxx" 27 #include <com/sun/star/sdbc/XRow.hpp> 28 #include <com/sun/star/sdbc/XResultSet.hpp> 29 #include <com/sun/star/sdbcx/KeyType.hpp> 30 #include <com/sun/star/sdbc/KeyRule.hpp> 31 #include <cppuhelper/typeprovider.hxx> 32 #include <com/sun/star/lang/DisposedException.hpp> 33 #include <com/sun/star/sdbc/ColumnValue.hpp> 34 #include <comphelper/implementationreference.hxx> 35 #include <comphelper/sequence.hxx> 36 #include <comphelper/extract.hxx> 37 #include <comphelper/types.hxx> 38 #include "connectivity/dbtools.hxx" 39 #include "connectivity/sdbcx/VCollection.hxx" 40 #include <unotools/sharedunocomponent.hxx> 41 #include "TConnection.hxx" 42 43 using namespace ::comphelper; 44 using namespace connectivity; 45 using namespace ::com::sun::star::uno; 46 using namespace ::com::sun::star::beans; 47 using namespace ::com::sun::star::sdbcx; 48 using namespace ::com::sun::star::sdbc; 49 using namespace ::com::sun::star::container; 50 using namespace ::com::sun::star::lang; 51 namespace 52 { 53 /// helper class for column property change events which holds the OComponentDefinition weak 54 typedef ::cppu::WeakImplHelper1 < XContainerListener > OTableContainerListener_BASE; 55 class OTableContainerListener : public OTableContainerListener_BASE 56 { 57 OTableHelper* m_pComponent; 58 ::std::map< ::rtl::OUString,bool> m_aRefNames; 59 60 OTableContainerListener(const OTableContainerListener&); 61 void operator =(const OTableContainerListener&); 62 protected: 63 virtual ~OTableContainerListener(){} 64 public: 65 OTableContainerListener(OTableHelper* _pComponent) : m_pComponent(_pComponent){} 66 virtual void SAL_CALL elementInserted( const ::com::sun::star::container::ContainerEvent& /*Event*/ ) throw (RuntimeException) 67 { 68 } 69 virtual void SAL_CALL elementRemoved( const ::com::sun::star::container::ContainerEvent& Event ) throw (RuntimeException) 70 { 71 ::rtl::OUString sName; 72 Event.Accessor >>= sName; 73 if ( m_aRefNames.find(sName) != m_aRefNames.end() ) 74 m_pComponent->refreshKeys(); 75 } 76 virtual void SAL_CALL elementReplaced( const ::com::sun::star::container::ContainerEvent& Event ) throw (RuntimeException) 77 { 78 ::rtl::OUString sOldComposedName,sNewComposedName; 79 Event.ReplacedElement >>= sOldComposedName; 80 Event.Accessor >>= sNewComposedName; 81 if ( sOldComposedName != sNewComposedName && m_aRefNames.find(sOldComposedName) != m_aRefNames.end() ) 82 m_pComponent->refreshKeys(); 83 } 84 // XEventListener 85 virtual void SAL_CALL disposing( const EventObject& /*_rSource*/ ) throw (RuntimeException) 86 { 87 } 88 void clear() { m_pComponent = NULL; } 89 inline void add(const ::rtl::OUString& _sRefName) { m_aRefNames.insert(::std::map< ::rtl::OUString,bool>::value_type(_sRefName,true)); } 90 }; 91 } 92 namespace connectivity 93 { 94 ::rtl::OUString lcl_getServiceNameForSetting(const Reference< ::com::sun::star::sdbc::XConnection >& _xConnection,const ::rtl::OUString& i_sSetting) 95 { 96 ::rtl::OUString sSupportService; 97 Any aValue; 98 if ( ::dbtools::getDataSourceSetting(_xConnection,i_sSetting,aValue) ) 99 { 100 aValue >>= sSupportService; 101 } 102 return sSupportService; 103 } 104 struct OTableHelperImpl 105 { 106 TKeyMap m_aKeys; 107 // helper services which can be provided by extensions 108 Reference< ::com::sun::star::sdb::tools::XTableRename> m_xRename; 109 Reference< ::com::sun::star::sdb::tools::XTableAlteration> m_xAlter; 110 Reference< ::com::sun::star::sdb::tools::XKeyAlteration> m_xKeyAlter; 111 Reference< ::com::sun::star::sdb::tools::XIndexAlteration> m_xIndexAlter; 112 113 Reference< ::com::sun::star::sdbc::XDatabaseMetaData > m_xMetaData; 114 Reference< ::com::sun::star::sdbc::XConnection > m_xConnection; 115 ::comphelper::ImplementationReference< OTableContainerListener,XContainerListener> 116 m_xTablePropertyListener; 117 ::std::vector< ColumnDesc > m_aColumnDesc; 118 OTableHelperImpl(const Reference< ::com::sun::star::sdbc::XConnection >& _xConnection) 119 : m_xConnection(_xConnection) 120 { 121 try 122 { 123 m_xMetaData = m_xConnection->getMetaData(); 124 Reference<XMultiServiceFactory> xFac(_xConnection,UNO_QUERY); 125 if ( xFac.is() ) 126 { 127 static const ::rtl::OUString s_sTableRename(RTL_CONSTASCII_USTRINGPARAM("TableRenameServiceName")); 128 m_xRename.set(xFac->createInstance(lcl_getServiceNameForSetting(m_xConnection,s_sTableRename)),UNO_QUERY); 129 static const ::rtl::OUString s_sTableAlteration(RTL_CONSTASCII_USTRINGPARAM("TableAlterationServiceName")); 130 m_xAlter.set(xFac->createInstance(lcl_getServiceNameForSetting(m_xConnection,s_sTableAlteration)),UNO_QUERY); 131 static const ::rtl::OUString s_sKeyAlteration(RTL_CONSTASCII_USTRINGPARAM("KeyAlterationServiceName")); 132 m_xKeyAlter.set(xFac->createInstance(lcl_getServiceNameForSetting(m_xConnection,s_sKeyAlteration)),UNO_QUERY); 133 static const ::rtl::OUString s_sIndexAlteration(RTL_CONSTASCII_USTRINGPARAM("IndexAlterationServiceName")); 134 m_xIndexAlter.set(xFac->createInstance(lcl_getServiceNameForSetting(m_xConnection,s_sIndexAlteration)),UNO_QUERY); 135 } 136 } 137 catch(const Exception&) 138 { 139 } 140 } 141 }; 142 } 143 144 OTableHelper::OTableHelper( sdbcx::OCollection* _pTables, 145 const Reference< XConnection >& _xConnection, 146 sal_Bool _bCase) 147 :OTable_TYPEDEF(_pTables,_bCase) 148 ,m_pImpl(new OTableHelperImpl(_xConnection)) 149 { 150 } 151 // ------------------------------------------------------------------------- 152 OTableHelper::OTableHelper( sdbcx::OCollection* _pTables, 153 const Reference< XConnection >& _xConnection, 154 sal_Bool _bCase, 155 const ::rtl::OUString& _Name, 156 const ::rtl::OUString& _Type, 157 const ::rtl::OUString& _Description , 158 const ::rtl::OUString& _SchemaName, 159 const ::rtl::OUString& _CatalogName 160 ) : OTable_TYPEDEF(_pTables, 161 _bCase, 162 _Name, 163 _Type, 164 _Description, 165 _SchemaName, 166 _CatalogName) 167 ,m_pImpl(new OTableHelperImpl(_xConnection)) 168 { 169 } 170 // ----------------------------------------------------------------------------- 171 OTableHelper::~OTableHelper() 172 { 173 } 174 // ----------------------------------------------------------------------------- 175 void SAL_CALL OTableHelper::disposing() 176 { 177 ::osl::MutexGuard aGuard(m_aMutex); 178 if ( m_pImpl->m_xTablePropertyListener.is() ) 179 { 180 m_pTables->removeContainerListener(m_pImpl->m_xTablePropertyListener.getRef()); 181 m_pImpl->m_xTablePropertyListener->clear(); 182 m_pImpl->m_xTablePropertyListener.dispose(); 183 } 184 OTable_TYPEDEF::disposing(); 185 186 m_pImpl->m_xConnection = NULL; 187 m_pImpl->m_xMetaData = NULL; 188 189 } 190 191 // ------------------------------------------------------------------------- 192 namespace 193 { 194 /** collects ColumnDesc's from a resultset produced by XDatabaseMetaData::getColumns 195 */ 196 void lcl_collectColumnDescs_throw( const Reference< XResultSet >& _rxResult, ::std::vector< ColumnDesc >& _out_rColumns ) 197 { 198 Reference< XRow > xRow( _rxResult, UNO_QUERY_THROW ); 199 ::rtl::OUString sName; 200 OrdinalPosition nOrdinalPosition( 0 ); 201 while ( _rxResult->next() ) 202 { 203 sName = xRow->getString( 4 ); // COLUMN_NAME 204 sal_Int32 nField5 = xRow->getInt(5); 205 ::rtl::OUString aField6 = xRow->getString(6); 206 sal_Int32 nField7 = xRow->getInt(7) 207 , nField9 = xRow->getInt(9) 208 , nField11= xRow->getInt(11); 209 ::rtl::OUString sField12 = xRow->getString(12) 210 ,sField13 = xRow->getString(13); 211 nOrdinalPosition = xRow->getInt( 17 ); // ORDINAL_POSITION 212 _out_rColumns.push_back( ColumnDesc( sName,nField5,aField6,nField7,nField9,nField11,sField12,sField13, nOrdinalPosition ) ); 213 } 214 } 215 216 /** checks a given array of ColumnDesc's whether it has reasonable ordinal positions. If not, 217 they will be normalized to be the array index. 218 */ 219 void lcl_sanitizeColumnDescs( ::std::vector< ColumnDesc >& _rColumns ) 220 { 221 if ( _rColumns.empty() ) 222 return; 223 224 // collect all used ordinals 225 ::std::set< OrdinalPosition > aUsedOrdinals; 226 for ( ::std::vector< ColumnDesc >::iterator collect = _rColumns.begin(); 227 collect != _rColumns.end(); 228 ++collect 229 ) 230 aUsedOrdinals.insert( collect->nOrdinalPosition ); 231 232 // we need to have as much different ordinals as we have different columns 233 bool bDuplicates = aUsedOrdinals.size() != _rColumns.size(); 234 // and it needs to be a continuous range 235 size_t nOrdinalsRange = *aUsedOrdinals.rbegin() - *aUsedOrdinals.begin() + 1; 236 bool bGaps = nOrdinalsRange != _rColumns.size(); 237 238 // if that's not the case, normalize it 239 if ( bGaps || bDuplicates ) 240 { 241 OSL_ENSURE( false, "lcl_sanitizeColumnDescs: database did provide invalid ORDINAL_POSITION values!" ); 242 243 OrdinalPosition nNormalizedPosition = 1; 244 for ( ::std::vector< ColumnDesc >::iterator normalize = _rColumns.begin(); 245 normalize != _rColumns.end(); 246 ++normalize 247 ) 248 normalize->nOrdinalPosition = nNormalizedPosition++; 249 return; 250 } 251 252 // what's left is that the range might not be from 1 to <column count>, but for instance 253 // 0 to <column count>-1. 254 size_t nOffset = *aUsedOrdinals.begin() - 1; 255 for ( ::std::vector< ColumnDesc >::iterator offset = _rColumns.begin(); 256 offset != _rColumns.end(); 257 ++offset 258 ) 259 offset->nOrdinalPosition -= nOffset; 260 } 261 } 262 263 // ------------------------------------------------------------------------- 264 void OTableHelper::refreshColumns() 265 { 266 TStringVector aVector; 267 if(!isNew()) 268 { 269 Any aCatalog; 270 if ( m_CatalogName.getLength() ) 271 aCatalog <<= m_CatalogName; 272 273 ::utl::SharedUNOComponent< XResultSet > xResult( getMetaData()->getColumns( 274 aCatalog, 275 m_SchemaName, 276 m_Name, 277 ::rtl::OUString::createFromAscii("%") 278 ) ); 279 280 // collect the column names, together with their ordinal position 281 m_pImpl->m_aColumnDesc.clear(); 282 lcl_collectColumnDescs_throw( xResult, m_pImpl->m_aColumnDesc ); 283 284 // ensure that the ordinal positions as obtained from the meta data do make sense 285 lcl_sanitizeColumnDescs( m_pImpl->m_aColumnDesc ); 286 287 // sort by ordinal position 288 ::std::map< OrdinalPosition, ::rtl::OUString > aSortedColumns; 289 for ( ::std::vector< ColumnDesc >::const_iterator copy = m_pImpl->m_aColumnDesc.begin(); 290 copy != m_pImpl->m_aColumnDesc.end(); 291 ++copy 292 ) 293 aSortedColumns[ copy->nOrdinalPosition ] = copy->sName; 294 295 // copy them to aVector, now that we have the proper ordering 296 ::std::transform( 297 aSortedColumns.begin(), 298 aSortedColumns.end(), 299 ::std::insert_iterator< TStringVector >( aVector, aVector.begin() ), 300 ::std::select2nd< ::std::map< OrdinalPosition, ::rtl::OUString >::value_type >() 301 ); 302 } 303 304 if(m_pColumns) 305 m_pColumns->reFill(aVector); 306 else 307 m_pColumns = createColumns(aVector); 308 } 309 // ----------------------------------------------------------------------------- 310 const ColumnDesc* OTableHelper::getColumnDescription(const ::rtl::OUString& _sName) const 311 { 312 const ColumnDesc* pRet = NULL; 313 ::std::vector< ColumnDesc >::const_iterator aEnd = m_pImpl->m_aColumnDesc.end(); 314 for (::std::vector< ColumnDesc >::const_iterator aIter = m_pImpl->m_aColumnDesc.begin();aIter != aEnd;++aIter) 315 { 316 if ( aIter->sName == _sName ) 317 { 318 pRet = &*aIter; 319 break; 320 } 321 } // for (::std::vector< ColumnDesc >::const_iterator aIter = m_pImpl->m_aColumnDesc.begin();aIter != aEnd;++aIter) 322 return pRet; 323 } 324 // ------------------------------------------------------------------------- 325 void OTableHelper::refreshPrimaryKeys(TStringVector& _rNames) 326 { 327 Any aCatalog; 328 if ( m_CatalogName.getLength() ) 329 aCatalog <<= m_CatalogName; 330 Reference< XResultSet > xResult = getMetaData()->getPrimaryKeys(aCatalog,m_SchemaName,m_Name); 331 332 if ( xResult.is() ) 333 { 334 sdbcx::TKeyProperties pKeyProps(new sdbcx::KeyProperties(::rtl::OUString(),KeyType::PRIMARY,0,0)); 335 ::rtl::OUString aPkName; 336 bool bAlreadyFetched = false; 337 const Reference< XRow > xRow(xResult,UNO_QUERY); 338 while ( xResult->next() ) 339 { 340 pKeyProps->m_aKeyColumnNames.push_back(xRow->getString(4)); 341 if ( !bAlreadyFetched ) 342 { 343 aPkName = xRow->getString(6); 344 bAlreadyFetched = true; 345 } 346 } 347 348 m_pImpl->m_aKeys.insert(TKeyMap::value_type(aPkName,pKeyProps)); 349 _rNames.push_back(aPkName); 350 } // if ( xResult.is() && xResult->next() ) 351 ::comphelper::disposeComponent(xResult); 352 } 353 // ------------------------------------------------------------------------- 354 void OTableHelper::refreshForgeinKeys(TStringVector& _rNames) 355 { 356 Any aCatalog; 357 if ( m_CatalogName.getLength() ) 358 aCatalog <<= m_CatalogName; 359 Reference< XResultSet > xResult = getMetaData()->getImportedKeys(aCatalog,m_SchemaName,m_Name); 360 Reference< XRow > xRow(xResult,UNO_QUERY); 361 362 if ( xRow.is() ) 363 { 364 sdbcx::TKeyProperties pKeyProps; 365 ::rtl::OUString aName,sCatalog,aSchema,sOldFKName; 366 while( xResult->next() ) 367 { 368 // this must be outsid the "if" because we have to call in a right order 369 sCatalog = xRow->getString(1); 370 if ( xRow->wasNull() ) 371 sCatalog = ::rtl::OUString(); 372 aSchema = xRow->getString(2); 373 aName = xRow->getString(3); 374 375 const ::rtl::OUString sForeignKeyColumn = xRow->getString(8); 376 const sal_Int32 nUpdateRule = xRow->getInt(10); 377 const sal_Int32 nDeleteRule = xRow->getInt(11); 378 const ::rtl::OUString sFkName = xRow->getString(12); 379 380 if ( pKeyProps.get() ) 381 { 382 } 383 384 385 if ( sFkName.getLength() && !xRow->wasNull() ) 386 { 387 if ( sOldFKName != sFkName ) 388 { 389 if ( pKeyProps.get() ) 390 m_pImpl->m_aKeys.insert(TKeyMap::value_type(sOldFKName,pKeyProps)); 391 392 const ::rtl::OUString sReferencedName = ::dbtools::composeTableName(getMetaData(),sCatalog,aSchema,aName,sal_False,::dbtools::eInDataManipulation); 393 pKeyProps.reset(new sdbcx::KeyProperties(sReferencedName,KeyType::FOREIGN,nUpdateRule,nDeleteRule)); 394 pKeyProps->m_aKeyColumnNames.push_back(sForeignKeyColumn); 395 _rNames.push_back(sFkName); 396 if ( m_pTables->hasByName(sReferencedName) ) 397 { 398 if ( !m_pImpl->m_xTablePropertyListener.is() ) 399 m_pImpl->m_xTablePropertyListener = ::comphelper::ImplementationReference< OTableContainerListener,XContainerListener>( new OTableContainerListener(this) ); 400 m_pTables->addContainerListener(m_pImpl->m_xTablePropertyListener.getRef()); 401 m_pImpl->m_xTablePropertyListener->add(sReferencedName); 402 } // if ( m_pTables->hasByName(sReferencedName) ) 403 sOldFKName = sFkName; 404 } // if ( sOldFKName != sFkName ) 405 else if ( pKeyProps.get() ) 406 { 407 pKeyProps->m_aKeyColumnNames.push_back(sForeignKeyColumn); 408 } 409 } 410 } // while( xResult->next() ) 411 if ( pKeyProps.get() ) 412 m_pImpl->m_aKeys.insert(TKeyMap::value_type(sOldFKName,pKeyProps)); 413 ::comphelper::disposeComponent(xResult); 414 } 415 } 416 // ------------------------------------------------------------------------- 417 void OTableHelper::refreshKeys() 418 { 419 m_pImpl->m_aKeys.clear(); 420 421 TStringVector aNames; 422 423 if(!isNew()) 424 { 425 refreshPrimaryKeys(aNames); 426 refreshForgeinKeys(aNames); 427 m_pKeys = createKeys(aNames); 428 } // if(!isNew()) 429 else if (!m_pKeys ) 430 m_pKeys = createKeys(aNames); 431 /*if(m_pKeys) 432 m_pKeys->reFill(aVector); 433 else*/ 434 435 } 436 // ------------------------------------------------------------------------- 437 void OTableHelper::refreshIndexes() 438 { 439 TStringVector aVector; 440 if(!isNew()) 441 { 442 // fill indexes 443 Any aCatalog; 444 if ( m_CatalogName.getLength() ) 445 aCatalog <<= m_CatalogName; 446 Reference< XResultSet > xResult = getMetaData()->getIndexInfo(aCatalog,m_SchemaName,m_Name,sal_False,sal_False); 447 448 if(xResult.is()) 449 { 450 Reference< XRow > xRow(xResult,UNO_QUERY); 451 ::rtl::OUString aName; 452 ::rtl::OUString sCatalogSep = getMetaData()->getCatalogSeparator(); 453 ::rtl::OUString sPreviousRoundName; 454 while( xResult->next() ) 455 { 456 aName = xRow->getString(5); 457 if(aName.getLength()) 458 aName += sCatalogSep; 459 aName += xRow->getString(6); 460 if ( aName.getLength() ) 461 { 462 // don't insert the name if the last one we inserted was the same 463 if (sPreviousRoundName != aName) 464 aVector.push_back(aName); 465 } 466 sPreviousRoundName = aName; 467 } 468 ::comphelper::disposeComponent(xResult); 469 } 470 } 471 472 if(m_pIndexes) 473 m_pIndexes->reFill(aVector); 474 else 475 m_pIndexes = createIndexes(aVector); 476 } 477 // ----------------------------------------------------------------------------- 478 ::rtl::OUString OTableHelper::getRenameStart() const 479 { 480 ::rtl::OUString sSql(RTL_CONSTASCII_USTRINGPARAM("RENAME ")); 481 if ( m_Type == ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VIEW")) ) 482 sSql += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" VIEW ")); 483 else 484 sSql += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" TABLE ")); 485 486 return sSql; 487 } 488 // ------------------------------------------------------------------------- 489 // XRename 490 void SAL_CALL OTableHelper::rename( const ::rtl::OUString& newName ) throw(SQLException, ElementExistException, RuntimeException) 491 { 492 ::osl::MutexGuard aGuard(m_aMutex); 493 checkDisposed( 494 #ifdef GCC 495 ::connectivity::sdbcx::OTableDescriptor_BASE::rBHelper.bDisposed 496 #else 497 rBHelper.bDisposed 498 #endif 499 ); 500 501 if(!isNew()) 502 { 503 if ( m_pImpl->m_xRename.is() ) 504 { 505 m_pImpl->m_xRename->rename(this,newName); 506 } 507 else 508 { 509 ::rtl::OUString sSql = getRenameStart(); 510 ::rtl::OUString sQuote = getMetaData()->getIdentifierQuoteString( ); 511 512 ::rtl::OUString sCatalog,sSchema,sTable; 513 ::dbtools::qualifiedNameComponents(getMetaData(),newName,sCatalog,sSchema,sTable,::dbtools::eInDataManipulation); 514 515 ::rtl::OUString sComposedName; 516 sComposedName = ::dbtools::composeTableName(getMetaData(),m_CatalogName,m_SchemaName,m_Name,sal_True,::dbtools::eInDataManipulation); 517 sSql += sComposedName 518 + ::rtl::OUString::createFromAscii(" TO "); 519 sComposedName = ::dbtools::composeTableName(getMetaData(),sCatalog,sSchema,sTable,sal_True,::dbtools::eInDataManipulation); 520 sSql += sComposedName; 521 522 Reference< XStatement > xStmt = m_pImpl->m_xConnection->createStatement( ); 523 if ( xStmt.is() ) 524 { 525 xStmt->execute(sSql); 526 ::comphelper::disposeComponent(xStmt); 527 } 528 } 529 530 OTable_TYPEDEF::rename(newName); 531 } 532 else 533 ::dbtools::qualifiedNameComponents(getMetaData(),newName,m_CatalogName,m_SchemaName,m_Name,::dbtools::eInTableDefinitions); 534 } 535 // ----------------------------------------------------------------------------- 536 Reference< XDatabaseMetaData> OTableHelper::getMetaData() const 537 { 538 return m_pImpl->m_xMetaData; 539 } 540 // ------------------------------------------------------------------------- 541 void SAL_CALL OTableHelper::alterColumnByIndex( sal_Int32 index, const Reference< XPropertySet >& descriptor ) throw(SQLException, ::com::sun::star::lang::IndexOutOfBoundsException, RuntimeException) 542 { 543 ::osl::MutexGuard aGuard(m_aMutex); 544 checkDisposed( 545 #ifdef GCC 546 ::connectivity::sdbcx::OTableDescriptor_BASE::rBHelper.bDisposed 547 #else 548 rBHelper.bDisposed 549 #endif 550 ); 551 552 Reference< XPropertySet > xOld; 553 if(::cppu::extractInterface(xOld,m_pColumns->getByIndex(index)) && xOld.is()) 554 alterColumnByName(getString(xOld->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME))),descriptor); 555 } 556 557 // ------------------------------------------------------------------------- 558 ::rtl::OUString SAL_CALL OTableHelper::getName() throw(RuntimeException) 559 { 560 ::rtl::OUString sComposedName; 561 sComposedName = ::dbtools::composeTableName(getMetaData(),m_CatalogName,m_SchemaName,m_Name,sal_False,::dbtools::eInDataManipulation); 562 return sComposedName; 563 } 564 // ----------------------------------------------------------------------------- 565 void SAL_CALL OTableHelper::acquire() throw() 566 { 567 OTable_TYPEDEF::acquire(); 568 } 569 // ----------------------------------------------------------------------------- 570 void SAL_CALL OTableHelper::release() throw() 571 { 572 OTable_TYPEDEF::release(); 573 } 574 // ----------------------------------------------------------------------------- 575 sdbcx::TKeyProperties OTableHelper::getKeyProperties(const ::rtl::OUString& _sName) const 576 { 577 sdbcx::TKeyProperties pKeyProps; 578 TKeyMap::const_iterator aFind = m_pImpl->m_aKeys.find(_sName); 579 if ( aFind != m_pImpl->m_aKeys.end() ) 580 { 581 pKeyProps = aFind->second; 582 } 583 else // only a fall back 584 { 585 OSL_ENSURE(0,"No key with the given name found"); 586 pKeyProps.reset(new sdbcx::KeyProperties()); 587 } 588 589 return pKeyProps; 590 } 591 // ----------------------------------------------------------------------------- 592 void OTableHelper::addKey(const ::rtl::OUString& _sName,const sdbcx::TKeyProperties& _aKeyProperties) 593 { 594 m_pImpl->m_aKeys.insert(TKeyMap::value_type(_sName,_aKeyProperties)); 595 } 596 // ----------------------------------------------------------------------------- 597 ::rtl::OUString OTableHelper::getTypeCreatePattern() const 598 { 599 return ::rtl::OUString(); 600 } 601 // ----------------------------------------------------------------------------- 602 Reference< XConnection> OTableHelper::getConnection() const 603 { 604 return m_pImpl->m_xConnection; 605 } 606 // ----------------------------------------------------------------------------- 607 Reference< ::com::sun::star::sdb::tools::XTableRename> OTableHelper::getRenameService() const 608 { 609 return m_pImpl->m_xRename; 610 } 611 // ----------------------------------------------------------------------------- 612 Reference< ::com::sun::star::sdb::tools::XTableAlteration> OTableHelper::getAlterService() const 613 { 614 return m_pImpl->m_xAlter; 615 } 616 // ----------------------------------------------------------------------------- 617 Reference< ::com::sun::star::sdb::tools::XKeyAlteration> OTableHelper::getKeyService() const 618 { 619 return m_pImpl->m_xKeyAlter; 620 } 621 // ----------------------------------------------------------------------------- 622 Reference< ::com::sun::star::sdb::tools::XIndexAlteration> OTableHelper::getIndexService() const 623 { 624 return m_pImpl->m_xIndexAlter; 625 } 626 // ----------------------------------------------------------------------------- 627