connectivity/source/commontools/TTableHelper.cxx

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