| /************************************************************** |
| * |
| * 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_dbaccess.hxx" |
| |
| #include "connection.hxx" |
| #include "dbastrings.hrc" |
| #include "datasource.hxx" |
| #include "core_resource.hrc" |
| #include "core_resource.hxx" |
| #include "statement.hxx" |
| #include "preparedstatement.hxx" |
| #include "callablestatement.hxx" |
| #include "ContainerMediator.hxx" |
| #include "SingleSelectQueryComposer.hxx" |
| #include "querycomposer.hxx" |
| #include "sdbcoretools.hxx" |
| |
| /** === begin UNO includes === **/ |
| #include <com/sun/star/sdb/CommandType.hpp> |
| #include <com/sun/star/sdbc/XDriverAccess.hpp> |
| #include <com/sun/star/sdbcx/XDataDefinitionSupplier.hpp> |
| #include <com/sun/star/reflection/XProxyFactory.hpp> |
| #include <com/sun/star/beans/NamedValue.hpp> |
| /** === end UNO includes === **/ |
| #include <connectivity/dbtools.hxx> |
| #include <connectivity/dbmetadata.hxx> |
| #include <connectivity/dbexception.hxx> |
| #include <tools/debug.hxx> |
| #include <tools/diagnose_ex.h> |
| #include <comphelper/extract.hxx> |
| #include <comphelper/uno3.hxx> |
| #include <comphelper/sequence.hxx> |
| #include <cppuhelper/typeprovider.hxx> |
| #include <rtl/logfile.hxx> |
| |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::util; |
| using namespace ::com::sun::star::sdb; |
| using namespace ::com::sun::star::sdb::application; |
| using namespace ::com::sun::star::sdbc; |
| using namespace ::com::sun::star::sdbcx; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::reflection; |
| using namespace ::com::sun::star::container; |
| using namespace ::com::sun::star::graphic; |
| using namespace ::osl; |
| using namespace ::comphelper; |
| using namespace ::cppu; |
| using namespace ::dbtools; |
| |
| using ::com::sun::star::sdb::tools::XTableName; |
| using ::com::sun::star::sdb::tools::XObjectNames; |
| using ::com::sun::star::sdb::tools::XDataSourceMetaData; |
| |
| //........................................................................ |
| namespace dbaccess |
| { |
| //........................................................................ |
| |
| //========================================================================== |
| // XServiceInfo |
| //------------------------------------------------------------------------------ |
| rtl::OUString OConnection::getImplementationName( ) throw(RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getImplementationName" ); |
| return rtl::OUString::createFromAscii("com.sun.star.comp.dbaccess.Connection"); |
| } |
| //------------------------------------------------------------------------------ |
| sal_Bool OConnection::supportsService( const ::rtl::OUString& _rServiceName ) throw (RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::supportsService" ); |
| return findValue(getSupportedServiceNames(), _rServiceName, sal_True).getLength() != 0; |
| } |
| |
| //------------------------------------------------------------------------------ |
| Sequence< ::rtl::OUString > OConnection::getSupportedServiceNames( ) throw (RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getSupportedServiceNames" ); |
| Sequence< ::rtl::OUString > aSupported = OConnectionWrapper::getSupportedServiceNames(); |
| |
| if ( 0 == findValue( aSupported, SERVICE_SDB_CONNECTION, sal_True ).getLength() ) |
| { |
| sal_Int32 nLen = aSupported.getLength(); |
| aSupported.realloc( nLen + 1 ); |
| aSupported[ nLen ] = SERVICE_SDB_CONNECTION; |
| } |
| |
| return aSupported; |
| } |
| |
| // XCloseable |
| //------------------------------------------------------------------------------ |
| void OConnection::close(void) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::close" ); |
| // being closed is the same as being disposed |
| dispose(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Bool OConnection::isClosed(void) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::isClosed" ); |
| MutexGuard aGuard(m_aMutex); |
| return !m_xMasterConnection.is(); |
| } |
| |
| // XConnection |
| //------------------------------------------------------------------------------ |
| Reference< XStatement > OConnection::createStatement(void) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::createStatement" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| |
| Reference< XStatement > xStatement; |
| Reference< XStatement > xMasterStatement = m_xMasterConnection->createStatement(); |
| if ( xMasterStatement.is() ) |
| { |
| xStatement = new OStatement(this, xMasterStatement); |
| m_aStatements.push_back(WeakReferenceHelper(xStatement)); |
| } |
| return xStatement; |
| } |
| //------------------------------------------------------------------------------ |
| Reference< XPreparedStatement > OConnection::prepareStatement(const rtl::OUString& sql) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::prepareStatement" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| |
| // TODO convert the SQL to SQL the driver understands |
| Reference< XPreparedStatement > xStatement; |
| Reference< XPreparedStatement > xMasterStatement = m_xMasterConnection->prepareStatement(sql); |
| if ( xMasterStatement.is() ) |
| { |
| xStatement = new OPreparedStatement(this, xMasterStatement); |
| m_aStatements.push_back(WeakReferenceHelper(xStatement)); |
| } |
| return xStatement; |
| } |
| |
| //------------------------------------------------------------------------------ |
| Reference< XPreparedStatement > OConnection::prepareCall(const rtl::OUString& sql) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::prepareCall" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| |
| Reference< XPreparedStatement > xStatement; |
| Reference< XPreparedStatement > xMasterStatement = m_xMasterConnection->prepareCall(sql); |
| if ( xMasterStatement.is() ) |
| { |
| xStatement = new OCallableStatement(this, xMasterStatement); |
| m_aStatements.push_back(WeakReferenceHelper(xStatement)); |
| } |
| return xStatement; |
| } |
| |
| //------------------------------------------------------------------------------ |
| rtl::OUString OConnection::nativeSQL(const rtl::OUString& sql) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::nativeSQL" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| return m_xMasterConnection->nativeSQL(sql); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OConnection::setAutoCommit(sal_Bool autoCommit) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::setAutoCommit" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| m_xMasterConnection->setAutoCommit(autoCommit); |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Bool OConnection::getAutoCommit(void) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getAutoCommit" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| return m_xMasterConnection->getAutoCommit(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OConnection::commit(void) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::commit" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| m_xMasterConnection->commit(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OConnection::rollback(void) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::rollback" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| m_xMasterConnection->rollback(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| Reference< XDatabaseMetaData > OConnection::getMetaData(void) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getMetaData" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| return m_xMasterConnection->getMetaData(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OConnection::setReadOnly(sal_Bool readOnly) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::setReadOnly" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| m_xMasterConnection->setReadOnly(readOnly); |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Bool OConnection::isReadOnly(void) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::isReadOnly" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| return m_xMasterConnection->isReadOnly(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OConnection::setCatalog(const rtl::OUString& catalog) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::setCatalog" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| m_xMasterConnection->setCatalog(catalog); |
| } |
| |
| //------------------------------------------------------------------------------ |
| rtl::OUString OConnection::getCatalog(void) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getCatalog" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| return m_xMasterConnection->getCatalog(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OConnection::setTransactionIsolation(sal_Int32 level) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::setTransactionIsolation" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| m_xMasterConnection->setTransactionIsolation(level); |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Int32 OConnection::getTransactionIsolation(void) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getTransactionIsolation" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| return m_xMasterConnection->getTransactionIsolation(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| Reference< XNameAccess > OConnection::getTypeMap(void) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getTypeMap" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| return m_xMasterConnection->getTypeMap(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OConnection::setTypeMap(const Reference< XNameAccess > & typeMap) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::setTypeMap" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| m_xMasterConnection->setTypeMap(typeMap); |
| } |
| //========================================================================== |
| //= OConnection |
| //========================================================================== |
| DBG_NAME(OConnection) |
| //-------------------------------------------------------------------------- |
| OConnection::OConnection(ODatabaseSource& _rDB |
| , Reference< XConnection >& _rxMaster |
| , const Reference< XMultiServiceFactory >& _rxORB) |
| :OSubComponent(m_aMutex, static_cast< OWeakObject* >(&_rDB)) |
| // as the queries reroute their refcounting to us, this m_aMutex is okey. If the queries |
| // container would do it's own refcounting, it would have to aquire m_pMutex |
| // same for tables |
| ,m_aTableFilter(_rDB.m_pImpl->m_aTableFilter) |
| ,m_aTableTypeFilter(_rDB.m_pImpl->m_aTableTypeFilter) |
| ,m_aContext( _rxORB ) |
| ,m_xMasterConnection(_rxMaster) |
| ,m_pTables(NULL) |
| ,m_pViews(NULL) |
| ,m_aWarnings( Reference< XWarningsSupplier >( _rxMaster, UNO_QUERY ) ) |
| ,m_nInAppend(0) |
| ,m_bSupportsViews(sal_False) |
| ,m_bSupportsUsers(sal_False) |
| ,m_bSupportsGroups(sal_False) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::OConnection" ); |
| DBG_CTOR(OConnection,NULL); |
| osl_incrementInterlockedCount(&m_refCount); |
| |
| try |
| { |
| Reference< XProxyFactory > xProxyFactory( |
| _rxORB->createInstance(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.reflection.ProxyFactory"))),UNO_QUERY); |
| Reference<XAggregation> xAgg = xProxyFactory->createProxy(_rxMaster.get()); |
| setDelegation(xAgg,m_refCount); |
| DBG_ASSERT(m_xConnection.is(), "OConnection::OConnection : invalid master connection !"); |
| } |
| catch(const Exception&) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| |
| m_xTableUIProvider = m_xTableUIProvider.query( m_xMasterConnection ); |
| |
| try |
| { |
| m_xQueries = new OQueryContainer(Reference< XNameContainer >(_rDB.getQueryDefinitions( ),UNO_QUERY), this,_rxORB, &m_aWarnings); |
| |
| sal_Bool bCase = sal_True; |
| Reference<XDatabaseMetaData> xMeta; |
| try |
| { |
| xMeta = getMetaData(); |
| bCase = xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers(); |
| } |
| catch(SQLException&) |
| { |
| } |
| Reference< XNameContainer > xTableDefinitions(_rDB.getTables(),UNO_QUERY); |
| m_pTables = new OTableContainer( *this, m_aMutex, this, bCase, xTableDefinitions, this, &m_aWarnings,m_nInAppend ); |
| |
| // check if we supports types |
| if ( xMeta.is() ) |
| { |
| Reference<XResultSet> xRes = xMeta->getTableTypes(); |
| if(xRes.is()) |
| { |
| ::rtl::OUString sView(RTL_CONSTASCII_USTRINGPARAM("VIEW")); |
| Reference<XRow> xRow(xRes,UNO_QUERY); |
| while(xRes->next()) |
| { |
| ::rtl::OUString sValue = xRow->getString(1); |
| if( !xRow->wasNull() && sValue == sView) |
| { |
| m_bSupportsViews = sal_True; |
| break; |
| } |
| } |
| } |
| // some dbs don't support this type so we should ask if a XViewsSupplier is supported |
| if(!m_bSupportsViews) |
| { |
| Reference< XViewsSupplier > xMaster(getMasterTables(),UNO_QUERY); |
| |
| if (xMaster.is() && xMaster->getViews().is()) |
| m_bSupportsViews = sal_True; |
| } |
| if(m_bSupportsViews) |
| { |
| m_pViews = new OViewContainer(*this, m_aMutex, this, bCase,this,&m_aWarnings,m_nInAppend); |
| m_pViews->addContainerListener(m_pTables); |
| m_pTables->addContainerListener(m_pViews); |
| } |
| m_bSupportsUsers = Reference< XUsersSupplier> (getMasterTables(),UNO_QUERY).is(); |
| m_bSupportsGroups = Reference< XGroupsSupplier> (getMasterTables(),UNO_QUERY).is(); |
| |
| impl_checkTableQueryNames_nothrow(); |
| } |
| } |
| catch(const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| osl_decrementInterlockedCount( &m_refCount ); |
| } |
| |
| //-------------------------------------------------------------------------- |
| OConnection::~OConnection() |
| { |
| delete m_pTables; |
| delete m_pViews; |
| DBG_DTOR(OConnection,NULL); |
| } |
| |
| |
| // XWarningsSupplier |
| //-------------------------------------------------------------------------- |
| Any SAL_CALL OConnection::getWarnings() throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getWarnings" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| return m_aWarnings.getWarnings(); |
| } |
| |
| //-------------------------------------------------------------------------- |
| void SAL_CALL OConnection::clearWarnings( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::clearWarnings" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| m_aWarnings.clearWarnings(); |
| } |
| |
| //-------------------------------------------------------------------------- |
| namespace |
| { |
| struct CompareTypeByName : public ::std::binary_function< Type, Type, bool > |
| { |
| bool operator() ( const Type& _rLHS, const Type& _rRHS ) const |
| { |
| return _rLHS.getTypeName() < _rRHS.getTypeName(); |
| } |
| }; |
| typedef ::std::set< Type, CompareTypeByName > TypeBag; |
| |
| void lcl_copyTypes( TypeBag& _out_rTypes, const Sequence< Type >& _rTypes ) |
| { |
| ::std::copy( _rTypes.getConstArray(), _rTypes.getConstArray() + _rTypes.getLength(), |
| ::std::insert_iterator< TypeBag >( _out_rTypes, _out_rTypes.begin() ) ); |
| } |
| } |
| // com::sun::star::lang::XTypeProvider |
| //-------------------------------------------------------------------------- |
| Sequence< Type > OConnection::getTypes() throw (RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getTypes" ); |
| TypeBag aNormalizedTypes; |
| |
| lcl_copyTypes( aNormalizedTypes, OSubComponent::getTypes() ); |
| lcl_copyTypes( aNormalizedTypes, OConnection_Base::getTypes() ); |
| lcl_copyTypes( aNormalizedTypes, ::connectivity::OConnectionWrapper::getTypes() ); |
| |
| if ( !m_bSupportsViews ) |
| aNormalizedTypes.erase( XViewsSupplier::static_type() ); |
| if ( !m_bSupportsUsers ) |
| aNormalizedTypes.erase( XUsersSupplier::static_type() ); |
| if ( !m_bSupportsGroups ) |
| aNormalizedTypes.erase( XGroupsSupplier::static_type() ); |
| |
| Sequence< Type > aSupportedTypes( aNormalizedTypes.size() ); |
| ::std::copy( aNormalizedTypes.begin(), aNormalizedTypes.end(), aSupportedTypes.getArray() ); |
| return aSupportedTypes; |
| } |
| |
| //-------------------------------------------------------------------------- |
| Sequence< sal_Int8 > OConnection::getImplementationId() throw (RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getImplementationId" ); |
| return getUnoTunnelImplementationId(); |
| } |
| |
| // com::sun::star::uno::XInterface |
| //-------------------------------------------------------------------------- |
| Any OConnection::queryInterface( const Type & rType ) throw (RuntimeException) |
| { |
| if ( !m_bSupportsViews && rType.equals( XViewsSupplier::static_type() ) ) |
| return Any(); |
| else if ( !m_bSupportsUsers && rType.equals( XUsersSupplier::static_type() ) ) |
| return Any(); |
| else if ( !m_bSupportsGroups && rType.equals( XGroupsSupplier::static_type() ) ) |
| return Any(); |
| Any aReturn = OSubComponent::queryInterface( rType ); |
| if (!aReturn.hasValue()) |
| { |
| aReturn = OConnection_Base::queryInterface( rType ); |
| if (!aReturn.hasValue()) |
| aReturn = OConnectionWrapper::queryInterface( rType ); |
| } |
| return aReturn; |
| } |
| |
| //-------------------------------------------------------------------------- |
| void OConnection::acquire() throw () |
| { |
| // include this one when you want to see who calls it (call graph) |
| //RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::acquire" ); |
| OSubComponent::acquire(); |
| } |
| |
| //-------------------------------------------------------------------------- |
| void OConnection::release() throw () |
| { |
| // include this one when you want to see who calls it (call graph) |
| //RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::release" ); |
| OSubComponent::release(); |
| } |
| |
| // OSubComponent |
| //------------------------------------------------------------------------------ |
| void OConnection::disposing() |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::disposing" ); |
| MutexGuard aGuard(m_aMutex); |
| |
| OSubComponent::disposing(); |
| OConnectionWrapper::disposing(); |
| |
| OWeakRefArrayIterator aEnd = m_aStatements.end(); |
| for (OWeakRefArrayIterator i = m_aStatements.begin(); aEnd != i; ++i) |
| { |
| Reference<XComponent> xComp(i->get(),UNO_QUERY); |
| ::comphelper::disposeComponent(xComp); |
| } |
| m_aStatements.clear(); |
| m_xMasterTables = NULL; |
| |
| if(m_pTables) |
| m_pTables->dispose(); |
| if(m_pViews) |
| m_pViews->dispose(); |
| |
| ::comphelper::disposeComponent(m_xQueries); |
| |
| OWeakRefArrayIterator aComposerEnd = m_aComposers.end(); |
| for (OWeakRefArrayIterator j = m_aComposers.begin(); aComposerEnd != j; ++j) |
| { |
| Reference<XComponent> xComp(j->get(),UNO_QUERY); |
| ::comphelper::disposeComponent(xComp); |
| } |
| |
| m_aComposers.clear(); |
| |
| try |
| { |
| if (m_xMasterConnection.is()) |
| m_xMasterConnection->close(); |
| } |
| catch(Exception) |
| { |
| } |
| m_xMasterConnection = NULL; |
| } |
| |
| // XChild |
| //------------------------------------------------------------------------------ |
| Reference< XInterface > OConnection::getParent(void) throw( RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getParent" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| return m_xParent; |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OConnection::setParent(const Reference< XInterface > & /*Parent*/) throw( NoSupportException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::setParent" ); |
| throw NoSupportException(); |
| } |
| |
| // XSQLQueryComposerFactory |
| //------------------------------------------------------------------------------ |
| Reference< XSQLQueryComposer > OConnection::createQueryComposer(void) throw( RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::createQueryComposer" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| |
| // Reference< XNumberFormatsSupplier > xSupplier = pParent->getNumberFormatsSupplier(); |
| Reference< XSQLQueryComposer > xComposer( new OQueryComposer( this ) ); |
| m_aComposers.push_back(WeakReferenceHelper(xComposer)); |
| return xComposer; |
| } |
| // ----------------------------------------------------------------------------- |
| void OConnection::impl_fillTableFilter() |
| { |
| Reference<XPropertySet> xProp(getParent(),UNO_QUERY); |
| if ( xProp.is() ) |
| { |
| xProp->getPropertyValue(PROPERTY_TABLEFILTER) >>= m_aTableFilter; |
| xProp->getPropertyValue(PROPERTY_TABLETYPEFILTER) >>= m_aTableTypeFilter; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void OConnection::refresh(const Reference< XNameAccess >& _rToBeRefreshed) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::refresh" ); |
| if ( _rToBeRefreshed == Reference< XNameAccess >(m_pTables) ) |
| { |
| if (m_pTables && !m_pTables->isInitialized()) |
| { |
| impl_fillTableFilter(); |
| // check if our "master connection" can supply tables |
| getMasterTables(); |
| |
| if (m_xMasterTables.is() && m_xMasterTables->getTables().is()) |
| { // yes -> wrap them |
| m_pTables->construct(m_xMasterTables->getTables(),m_aTableFilter, m_aTableTypeFilter); |
| } |
| else |
| { // no -> use an own container |
| m_pTables->construct(m_aTableFilter, m_aTableTypeFilter); |
| } |
| } |
| } |
| else if ( _rToBeRefreshed == Reference< XNameAccess >(m_pViews) ) |
| { |
| if (m_pViews && !m_pViews->isInitialized()) |
| { |
| impl_fillTableFilter(); |
| // check if our "master connection" can supply tables |
| Reference< XViewsSupplier > xMaster(getMasterTables(),UNO_QUERY); |
| |
| if (xMaster.is() && xMaster->getViews().is()) |
| m_pViews->construct(xMaster->getViews(),m_aTableFilter, m_aTableTypeFilter); |
| else |
| m_pViews->construct(m_aTableFilter, m_aTableTypeFilter); |
| } |
| } |
| } |
| // ----------------------------------------------------------------------------- |
| |
| // XTablesSupplier |
| //------------------------------------------------------------------------------ |
| Reference< XNameAccess > OConnection::getTables() throw( RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getTables" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| |
| refresh(m_pTables); |
| |
| return m_pTables; |
| } |
| // ----------------------------------------------------------------------------- |
| Reference< XNameAccess > SAL_CALL OConnection::getViews( ) throw(RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getViews" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| |
| refresh(m_pViews); |
| |
| return m_pViews; |
| } |
| // XQueriesSupplier |
| //------------------------------------------------------------------------------ |
| Reference< XNameAccess > OConnection::getQueries(void) throw( RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getQueries" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| |
| return m_xQueries; |
| } |
| |
| // ::com::sun::star::sdb::XCommandPreparation |
| //------------------------------------------------------------------------------ |
| Reference< XPreparedStatement > SAL_CALL OConnection::prepareCommand( const ::rtl::OUString& command, sal_Int32 commandType ) throw(::com::sun::star::sdbc::SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::prepareCommand" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| |
| rtl::OUString aStatement; |
| switch (commandType) |
| { |
| case CommandType::TABLE: |
| { |
| aStatement = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SELECT * FROM ")); |
| |
| ::rtl::OUString sCatalog, sSchema, sTable; |
| ::dbtools::qualifiedNameComponents( getMetaData(), command, sCatalog, sSchema, sTable, ::dbtools::eInDataManipulation ); |
| aStatement += ::dbtools::composeTableNameForSelect( this, sCatalog, sSchema, sTable ); |
| } |
| break; |
| case CommandType::QUERY: |
| if ( m_xQueries->hasByName(command) ) |
| { |
| Reference< XPropertySet > xQuery(m_xQueries->getByName(command),UNO_QUERY); |
| xQuery->getPropertyValue(PROPERTY_COMMAND) >>= aStatement; |
| } |
| break; |
| default: |
| aStatement = command; |
| } |
| // TODO EscapeProcessing |
| return prepareStatement(aStatement); |
| } |
| // ----------------------------------------------------------------------------- |
| Reference< XInterface > SAL_CALL OConnection::createInstance( const ::rtl::OUString& _sServiceSpecifier ) throw (Exception, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::createInstance" ); |
| Reference< XServiceInfo > xRet; |
| if ( ( SERVICE_NAME_SINGLESELECTQUERYCOMPOSER == _sServiceSpecifier ) |
| || ( _sServiceSpecifier.equalsAscii( "com.sun.star.sdb.SingleSelectQueryAnalyzer" ) ) |
| ) |
| { |
| xRet = new OSingleSelectQueryComposer( getTables(),this, m_aContext ); |
| m_aComposers.push_back(WeakReferenceHelper(xRet)); |
| } |
| else |
| { |
| if ( _sServiceSpecifier.getLength() ) |
| { |
| TSupportServices::iterator aFind = m_aSupportServices.find(_sServiceSpecifier); |
| if ( aFind == m_aSupportServices.end() ) |
| { |
| Sequence<Any> aArgs(1); |
| Reference<XConnection> xMy(this); |
| aArgs[0] <<= NamedValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ActiveConnection")),makeAny(xMy)); |
| aFind = m_aSupportServices.insert(TSupportServices::value_type(_sServiceSpecifier,m_aContext.createComponentWithArguments(_sServiceSpecifier,aArgs))).first; |
| } |
| return aFind->second; |
| } |
| } |
| return Reference< XInterface >(xRet,UNO_QUERY); |
| } |
| // ----------------------------------------------------------------------------- |
| Reference< XInterface > SAL_CALL OConnection::createInstanceWithArguments( const ::rtl::OUString& _sServiceSpecifier, const Sequence< Any >& /*Arguments*/ ) throw (Exception, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::createInstanceWithArguments" ); |
| return createInstance(_sServiceSpecifier); |
| } |
| // ----------------------------------------------------------------------------- |
| Sequence< ::rtl::OUString > SAL_CALL OConnection::getAvailableServiceNames( ) throw (RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getAvailableServiceNames" ); |
| Sequence< ::rtl::OUString > aRet(1); |
| aRet[0] = SERVICE_NAME_SINGLESELECTQUERYCOMPOSER; |
| return aRet; |
| } |
| // ----------------------------------------------------------------------------- |
| Reference< XTablesSupplier > OConnection::getMasterTables() |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getMasterTables" ); |
| // check if out "master connection" can supply tables |
| if(!m_xMasterTables.is()) |
| { |
| try |
| { |
| Reference<XDatabaseMetaData> xMeta = getMetaData(); |
| if ( xMeta.is() ) |
| m_xMasterTables = ::dbtools::getDataDefinitionByURLAndConnection( xMeta->getURL(), m_xMasterConnection, m_aContext.getLegacyServiceFactory() ); |
| } |
| catch(SQLException&) |
| { |
| } |
| } |
| return m_xMasterTables; |
| } |
| // ----------------------------------------------------------------------------- |
| // XUsersSupplier |
| Reference< XNameAccess > SAL_CALL OConnection::getUsers( ) throw(RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getUsers" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| |
| Reference<XUsersSupplier> xUsr(getMasterTables(),UNO_QUERY); |
| return xUsr.is() ? xUsr->getUsers() : Reference< XNameAccess >(); |
| } |
| // ----------------------------------------------------------------------------- |
| // XGroupsSupplier |
| Reference< XNameAccess > SAL_CALL OConnection::getGroups( ) throw(RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getGroups" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| Reference<XGroupsSupplier> xGrp(getMasterTables(),UNO_QUERY); |
| return xGrp.is() ? xGrp->getGroups() : Reference< XNameAccess >(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void OConnection::impl_loadConnectionTools_throw() |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::impl_loadConnectionTools_throw" ); |
| Sequence< Any > aArguments( 1 ); |
| aArguments[0] <<= NamedValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Connection" ) ), makeAny( Reference< XConnection >( this ) ) ); |
| |
| if ( !m_aContext.createComponentWithArguments( "com.sun.star.sdb.tools.ConnectionTools", aArguments, m_xConnectionTools ) ) |
| throw RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "service not registered: com.sun.star.sdb.tools.ConnectionTools" ) ), *this ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| Reference< XTableName > SAL_CALL OConnection::createTableName( ) throw (RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::createTableName" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| impl_loadConnectionTools_throw(); |
| |
| return m_xConnectionTools->createTableName(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| Reference< XObjectNames > SAL_CALL OConnection::getObjectNames( ) throw (RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getObjectNames" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| impl_loadConnectionTools_throw(); |
| |
| return m_xConnectionTools->getObjectNames(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| Reference< XDataSourceMetaData > SAL_CALL OConnection::getDataSourceMetaData( ) throw (RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getDataSourceMetaData" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| impl_loadConnectionTools_throw(); |
| |
| return m_xConnectionTools->getDataSourceMetaData(); |
| } |
| // ----------------------------------------------------------------------------- |
| Reference< ::com::sun::star::container::XNameAccess > SAL_CALL OConnection::getFieldsByCommandDescriptor( ::sal_Int32 commandType, const ::rtl::OUString& command, ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent >& keepFieldsAlive ) throw (::com::sun::star::sdbc::SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getFieldsByCommandDescriptor" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| impl_loadConnectionTools_throw(); |
| |
| return m_xConnectionTools->getFieldsByCommandDescriptor(commandType,command,keepFieldsAlive); |
| } |
| //-------------------------------------------------------------------- |
| Reference< XSingleSelectQueryComposer > SAL_CALL OConnection::getComposer( ::sal_Int32 commandType, const ::rtl::OUString& command ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getComposer" ); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(); |
| impl_loadConnectionTools_throw(); |
| |
| return m_xConnectionTools->getComposer(commandType,command); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void OConnection::impl_checkTableQueryNames_nothrow() |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::impl_checkTableQueryNames_nothrow" ); |
| DatabaseMetaData aMeta( static_cast< XConnection* >( this ) ); |
| if ( !aMeta.supportsSubqueriesInFrom() ) |
| // nothing to do |
| return; |
| |
| try |
| { |
| Reference< XNameAccess > xTables( getTables() ); |
| Sequence< ::rtl::OUString > aTableNames( xTables->getElementNames() ); |
| ::std::set< ::rtl::OUString > aSortedTableNames( aTableNames.getConstArray(), aTableNames.getConstArray() + aTableNames.getLength() ); |
| |
| Reference< XNameAccess > xQueries( getQueries() ); |
| Sequence< ::rtl::OUString > aQueryNames( xQueries->getElementNames() ); |
| |
| for ( const ::rtl::OUString* pQueryName = aQueryNames.getConstArray(); |
| pQueryName != aQueryNames.getConstArray() + aQueryNames.getLength(); |
| ++pQueryName |
| ) |
| { |
| if ( aSortedTableNames.find( *pQueryName ) != aSortedTableNames.end() ) |
| { |
| ::rtl::OUString sConflictWarning( DBACORE_RESSTRING( RID_STR_CONFLICTING_NAMES ) ); |
| m_aWarnings.appendWarning( sConflictWarning, "01SB0", *this ); |
| } |
| } |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| Reference< XGraphic > SAL_CALL OConnection::getTableIcon( const ::rtl::OUString& _TableName, ::sal_Int32 _ColorMode ) throw (RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getTableIcon" ); |
| Reference< XGraphic > xReturn; |
| |
| // ask our aggregate |
| if ( m_xTableUIProvider.is() ) |
| xReturn = m_xTableUIProvider->getTableIcon( _TableName, _ColorMode ); |
| |
| // ask ourself |
| // well, we don't have own functionality here ... |
| // In the future, we might decide to delegate the complete handling to this interface. |
| // In this case, we would need to load the icon here. |
| |
| return xReturn; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| Reference< XInterface > SAL_CALL OConnection::getTableEditor( const Reference< XDatabaseDocumentUI >& _DocumentUI, const ::rtl::OUString& _TableName ) throw (IllegalArgumentException, WrappedTargetException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dataaccess", "Ocke.Janssen@sun.com", "OConnection::getTableEditor" ); |
| Reference< XInterface > xReturn; |
| |
| // ask our aggregate |
| if ( m_xTableUIProvider.is() ) |
| xReturn = m_xTableUIProvider->getTableEditor( _DocumentUI, _TableName ); |
| |
| // ask ourself |
| // well, we don't have own functionality here ... |
| // In the future, we might decide to delegate the complete handling to this interface. |
| // In this case, we would need to instantiate an css.sdb.TableDesign here. |
| |
| return xReturn; |
| } |
| |
| |
| //........................................................................ |
| } // namespace dbaccess |
| //........................................................................ |
| |
