xref: /AOO41X/main/connectivity/source/commontools/TTableHelper.cxx (revision 9b5730f6ddef7eb82608ca4d31dc0d7678e652cf)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_connectivity.hxx"
#include "connectivity/TTableHelper.hxx"
#include <com/sun/star/sdbc/XRow.hpp>
#include <com/sun/star/sdbc/XResultSet.hpp>
#include <com/sun/star/sdbcx/KeyType.hpp>
#include <com/sun/star/sdbc/KeyRule.hpp>
#include <cppuhelper/typeprovider.hxx>
#include <com/sun/star/lang/DisposedException.hpp>
#include <com/sun/star/sdbc/ColumnValue.hpp>
#include <comphelper/implementationreference.hxx>
#include <comphelper/sequence.hxx>
#include <comphelper/extract.hxx>
#include <comphelper/types.hxx>
#include "connectivity/dbtools.hxx"
#include "connectivity/sdbcx/VCollection.hxx"
#include <unotools/sharedunocomponent.hxx>
#include "TConnection.hxx"

using namespace ::comphelper;
using namespace connectivity;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::sdbcx;
using namespace ::com::sun::star::sdbc;
using namespace ::com::sun::star::container;
using namespace ::com::sun::star::lang;
namespace
{
    /// helper class for column property change events which holds the OComponentDefinition weak
typedef ::cppu::WeakImplHelper1	< XContainerListener > OTableContainerListener_BASE;
class OTableContainerListener : public OTableContainerListener_BASE
{
    OTableHelper* m_pComponent;
    ::std::map< ::rtl::OUString,bool> m_aRefNames;

    OTableContainerListener(const OTableContainerListener&);
    void operator =(const OTableContainerListener&);
protected:
    virtual ~OTableContainerListener(){}
public:
    OTableContainerListener(OTableHelper* _pComponent) : m_pComponent(_pComponent){}
    virtual void SAL_CALL elementInserted( const ::com::sun::star::container::ContainerEvent& /*Event*/ ) throw (RuntimeException)
    {
    }
    virtual void SAL_CALL elementRemoved( const ::com::sun::star::container::ContainerEvent& Event ) throw (RuntimeException)
    {
        ::rtl::OUString sName;
		Event.Accessor	>>= sName;
        if ( m_aRefNames.find(sName) != m_aRefNames.end() )
            m_pComponent->refreshKeys();
    }
    virtual void SAL_CALL elementReplaced( const ::com::sun::star::container::ContainerEvent& Event ) throw (RuntimeException)
	{
        ::rtl::OUString sOldComposedName,sNewComposedName;
		Event.ReplacedElement	>>= sOldComposedName;
		Event.Accessor			>>= sNewComposedName;
        if ( sOldComposedName != sNewComposedName && m_aRefNames.find(sOldComposedName) != m_aRefNames.end() )
            m_pComponent->refreshKeys();
    }
	// XEventListener
	virtual void SAL_CALL disposing( const EventObject& /*_rSource*/ ) throw (RuntimeException)
    {
    }
    void clear() { m_pComponent = NULL; }
    inline void add(const ::rtl::OUString& _sRefName) { m_aRefNames.insert(::std::map< ::rtl::OUString,bool>::value_type(_sRefName,true)); }
};
}
namespace connectivity
{
    ::rtl::OUString lcl_getServiceNameForSetting(const Reference< ::com::sun::star::sdbc::XConnection >& _xConnection,const ::rtl::OUString& i_sSetting)
    {
        ::rtl::OUString sSupportService;
        Any aValue;
        if ( ::dbtools::getDataSourceSetting(_xConnection,i_sSetting,aValue) )
        {
            aValue >>= sSupportService;
        }
        return sSupportService;
    }
    struct OTableHelperImpl
    {
        TKeyMap  m_aKeys;
        // helper services which can be provided by extensions
        Reference< ::com::sun::star::sdb::tools::XTableRename>      m_xRename;
        Reference< ::com::sun::star::sdb::tools::XTableAlteration>  m_xAlter;
        Reference< ::com::sun::star::sdb::tools::XKeyAlteration>    m_xKeyAlter;
        Reference< ::com::sun::star::sdb::tools::XIndexAlteration>  m_xIndexAlter;

        Reference< ::com::sun::star::sdbc::XDatabaseMetaData >	    m_xMetaData;
		Reference< ::com::sun::star::sdbc::XConnection >			m_xConnection;
        ::comphelper::ImplementationReference< OTableContainerListener,XContainerListener>
                                    m_xTablePropertyListener;
        ::std::vector< ColumnDesc > m_aColumnDesc;
        OTableHelperImpl(const Reference< ::com::sun::star::sdbc::XConnection >& _xConnection)
            : m_xConnection(_xConnection)
        {
            try
	        {
		        m_xMetaData = m_xConnection->getMetaData();
                Reference<XMultiServiceFactory> xFac(_xConnection,UNO_QUERY);
                if ( xFac.is() )
                {
                    static const ::rtl::OUString s_sTableRename(RTL_CONSTASCII_USTRINGPARAM("TableRenameServiceName"));
                    m_xRename.set(xFac->createInstance(lcl_getServiceNameForSetting(m_xConnection,s_sTableRename)),UNO_QUERY);
                    static const ::rtl::OUString s_sTableAlteration(RTL_CONSTASCII_USTRINGPARAM("TableAlterationServiceName"));
                    m_xAlter.set(xFac->createInstance(lcl_getServiceNameForSetting(m_xConnection,s_sTableAlteration)),UNO_QUERY);
                    static const ::rtl::OUString s_sKeyAlteration(RTL_CONSTASCII_USTRINGPARAM("KeyAlterationServiceName"));
                    m_xKeyAlter.set(xFac->createInstance(lcl_getServiceNameForSetting(m_xConnection,s_sKeyAlteration)),UNO_QUERY);
                    static const ::rtl::OUString s_sIndexAlteration(RTL_CONSTASCII_USTRINGPARAM("IndexAlterationServiceName"));
                    m_xIndexAlter.set(xFac->createInstance(lcl_getServiceNameForSetting(m_xConnection,s_sIndexAlteration)),UNO_QUERY);
                }
	        }
	        catch(const Exception&)
	        {
	        }
        }
    };
}

OTableHelper::OTableHelper(	sdbcx::OCollection* _pTables,
						   const Reference< XConnection >& _xConnection,
						   sal_Bool _bCase)
	:OTable_TYPEDEF(_pTables,_bCase)
    ,m_pImpl(new OTableHelperImpl(_xConnection))
{
}
// -------------------------------------------------------------------------
OTableHelper::OTableHelper(	sdbcx::OCollection* _pTables,
							const Reference< XConnection >& _xConnection,
							sal_Bool _bCase,
							const ::rtl::OUString& _Name,
							const ::rtl::OUString& _Type,
							const ::rtl::OUString& _Description ,
							const ::rtl::OUString& _SchemaName,
							const ::rtl::OUString& _CatalogName
						) : OTable_TYPEDEF(_pTables,
											_bCase,
											_Name,
										  _Type,
										  _Description,
										  _SchemaName,
										  _CatalogName)
						,m_pImpl(new OTableHelperImpl(_xConnection))
{
}
// -----------------------------------------------------------------------------
OTableHelper::~OTableHelper()
{
}
// -----------------------------------------------------------------------------
void SAL_CALL OTableHelper::disposing()
{
    ::osl::MutexGuard aGuard(m_aMutex);
    if ( m_pImpl->m_xTablePropertyListener.is() )
    {
        m_pTables->removeContainerListener(m_pImpl->m_xTablePropertyListener.getRef());
        m_pImpl->m_xTablePropertyListener->clear();
        m_pImpl->m_xTablePropertyListener.dispose();
    }
	OTable_TYPEDEF::disposing();

	m_pImpl->m_xConnection	= NULL;
	m_pImpl->m_xMetaData	= NULL;

}

// -------------------------------------------------------------------------
namespace
{
    /** collects ColumnDesc's from a resultset produced by XDatabaseMetaData::getColumns
    */
    void lcl_collectColumnDescs_throw( const Reference< XResultSet >& _rxResult, ::std::vector< ColumnDesc >& _out_rColumns )
    {
        Reference< XRow > xRow( _rxResult, UNO_QUERY_THROW );
        ::rtl::OUString sName;
        OrdinalPosition nOrdinalPosition( 0 );
	    while ( _rxResult->next() )
        {
            sName = xRow->getString( 4 );           // COLUMN_NAME
            sal_Int32		nField5	= xRow->getInt(5);
			::rtl::OUString aField6 = xRow->getString(6);
			sal_Int32		nField7 = xRow->getInt(7)
						,	nField9 = xRow->getInt(9)
						,	nField11= xRow->getInt(11);
			::rtl::OUString  sField12 = xRow->getString(12)
                            ,sField13 = xRow->getString(13);
            nOrdinalPosition = xRow->getInt( 17 );  // ORDINAL_POSITION
            _out_rColumns.push_back( ColumnDesc( sName,nField5,aField6,nField7,nField9,nField11,sField12,sField13, nOrdinalPosition ) );
        }
    }

    /** checks a given array of ColumnDesc's whether it has reasonable ordinal positions. If not,
        they will be normalized to be the array index.
    */
    void lcl_sanitizeColumnDescs( ::std::vector< ColumnDesc >& _rColumns )
    {
        if ( _rColumns.empty() )
            return;

        // collect all used ordinals
        ::std::set< OrdinalPosition > aUsedOrdinals;
        for (   ::std::vector< ColumnDesc >::iterator collect = _rColumns.begin();
                collect != _rColumns.end();
                ++collect
            )
            aUsedOrdinals.insert( collect->nOrdinalPosition );

        // we need to have as much different ordinals as we have different columns
        bool bDuplicates = aUsedOrdinals.size() != _rColumns.size();
        // and it needs to be a continuous range
        size_t nOrdinalsRange = *aUsedOrdinals.rbegin() - *aUsedOrdinals.begin() + 1;
        bool bGaps = nOrdinalsRange != _rColumns.size();

        // if that's not the case, normalize it
        if ( bGaps || bDuplicates )
        {
            OSL_ENSURE( false, "lcl_sanitizeColumnDescs: database did provide invalid ORDINAL_POSITION values!" );

            OrdinalPosition nNormalizedPosition = 1;
            for (   ::std::vector< ColumnDesc >::iterator normalize = _rColumns.begin();
                    normalize != _rColumns.end();
                    ++normalize
                )
                normalize->nOrdinalPosition = nNormalizedPosition++;
            return;
        }

        // what's left is that the range might not be from 1 to <column count>, but for instance
        // 0 to <column count>-1.
        size_t nOffset = *aUsedOrdinals.begin() - 1;
        for (   ::std::vector< ColumnDesc >::iterator offset = _rColumns.begin();
                offset != _rColumns.end();
                ++offset
            )
            offset->nOrdinalPosition -= nOffset;
    }
}

// -------------------------------------------------------------------------
void OTableHelper::refreshColumns()
{
	TStringVector aVector;
	if(!isNew())
	{
		Any aCatalog;
		if ( m_CatalogName.getLength() )
			aCatalog <<= m_CatalogName;

        ::utl::SharedUNOComponent< XResultSet > xResult( getMetaData()->getColumns(
            aCatalog,
            m_SchemaName,
            m_Name,
            ::rtl::OUString::createFromAscii("%")
        ) );

        // collect the column names, together with their ordinal position
        m_pImpl->m_aColumnDesc.clear();
        lcl_collectColumnDescs_throw( xResult, m_pImpl->m_aColumnDesc );

        // ensure that the ordinal positions as obtained from the meta data do make sense
        lcl_sanitizeColumnDescs( m_pImpl->m_aColumnDesc );

        // sort by ordinal position
        ::std::map< OrdinalPosition, ::rtl::OUString > aSortedColumns;
        for (   ::std::vector< ColumnDesc >::const_iterator copy = m_pImpl->m_aColumnDesc.begin();
                copy != m_pImpl->m_aColumnDesc.end();
                ++copy
            )
            aSortedColumns[ copy->nOrdinalPosition ] = copy->sName;

        // copy them to aVector, now that we have the proper ordering
        ::std::transform(
            aSortedColumns.begin(),
            aSortedColumns.end(),
            ::std::insert_iterator< TStringVector >( aVector, aVector.begin() ),
            ::std::select2nd< ::std::map< OrdinalPosition, ::rtl::OUString >::value_type >()
        );
	}

	if(m_pColumns)
		m_pColumns->reFill(aVector);
	else
		m_pColumns	= createColumns(aVector);
}
// -----------------------------------------------------------------------------
const ColumnDesc* OTableHelper::getColumnDescription(const ::rtl::OUString& _sName) const
{
    const ColumnDesc* pRet = NULL;
    ::std::vector< ColumnDesc >::const_iterator aEnd = m_pImpl->m_aColumnDesc.end();
    for (::std::vector< ColumnDesc >::const_iterator aIter = m_pImpl->m_aColumnDesc.begin();aIter != aEnd;++aIter)
    {
        if ( aIter->sName == _sName )
        {
            pRet = &*aIter;
            break;
        }
    } // for (::std::vector< ColumnDesc >::const_iterator aIter = m_pImpl->m_aColumnDesc.begin();aIter != aEnd;++aIter)
    return pRet;
}
// -------------------------------------------------------------------------
void OTableHelper::refreshPrimaryKeys(TStringVector& _rNames)
{
	Any aCatalog;
	if ( m_CatalogName.getLength() )
		aCatalog <<= m_CatalogName;
    Reference< XResultSet > xResult = getMetaData()->getPrimaryKeys(aCatalog,m_SchemaName,m_Name);

	if ( xResult.is() )
	{
        sdbcx::TKeyProperties pKeyProps(new sdbcx::KeyProperties(::rtl::OUString(),KeyType::PRIMARY,0,0));
        ::rtl::OUString aPkName;
        bool bAlreadyFetched = false;
        const Reference< XRow > xRow(xResult,UNO_QUERY);
        while ( xResult->next() )
        {
            pKeyProps->m_aKeyColumnNames.push_back(xRow->getString(4));
            if ( !bAlreadyFetched )
            {
		        aPkName = xRow->getString(6);
                bAlreadyFetched = true;
            }
        }

        m_pImpl->m_aKeys.insert(TKeyMap::value_type(aPkName,pKeyProps));
        _rNames.push_back(aPkName);
	} // if ( xResult.is() && xResult->next() )
    ::comphelper::disposeComponent(xResult);
}
// -------------------------------------------------------------------------
void OTableHelper::refreshForgeinKeys(TStringVector& _rNames)
{
	Any aCatalog;
	if ( m_CatalogName.getLength() )
		aCatalog <<= m_CatalogName;
	Reference< XResultSet > xResult = getMetaData()->getImportedKeys(aCatalog,m_SchemaName,m_Name);
	Reference< XRow > xRow(xResult,UNO_QUERY);

	if ( xRow.is() )
	{
        sdbcx::TKeyProperties pKeyProps;
        ::rtl::OUString aName,sCatalog,aSchema,sOldFKName;
		while( xResult->next() )
		{
            // this must be outsid the "if" because we have to call in a right order
			sCatalog	= xRow->getString(1);
			if ( xRow->wasNull() )
				sCatalog = ::rtl::OUString();
			aSchema		= xRow->getString(2);
			aName		= xRow->getString(3);

            const ::rtl::OUString sForeignKeyColumn = xRow->getString(8);
			const sal_Int32 nUpdateRule = xRow->getInt(10);
			const sal_Int32 nDeleteRule = xRow->getInt(11);
            const ::rtl::OUString sFkName = xRow->getString(12);

                if ( pKeyProps.get() )
                {
                }


			if ( sFkName.getLength() && !xRow->wasNull() )
            {
                if ( sOldFKName != sFkName )
                {
                    if ( pKeyProps.get() )
                        m_pImpl->m_aKeys.insert(TKeyMap::value_type(sOldFKName,pKeyProps));

                    const ::rtl::OUString sReferencedName = ::dbtools::composeTableName(getMetaData(),sCatalog,aSchema,aName,sal_False,::dbtools::eInDataManipulation);
                    pKeyProps.reset(new sdbcx::KeyProperties(sReferencedName,KeyType::FOREIGN,nUpdateRule,nDeleteRule));
                    pKeyProps->m_aKeyColumnNames.push_back(sForeignKeyColumn);
                    _rNames.push_back(sFkName);
                    if ( m_pTables->hasByName(sReferencedName) )
                    {
                        if ( !m_pImpl->m_xTablePropertyListener.is() )
                            m_pImpl->m_xTablePropertyListener = ::comphelper::ImplementationReference< OTableContainerListener,XContainerListener>( new OTableContainerListener(this) );
                        m_pTables->addContainerListener(m_pImpl->m_xTablePropertyListener.getRef());
                        m_pImpl->m_xTablePropertyListener->add(sReferencedName);
                    } // if ( m_pTables->hasByName(sReferencedName) )
                    sOldFKName = sFkName;
                } // if ( sOldFKName != sFkName )
                else if ( pKeyProps.get() )
                {
                    pKeyProps->m_aKeyColumnNames.push_back(sForeignKeyColumn);
                }
            }
		} // while( xResult->next() )
        if ( pKeyProps.get() )
            m_pImpl->m_aKeys.insert(TKeyMap::value_type(sOldFKName,pKeyProps));
		::comphelper::disposeComponent(xResult);
	}
}
// -------------------------------------------------------------------------
void OTableHelper::refreshKeys()
{
	m_pImpl->m_aKeys.clear();

    TStringVector aNames;

	if(!isNew())
	{
		refreshPrimaryKeys(aNames);
		refreshForgeinKeys(aNames);
        m_pKeys	= createKeys(aNames);
	} // if(!isNew())
    else if (!m_pKeys )
        m_pKeys	= createKeys(aNames);
	/*if(m_pKeys)
		m_pKeys->reFill(aVector);
	else*/

}
// -------------------------------------------------------------------------
void OTableHelper::refreshIndexes()
{
	TStringVector aVector;
	if(!isNew())
	{
		// fill indexes
		Any aCatalog;
		if ( m_CatalogName.getLength() )
			aCatalog <<= m_CatalogName;
		Reference< XResultSet > xResult = getMetaData()->getIndexInfo(aCatalog,m_SchemaName,m_Name,sal_False,sal_False);

		if(xResult.is())
		{
			Reference< XRow > xRow(xResult,UNO_QUERY);
			::rtl::OUString aName;
			::rtl::OUString sCatalogSep = getMetaData()->getCatalogSeparator();
			::rtl::OUString sPreviousRoundName;
			while( xResult->next() )
			{
				aName = xRow->getString(5);
				if(aName.getLength())
					aName += sCatalogSep;
				aName += xRow->getString(6);
				if ( aName.getLength() )
				{
					// don't insert the name if the last one we inserted was the same
					if (sPreviousRoundName != aName)
						aVector.push_back(aName);
				}
				sPreviousRoundName = aName;
			}
			::comphelper::disposeComponent(xResult);
		}
	}

	if(m_pIndexes)
		m_pIndexes->reFill(aVector);
	else
		m_pIndexes	= createIndexes(aVector);
}
// -----------------------------------------------------------------------------
::rtl::OUString OTableHelper::getRenameStart() const
{
    ::rtl::OUString sSql(RTL_CONSTASCII_USTRINGPARAM("RENAME "));
    if ( m_Type == ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VIEW")) )
	    sSql += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" VIEW "));
    else
	    sSql += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" TABLE "));

    return sSql;
}
// -------------------------------------------------------------------------
// XRename
void SAL_CALL OTableHelper::rename( const ::rtl::OUString& newName ) throw(SQLException, ElementExistException, RuntimeException)
{
	::osl::MutexGuard aGuard(m_aMutex);
	checkDisposed(
#ifdef GCC
		::connectivity::sdbcx::OTableDescriptor_BASE::rBHelper.bDisposed
#else
		rBHelper.bDisposed
#endif
		);

	if(!isNew())
	{
        if ( m_pImpl->m_xRename.is() )
        {
            m_pImpl->m_xRename->rename(this,newName);
        }
        else
        {
		    ::rtl::OUString sSql = getRenameStart();
		    ::rtl::OUString sQuote = getMetaData()->getIdentifierQuoteString(  );

		    ::rtl::OUString sCatalog,sSchema,sTable;
		    ::dbtools::qualifiedNameComponents(getMetaData(),newName,sCatalog,sSchema,sTable,::dbtools::eInDataManipulation);

		    ::rtl::OUString sComposedName;
		    sComposedName = ::dbtools::composeTableName(getMetaData(),m_CatalogName,m_SchemaName,m_Name,sal_True,::dbtools::eInDataManipulation);
		    sSql += sComposedName
			     + ::rtl::OUString::createFromAscii(" TO ");
		    sComposedName = ::dbtools::composeTableName(getMetaData(),sCatalog,sSchema,sTable,sal_True,::dbtools::eInDataManipulation);
		    sSql += sComposedName;

		    Reference< XStatement > xStmt = m_pImpl->m_xConnection->createStatement(  );
		    if ( xStmt.is() )
		    {
			    xStmt->execute(sSql);
			    ::comphelper::disposeComponent(xStmt);
		    }
        }

		OTable_TYPEDEF::rename(newName);
	}
	else
		::dbtools::qualifiedNameComponents(getMetaData(),newName,m_CatalogName,m_SchemaName,m_Name,::dbtools::eInTableDefinitions);
}
// -----------------------------------------------------------------------------
Reference< XDatabaseMetaData> OTableHelper::getMetaData() const
{
	return m_pImpl->m_xMetaData;
}
// -------------------------------------------------------------------------
void SAL_CALL OTableHelper::alterColumnByIndex( sal_Int32 index, const Reference< XPropertySet >& descriptor ) throw(SQLException, ::com::sun::star::lang::IndexOutOfBoundsException, RuntimeException)
{
	::osl::MutexGuard aGuard(m_aMutex);
	checkDisposed(
#ifdef GCC
		::connectivity::sdbcx::OTableDescriptor_BASE::rBHelper.bDisposed
#else
		rBHelper.bDisposed
#endif
		);

	Reference< XPropertySet > xOld;
	if(::cppu::extractInterface(xOld,m_pColumns->getByIndex(index)) && xOld.is())
		alterColumnByName(getString(xOld->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME))),descriptor);
}

// -------------------------------------------------------------------------
::rtl::OUString SAL_CALL OTableHelper::getName() throw(RuntimeException)
{
	::rtl::OUString sComposedName;
	sComposedName = ::dbtools::composeTableName(getMetaData(),m_CatalogName,m_SchemaName,m_Name,sal_False,::dbtools::eInDataManipulation);
	return sComposedName;
}
// -----------------------------------------------------------------------------
void SAL_CALL OTableHelper::acquire() throw()
{
	OTable_TYPEDEF::acquire();
}
// -----------------------------------------------------------------------------
void SAL_CALL OTableHelper::release() throw()
{
	OTable_TYPEDEF::release();
}
// -----------------------------------------------------------------------------
sdbcx::TKeyProperties OTableHelper::getKeyProperties(const ::rtl::OUString& _sName) const
{
    sdbcx::TKeyProperties pKeyProps;
    TKeyMap::const_iterator aFind = m_pImpl->m_aKeys.find(_sName);
    if ( aFind != m_pImpl->m_aKeys.end() )
    {
        pKeyProps = aFind->second;
    }
    else // only a fall back
    {
        OSL_ENSURE(0,"No key with the given name found");
        pKeyProps.reset(new sdbcx::KeyProperties());
    }

    return pKeyProps;
}
// -----------------------------------------------------------------------------
void OTableHelper::addKey(const ::rtl::OUString& _sName,const sdbcx::TKeyProperties& _aKeyProperties)
{
    m_pImpl->m_aKeys.insert(TKeyMap::value_type(_sName,_aKeyProperties));
}
// -----------------------------------------------------------------------------
::rtl::OUString OTableHelper::getTypeCreatePattern() const
{
    return ::rtl::OUString();
}
// -----------------------------------------------------------------------------
Reference< XConnection> OTableHelper::getConnection() const
{
    return m_pImpl->m_xConnection;
}
// -----------------------------------------------------------------------------
Reference< ::com::sun::star::sdb::tools::XTableRename>      OTableHelper::getRenameService() const
{
    return m_pImpl->m_xRename;
}
// -----------------------------------------------------------------------------
Reference< ::com::sun::star::sdb::tools::XTableAlteration>  OTableHelper::getAlterService() const
{
    return m_pImpl->m_xAlter;
}
// -----------------------------------------------------------------------------
Reference< ::com::sun::star::sdb::tools::XKeyAlteration>  OTableHelper::getKeyService() const
{
    return m_pImpl->m_xKeyAlter;
}
// -----------------------------------------------------------------------------
Reference< ::com::sun::star::sdb::tools::XIndexAlteration>  OTableHelper::getIndexService() const
{
    return m_pImpl->m_xIndexAlter;
}
// -----------------------------------------------------------------------------