LCOV - code coverage report
Current view: top level - dbaccess/source/core/dataaccess - connection.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 204 391 52.2 %
Date: 2014-11-03 Functions: 26 59 44.1 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <sal/config.h>
      21             : 
      22             : #include <iterator>
      23             : 
      24             : #include "connection.hxx"
      25             : #include "dbastrings.hrc"
      26             : #include "datasource.hxx"
      27             : #include "core_resource.hrc"
      28             : #include "core_resource.hxx"
      29             : #include "statement.hxx"
      30             : #include "preparedstatement.hxx"
      31             : #include "callablestatement.hxx"
      32             : #include "ContainerMediator.hxx"
      33             : #include "SingleSelectQueryComposer.hxx"
      34             : #include "querycomposer.hxx"
      35             : #include "sdbcoretools.hxx"
      36             : 
      37             : #include <com/sun/star/sdb/CommandType.hpp>
      38             : #include <com/sun/star/sdb/tools/ConnectionTools.hpp>
      39             : #include <com/sun/star/sdbc/XDriverAccess.hpp>
      40             : #include <com/sun/star/sdbcx/XDataDefinitionSupplier.hpp>
      41             : #include <com/sun/star/reflection/ProxyFactory.hpp>
      42             : #include <com/sun/star/beans/NamedValue.hpp>
      43             : #include <connectivity/dbtools.hxx>
      44             : #include <connectivity/dbmetadata.hxx>
      45             : #include <connectivity/dbexception.hxx>
      46             : #include <tools/debug.hxx>
      47             : #include <tools/diagnose_ex.h>
      48             : #include <osl/diagnose.h>
      49             : #include <comphelper/extract.hxx>
      50             : #include <comphelper/uno3.hxx>
      51             : #include <comphelper/sequence.hxx>
      52             : #include <cppuhelper/supportsservice.hxx>
      53             : #include <cppuhelper/typeprovider.hxx>
      54             : 
      55             : using namespace ::com::sun::star::uno;
      56             : using namespace ::com::sun::star::lang;
      57             : using namespace ::com::sun::star::util;
      58             : using namespace ::com::sun::star::sdb;
      59             : using namespace ::com::sun::star::sdb::application;
      60             : using namespace ::com::sun::star::sdbc;
      61             : using namespace ::com::sun::star::sdbcx;
      62             : using namespace ::com::sun::star::beans;
      63             : using namespace ::com::sun::star::reflection;
      64             : using namespace ::com::sun::star::container;
      65             : using namespace ::com::sun::star::graphic;
      66             : using namespace ::osl;
      67             : using namespace ::comphelper;
      68             : using namespace ::cppu;
      69             : using namespace ::dbtools;
      70             : 
      71             : using ::com::sun::star::sdb::tools::XTableName;
      72             : using ::com::sun::star::sdb::tools::XObjectNames;
      73             : using ::com::sun::star::sdb::tools::XDataSourceMetaData;
      74             : 
      75             : namespace dbaccess
      76             : {
      77             : 
      78             : // XServiceInfo
      79           0 : OUString OConnection::getImplementationName(  ) throw(RuntimeException, std::exception)
      80             : {
      81           0 :     return OUString("com.sun.star.comp.dbaccess.Connection");
      82             : }
      83             : 
      84           0 : sal_Bool OConnection::supportsService( const OUString& _rServiceName ) throw (RuntimeException, std::exception)
      85             : {
      86           0 :     return cppu::supportsService(this, _rServiceName);
      87             : }
      88             : 
      89           0 : Sequence< OUString > OConnection::getSupportedServiceNames(  ) throw (RuntimeException, std::exception)
      90             : {
      91           0 :     Sequence< OUString > aSupported = OConnectionWrapper::getSupportedServiceNames();
      92             : 
      93           0 :     if ( 0 == findValue( aSupported, SERVICE_SDB_CONNECTION, true ).getLength() )
      94             :     {
      95           0 :         sal_Int32 nLen = aSupported.getLength();
      96           0 :         aSupported.realloc( nLen + 1 );
      97           0 :         aSupported[ nLen ] = SERVICE_SDB_CONNECTION;
      98             :     }
      99             : 
     100           0 :     return aSupported;
     101             : }
     102             : 
     103             : // XCloseable
     104           4 : void OConnection::close(void) throw( SQLException, RuntimeException, std::exception )
     105             : {
     106             :     // being closed is the same as being disposed
     107           4 :     dispose();
     108           4 : }
     109             : 
     110           0 : sal_Bool OConnection::isClosed(void) throw( SQLException, RuntimeException, std::exception )
     111             : {
     112           0 :     MutexGuard aGuard(m_aMutex);
     113           0 :     return !m_xMasterConnection.is();
     114             : }
     115             : 
     116             : // XConnection
     117          26 : Reference< XStatement >  OConnection::createStatement(void) throw( SQLException, RuntimeException, std::exception )
     118             : {
     119          26 :     MutexGuard aGuard(m_aMutex);
     120          26 :     checkDisposed();
     121             : 
     122          26 :     Reference< XStatement > xStatement;
     123          52 :     Reference< XStatement > xMasterStatement = m_xMasterConnection->createStatement();
     124          26 :     if ( xMasterStatement.is() )
     125             :     {
     126          26 :         xStatement = new OStatement(this, xMasterStatement);
     127          26 :         m_aStatements.push_back(WeakReferenceHelper(xStatement));
     128             :     }
     129          52 :     return xStatement;
     130             : }
     131             : 
     132         110 : Reference< XPreparedStatement >  OConnection::prepareStatement(const OUString& sql) throw( SQLException, RuntimeException, std::exception )
     133             : {
     134         110 :     MutexGuard aGuard(m_aMutex);
     135         110 :     checkDisposed();
     136             : 
     137             :     // TODO convert the SQL to SQL the driver understands
     138         110 :     Reference< XPreparedStatement > xStatement;
     139         198 :     Reference< XPreparedStatement > xMasterStatement = m_xMasterConnection->prepareStatement(sql);
     140          88 :     if ( xMasterStatement.is() )
     141             :     {
     142          88 :         xStatement = new OPreparedStatement(this, xMasterStatement);
     143          88 :         m_aStatements.push_back(WeakReferenceHelper(xStatement));
     144             :     }
     145         198 :     return xStatement;
     146             : }
     147             : 
     148           0 : Reference< XPreparedStatement >  OConnection::prepareCall(const OUString& sql) throw( SQLException, RuntimeException, std::exception )
     149             : {
     150           0 :     MutexGuard aGuard(m_aMutex);
     151           0 :     checkDisposed();
     152             : 
     153           0 :     Reference< XPreparedStatement > xStatement;
     154           0 :     Reference< XPreparedStatement > xMasterStatement = m_xMasterConnection->prepareCall(sql);
     155           0 :     if ( xMasterStatement.is() )
     156             :     {
     157           0 :         xStatement = new OCallableStatement(this, xMasterStatement);
     158           0 :         m_aStatements.push_back(WeakReferenceHelper(xStatement));
     159             :     }
     160           0 :     return xStatement;
     161             : }
     162             : 
     163           0 : OUString OConnection::nativeSQL(const OUString& sql) throw( SQLException, RuntimeException, std::exception )
     164             : {
     165           0 :     MutexGuard aGuard(m_aMutex);
     166           0 :     checkDisposed();
     167           0 :     return m_xMasterConnection->nativeSQL(sql);
     168             : }
     169             : 
     170           0 : void OConnection::setAutoCommit(sal_Bool autoCommit) throw( SQLException, RuntimeException, std::exception )
     171             : {
     172           0 :     MutexGuard aGuard(m_aMutex);
     173           0 :     checkDisposed();
     174           0 :     m_xMasterConnection->setAutoCommit(autoCommit);
     175           0 : }
     176             : 
     177           0 : sal_Bool OConnection::getAutoCommit(void) throw( SQLException, RuntimeException, std::exception )
     178             : {
     179           0 :     MutexGuard aGuard(m_aMutex);
     180           0 :     checkDisposed();
     181           0 :     return m_xMasterConnection->getAutoCommit();
     182             : }
     183             : 
     184           0 : void OConnection::commit(void) throw( SQLException, RuntimeException, std::exception )
     185             : {
     186           0 :     MutexGuard aGuard(m_aMutex);
     187           0 :     checkDisposed();
     188           0 :     m_xMasterConnection->commit();
     189           0 : }
     190             : 
     191           0 : void OConnection::rollback(void) throw( SQLException, RuntimeException, std::exception )
     192             : {
     193           0 :     MutexGuard aGuard(m_aMutex);
     194           0 :     checkDisposed();
     195           0 :     m_xMasterConnection->rollback();
     196           0 : }
     197             : 
     198        4865 : Reference< XDatabaseMetaData >  OConnection::getMetaData(void) throw( SQLException, RuntimeException, std::exception )
     199             : {
     200        4865 :     MutexGuard aGuard(m_aMutex);
     201        4865 :     checkDisposed();
     202        4865 :     return m_xMasterConnection->getMetaData();
     203             : }
     204             : 
     205           0 : void OConnection::setReadOnly(sal_Bool readOnly) throw( SQLException, RuntimeException, std::exception )
     206             : {
     207           0 :     MutexGuard aGuard(m_aMutex);
     208           0 :     checkDisposed();
     209           0 :     m_xMasterConnection->setReadOnly(readOnly);
     210           0 : }
     211             : 
     212           0 : sal_Bool OConnection::isReadOnly(void) throw( SQLException, RuntimeException, std::exception )
     213             : {
     214           0 :     MutexGuard aGuard(m_aMutex);
     215           0 :     checkDisposed();
     216           0 :     return m_xMasterConnection->isReadOnly();
     217             : }
     218             : 
     219           0 : void OConnection::setCatalog(const OUString& catalog) throw( SQLException, RuntimeException, std::exception )
     220             : {
     221           0 :     MutexGuard aGuard(m_aMutex);
     222           0 :     checkDisposed();
     223           0 :     m_xMasterConnection->setCatalog(catalog);
     224           0 : }
     225             : 
     226           0 : OUString OConnection::getCatalog(void) throw( SQLException, RuntimeException, std::exception )
     227             : {
     228           0 :     MutexGuard aGuard(m_aMutex);
     229           0 :     checkDisposed();
     230           0 :     return m_xMasterConnection->getCatalog();
     231             : }
     232             : 
     233           0 : void OConnection::setTransactionIsolation(sal_Int32 level) throw( SQLException, RuntimeException, std::exception )
     234             : {
     235           0 :     MutexGuard aGuard(m_aMutex);
     236           0 :     checkDisposed();
     237           0 :     m_xMasterConnection->setTransactionIsolation(level);
     238           0 : }
     239             : 
     240           0 : sal_Int32 OConnection::getTransactionIsolation(void) throw( SQLException, RuntimeException, std::exception )
     241             : {
     242           0 :     MutexGuard aGuard(m_aMutex);
     243           0 :     checkDisposed();
     244           0 :     return m_xMasterConnection->getTransactionIsolation();
     245             : }
     246             : 
     247           0 : Reference< XNameAccess >  OConnection::getTypeMap(void) throw( SQLException, RuntimeException, std::exception )
     248             : {
     249           0 :     MutexGuard aGuard(m_aMutex);
     250           0 :     checkDisposed();
     251           0 :     return m_xMasterConnection->getTypeMap();
     252             : }
     253             : 
     254           0 : void OConnection::setTypeMap(const Reference< XNameAccess > & typeMap) throw( SQLException, RuntimeException, std::exception )
     255             : {
     256           0 :     MutexGuard aGuard(m_aMutex);
     257           0 :     checkDisposed();
     258           0 :     m_xMasterConnection->setTypeMap(typeMap);
     259           0 : }
     260             : 
     261             : // OConnection
     262             : 
     263          70 : OConnection::OConnection(ODatabaseSource& _rDB
     264             :                          , Reference< XConnection >& _rxMaster
     265             :                          , const Reference< XComponentContext >& _rxORB)
     266             :             :OSubComponent(m_aMutex, static_cast< OWeakObject* >(&_rDB))
     267             :                 // as the queries reroute their refcounting to us, this m_aMutex is okey. If the queries
     268             :                 // container would do it's own refcounting, it would have to acquire m_pMutex
     269             :                 // same for tables
     270          70 :             ,m_aTableFilter(_rDB.m_pImpl->m_aTableFilter)
     271          70 :             ,m_aTableTypeFilter(_rDB.m_pImpl->m_aTableTypeFilter)
     272             :             ,m_aContext( _rxORB )
     273             :             ,m_xMasterConnection(_rxMaster)
     274             :             ,m_pTables(NULL)
     275             :             ,m_pViews(NULL)
     276             :             ,m_aWarnings( Reference< XWarningsSupplier >( _rxMaster, UNO_QUERY ) )
     277             :             ,m_nInAppend(0)
     278             :             ,m_bSupportsViews(false)
     279             :             ,m_bSupportsUsers(false)
     280         210 :             ,m_bSupportsGroups(false)
     281             : {
     282          70 :     osl_atomic_increment(&m_refCount);
     283             : 
     284             :     try
     285             :     {
     286          70 :         Reference< XProxyFactory > xProxyFactory = ProxyFactory::create( m_aContext );
     287         140 :         Reference<XAggregation> xAgg = xProxyFactory->createProxy(_rxMaster.get());
     288          70 :         setDelegation(xAgg,m_refCount);
     289          70 :         OSL_ENSURE(m_xConnection.is(), "OConnection::OConnection : invalid master connection !");
     290             :     }
     291           0 :     catch(const Exception&)
     292             :     {
     293             :         DBG_UNHANDLED_EXCEPTION();
     294             :     }
     295             : 
     296          70 :     m_xTableUIProvider.set(m_xMasterConnection, css::uno::UNO_QUERY);
     297             : 
     298             :     try
     299             :     {
     300          70 :         m_xQueries = OQueryContainer::create(Reference< XNameContainer >(_rDB.getQueryDefinitions(), UNO_QUERY), this, _rxORB, &m_aWarnings).get();
     301             : 
     302          70 :         bool bCase = true;
     303          70 :         Reference<XDatabaseMetaData> xMeta;
     304             :         try
     305             :         {
     306          70 :             xMeta = getMetaData();
     307          70 :             bCase = xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers();
     308             :         }
     309           0 :         catch(const SQLException&)
     310             :         {
     311             :         }
     312         140 :         Reference< XNameContainer > xTableDefinitions(_rDB.getTables(),UNO_QUERY);
     313          70 :         m_pTables = new OTableContainer( *this, m_aMutex, this, bCase, xTableDefinitions, this, &m_aWarnings,m_nInAppend );
     314             : 
     315             :         // check if we supports types
     316          70 :         if ( xMeta.is() )
     317             :         {
     318          70 :             Reference<XResultSet> xRes = xMeta->getTableTypes();
     319          70 :             if(xRes.is())
     320             :             {
     321          70 :                 OUString sView("VIEW");
     322         140 :                 Reference<XRow> xRow(xRes,UNO_QUERY);
     323         214 :                 while(xRes->next())
     324             :                 {
     325          78 :                     OUString sValue = xRow->getString(1);
     326          78 :                     if( !xRow->wasNull() && sValue == sView)
     327             :                     {
     328           4 :                         m_bSupportsViews = true;
     329           4 :                         break;
     330             :                     }
     331         144 :                 }
     332             :             }
     333             :             // some dbs don't support this type so we should ask if a XViewsSupplier is supported
     334          70 :             if(!m_bSupportsViews)
     335             :             {
     336          66 :                 Reference< XViewsSupplier > xMaster(getMasterTables(),UNO_QUERY);
     337             : 
     338          66 :                 if (xMaster.is() && xMaster->getViews().is())
     339           0 :                     m_bSupportsViews = true;
     340             :             }
     341          70 :             if(m_bSupportsViews)
     342             :             {
     343           4 :                 m_pViews = new OViewContainer(*this, m_aMutex, this, bCase,this,&m_aWarnings,m_nInAppend);
     344           4 :                 m_pViews->addContainerListener(m_pTables);
     345           4 :                 m_pTables->addContainerListener(m_pViews);
     346             :             }
     347          70 :             m_bSupportsUsers = Reference< XUsersSupplier> (getMasterTables(),UNO_QUERY).is();
     348          70 :             m_bSupportsGroups = Reference< XGroupsSupplier> (getMasterTables(),UNO_QUERY).is();
     349             : 
     350          70 :             impl_checkTableQueryNames_nothrow();
     351          70 :         }
     352             :     }
     353           0 :     catch(const Exception& )
     354             :     {
     355             :         DBG_UNHANDLED_EXCEPTION();
     356             :     }
     357          70 :     osl_atomic_decrement( &m_refCount );
     358          70 : }
     359             : 
     360         204 : OConnection::~OConnection()
     361             : {
     362          68 :     delete m_pTables;
     363          68 :     delete m_pViews;
     364         136 : }
     365             : 
     366             : // XWarningsSupplier
     367           4 : Any SAL_CALL OConnection::getWarnings() throw(SQLException, RuntimeException, std::exception)
     368             : {
     369           4 :     MutexGuard aGuard(m_aMutex);
     370           4 :     checkDisposed();
     371           4 :     return m_aWarnings.getWarnings();
     372             : }
     373             : 
     374           4 : void SAL_CALL OConnection::clearWarnings(  ) throw(SQLException, RuntimeException, std::exception)
     375             : {
     376           4 :     MutexGuard aGuard(m_aMutex);
     377           4 :     checkDisposed();
     378           4 :     m_aWarnings.clearWarnings();
     379           4 : }
     380             : 
     381             : namespace
     382             : {
     383             :     struct CompareTypeByName : public ::std::binary_function< Type, Type, bool >
     384             :     {
     385        1640 :         bool operator() ( const Type& _rLHS, const Type& _rRHS ) const
     386             :         {
     387        1640 :             return _rLHS.getTypeName() < _rRHS.getTypeName();
     388             :         }
     389             :     };
     390             :     typedef ::std::set< Type, CompareTypeByName > TypeBag;
     391             : 
     392          24 :     void lcl_copyTypes( TypeBag& _out_rTypes, const Sequence< Type >& _rTypes )
     393             :     {
     394          24 :         ::std::copy( _rTypes.getConstArray(), _rTypes.getConstArray() + _rTypes.getLength(),
     395          48 :             ::std::insert_iterator< TypeBag >( _out_rTypes, _out_rTypes.begin() ) );
     396          24 :     }
     397             : }
     398             : 
     399             : // com::sun::star::lang::XTypeProvider
     400           8 : Sequence< Type > OConnection::getTypes() throw (RuntimeException, std::exception)
     401             : {
     402           8 :     TypeBag aNormalizedTypes;
     403             : 
     404           8 :     lcl_copyTypes( aNormalizedTypes, OSubComponent::getTypes() );
     405           8 :     lcl_copyTypes( aNormalizedTypes, OConnection_Base::getTypes() );
     406           8 :     lcl_copyTypes( aNormalizedTypes, ::connectivity::OConnectionWrapper::getTypes() );
     407             : 
     408           8 :     if ( !m_bSupportsViews )
     409           4 :         aNormalizedTypes.erase( cppu::UnoType<XViewsSupplier>::get() );
     410           8 :     if ( !m_bSupportsUsers )
     411           4 :         aNormalizedTypes.erase( cppu::UnoType<XUsersSupplier>::get() );
     412           8 :     if ( !m_bSupportsGroups )
     413           8 :         aNormalizedTypes.erase( cppu::UnoType<XGroupsSupplier>::get() );
     414             : 
     415           8 :     Sequence< Type > aSupportedTypes( aNormalizedTypes.size() );
     416           8 :     ::std::copy( aNormalizedTypes.begin(), aNormalizedTypes.end(), aSupportedTypes.getArray() );
     417           8 :     return aSupportedTypes;
     418             : }
     419             : 
     420           0 : Sequence< sal_Int8 > OConnection::getImplementationId() throw (RuntimeException, std::exception)
     421             : {
     422           0 :     return css::uno::Sequence<sal_Int8>();
     423             : }
     424             : 
     425             : // com::sun::star::uno::XInterface
     426        2902 : Any OConnection::queryInterface( const Type & rType ) throw (RuntimeException, std::exception)
     427             : {
     428        2902 :     if ( !m_bSupportsViews && rType.equals( cppu::UnoType<XViewsSupplier>::get() ) )
     429           4 :         return Any();
     430        2898 :     else if ( !m_bSupportsUsers && rType.equals( cppu::UnoType<XUsersSupplier>::get() ) )
     431           0 :         return Any();
     432        2898 :     else if ( !m_bSupportsGroups && rType.equals( cppu::UnoType<XGroupsSupplier>::get() ) )
     433           0 :         return Any();
     434        2898 :     Any aReturn = OSubComponent::queryInterface( rType );
     435        2898 :     if (!aReturn.hasValue())
     436             :     {
     437        1304 :         aReturn = OConnection_Base::queryInterface( rType );
     438        1304 :         if (!aReturn.hasValue())
     439         458 :             aReturn = OConnectionWrapper::queryInterface( rType );
     440             :     }
     441        2898 :     return aReturn;
     442             : }
     443             : 
     444       42206 : void OConnection::acquire() throw ()
     445             : {
     446             :     // include this one when you want to see who calls it (call graph)
     447       42206 :     OSubComponent::acquire();
     448       42206 : }
     449             : 
     450       42172 : void OConnection::release() throw ()
     451             : {
     452             :     // include this one when you want to see who calls it (call graph)
     453       42172 :     OSubComponent::release();
     454       42172 : }
     455             : 
     456             : // OSubComponent
     457          68 : void OConnection::disposing()
     458             : {
     459          68 :     MutexGuard aGuard(m_aMutex);
     460             : 
     461          68 :     OSubComponent::disposing();
     462          68 :     OConnectionWrapper::disposing();
     463             : 
     464          68 :     connectivity::OWeakRefArray::iterator aEnd = m_aStatements.end();
     465         180 :     for (connectivity::OWeakRefArray::iterator i = m_aStatements.begin(); aEnd != i; ++i)
     466             :     {
     467         112 :         Reference<XComponent> xComp(i->get(),UNO_QUERY);
     468         112 :         ::comphelper::disposeComponent(xComp);
     469         112 :     }
     470          68 :     m_aStatements.clear();
     471          68 :     m_xMasterTables = NULL;
     472             : 
     473          68 :     if(m_pTables)
     474          68 :         m_pTables->dispose();
     475          68 :     if(m_pViews)
     476           2 :         m_pViews->dispose();
     477             : 
     478          68 :     ::comphelper::disposeComponent(m_xQueries);
     479             : 
     480          68 :     connectivity::OWeakRefArray::iterator aComposerEnd = m_aComposers.end();
     481         148 :     for (connectivity::OWeakRefArray::iterator j = m_aComposers.begin(); aComposerEnd != j; ++j)
     482             :     {
     483          80 :         Reference<XComponent> xComp(j->get(),UNO_QUERY);
     484          80 :         ::comphelper::disposeComponent(xComp);
     485          80 :     }
     486             : 
     487          68 :     m_aComposers.clear();
     488             : 
     489             :     try
     490             :     {
     491          68 :         if (m_xMasterConnection.is())
     492          68 :             m_xMasterConnection->close();
     493             :     }
     494           4 :     catch(const Exception&)
     495             :     {
     496             :     }
     497          68 :     m_xMasterConnection = NULL;
     498          68 : }
     499             : 
     500             : // XChild
     501         506 : Reference< XInterface >  OConnection::getParent(void) throw( RuntimeException, std::exception )
     502             : {
     503         506 :     MutexGuard aGuard(m_aMutex);
     504         506 :     checkDisposed();
     505         506 :     return m_xParent;
     506             : }
     507             : 
     508           0 : void OConnection::setParent(const Reference< XInterface > & /*Parent*/) throw( NoSupportException, RuntimeException, std::exception )
     509             : {
     510           0 :     throw NoSupportException();
     511             : }
     512             : 
     513             : // XSQLQueryComposerFactory
     514           0 : Reference< XSQLQueryComposer >  OConnection::createQueryComposer(void) throw( RuntimeException, std::exception )
     515             : {
     516           0 :     MutexGuard aGuard(m_aMutex);
     517           0 :     checkDisposed();
     518             : 
     519             :     //  Reference< XNumberFormatsSupplier >  xSupplier = pParent->getNumberFormatsSupplier();
     520           0 :     Reference< XSQLQueryComposer >  xComposer( new OQueryComposer( this ) );
     521           0 :     m_aComposers.push_back(WeakReferenceHelper(xComposer));
     522           0 :     return xComposer;
     523             : }
     524             : 
     525          64 : void OConnection::impl_fillTableFilter()
     526             : {
     527          64 :     Reference<XPropertySet> xProp(getParent(),UNO_QUERY);
     528          64 :     if ( xProp.is() )
     529             :     {
     530          64 :         xProp->getPropertyValue(PROPERTY_TABLEFILTER)       >>= m_aTableFilter;
     531          64 :         xProp->getPropertyValue(PROPERTY_TABLETYPEFILTER)   >>= m_aTableTypeFilter;
     532          64 :     }
     533          64 : }
     534             : 
     535         640 : void OConnection::refresh(const Reference< XNameAccess >& _rToBeRefreshed)
     536             : {
     537         640 :     if ( _rToBeRefreshed == Reference< XNameAccess >(m_pTables) )
     538             :     {
     539         640 :         if (m_pTables && !m_pTables->isInitialized())
     540             :         {
     541          64 :             impl_fillTableFilter();
     542             :             // check if our "master connection" can supply tables
     543          64 :             getMasterTables();
     544             : 
     545          64 :             if (m_xMasterTables.is() && m_xMasterTables->getTables().is())
     546             :             {   // yes -> wrap them
     547          64 :                 m_pTables->construct(m_xMasterTables->getTables(),m_aTableFilter, m_aTableTypeFilter);
     548             :             }
     549             :             else
     550             :             {   // no -> use an own container
     551           0 :                 m_pTables->construct(m_aTableFilter, m_aTableTypeFilter);
     552             :             }
     553             :         }
     554             :     }
     555           0 :     else if ( _rToBeRefreshed == Reference< XNameAccess >(m_pViews) )
     556             :     {
     557           0 :         if (m_pViews && !m_pViews->isInitialized())
     558             :         {
     559           0 :             impl_fillTableFilter();
     560             :             // check if our "master connection" can supply tables
     561           0 :             Reference< XViewsSupplier > xMaster(getMasterTables(),UNO_QUERY);
     562             : 
     563           0 :             if (xMaster.is() && xMaster->getViews().is())
     564           0 :                 m_pViews->construct(xMaster->getViews(),m_aTableFilter, m_aTableTypeFilter);
     565             :             else
     566           0 :                 m_pViews->construct(m_aTableFilter, m_aTableTypeFilter);
     567             :         }
     568             :     }
     569         640 : }
     570             : 
     571             : // XTablesSupplier
     572         640 : Reference< XNameAccess >  OConnection::getTables() throw( RuntimeException, std::exception )
     573             : {
     574         640 :     MutexGuard aGuard(m_aMutex);
     575         640 :     checkDisposed();
     576             : 
     577         640 :     refresh(m_pTables);
     578             : 
     579         640 :     return m_pTables;
     580             : }
     581             : 
     582           0 : Reference< XNameAccess > SAL_CALL OConnection::getViews(  ) throw(RuntimeException, std::exception)
     583             : {
     584           0 :     MutexGuard aGuard(m_aMutex);
     585           0 :     checkDisposed();
     586             : 
     587           0 :     refresh(m_pViews);
     588             : 
     589           0 :     return m_pViews;
     590             : }
     591             : 
     592             : // XQueriesSupplier
     593         106 : Reference< XNameAccess >  OConnection::getQueries(void) throw( RuntimeException, std::exception )
     594             : {
     595         106 :     MutexGuard aGuard(m_aMutex);
     596         106 :     checkDisposed();
     597             : 
     598         106 :     return m_xQueries;
     599             : }
     600             : 
     601             : // ::com::sun::star::sdb::XCommandPreparation
     602           0 : Reference< XPreparedStatement >  SAL_CALL OConnection::prepareCommand( const OUString& command, sal_Int32 commandType ) throw(::com::sun::star::sdbc::SQLException, RuntimeException, std::exception)
     603             : {
     604           0 :     MutexGuard aGuard(m_aMutex);
     605           0 :     checkDisposed();
     606             : 
     607           0 :     OUString aStatement;
     608           0 :     switch (commandType)
     609             :     {
     610             :         case CommandType::TABLE:
     611             :             {
     612           0 :                 aStatement = "SELECT * FROM ";
     613             : 
     614           0 :                 OUString sCatalog, sSchema, sTable;
     615           0 :                 ::dbtools::qualifiedNameComponents( getMetaData(), command, sCatalog, sSchema, sTable, ::dbtools::eInDataManipulation );
     616           0 :                 aStatement += ::dbtools::composeTableNameForSelect( this, sCatalog, sSchema, sTable );
     617             :             }
     618           0 :             break;
     619             :         case CommandType::QUERY:
     620           0 :             if ( m_xQueries->hasByName(command) )
     621             :             {
     622           0 :                 Reference< XPropertySet > xQuery(m_xQueries->getByName(command),UNO_QUERY);
     623           0 :                 xQuery->getPropertyValue(PROPERTY_COMMAND) >>= aStatement;
     624             :             }
     625           0 :             break;
     626             :         default:
     627           0 :             aStatement = command;
     628             :     }
     629             :     // TODO EscapeProcessing
     630           0 :     return prepareStatement(aStatement);
     631             : }
     632             : 
     633          82 : Reference< XInterface > SAL_CALL OConnection::createInstance( const OUString& _sServiceSpecifier ) throw (Exception, RuntimeException, std::exception)
     634             : {
     635          82 :     Reference< XServiceInfo > xRet;
     636          82 :     if ( SERVICE_NAME_SINGLESELECTQUERYCOMPOSER == _sServiceSpecifier || _sServiceSpecifier == "com.sun.star.sdb.SingleSelectQueryAnalyzer" )
     637             :     {
     638          82 :         xRet = new OSingleSelectQueryComposer( getTables(),this, m_aContext );
     639          82 :         m_aComposers.push_back(WeakReferenceHelper(xRet));
     640             :     }
     641             :     else
     642             :     {
     643           0 :         if ( !_sServiceSpecifier.isEmpty() )
     644             :         {
     645           0 :             TSupportServices::iterator aFind = m_aSupportServices.find(_sServiceSpecifier);
     646           0 :             if ( aFind == m_aSupportServices.end() )
     647             :             {
     648           0 :                 Sequence<Any> aArgs(1);
     649           0 :                 Reference<XConnection> xMy(this);
     650           0 :                 aArgs[0] <<= NamedValue("ActiveConnection",makeAny(xMy));
     651             :                 aFind = m_aSupportServices.insert(
     652             :                            TSupportServices::value_type(
     653             :                                _sServiceSpecifier,
     654           0 :                                m_aContext->getServiceManager()->createInstanceWithArgumentsAndContext(_sServiceSpecifier, aArgs, m_aContext)
     655           0 :                            )).first;
     656             :             }
     657           0 :             return aFind->second;
     658             :         }
     659             :     }
     660          82 :     return Reference<XInterface>(xRet, UNO_QUERY);
     661             : }
     662             : 
     663           0 : Reference< XInterface > SAL_CALL OConnection::createInstanceWithArguments( const OUString& _sServiceSpecifier, const Sequence< Any >& /*Arguments*/ ) throw (Exception, RuntimeException, std::exception)
     664             : {
     665           0 :     return createInstance(_sServiceSpecifier);
     666             : }
     667             : 
     668           2 : Sequence< OUString > SAL_CALL OConnection::getAvailableServiceNames(  ) throw (RuntimeException, std::exception)
     669             : {
     670           2 :     Sequence< OUString > aRet(1);
     671           2 :     aRet[0] = SERVICE_NAME_SINGLESELECTQUERYCOMPOSER;
     672           2 :     return aRet;
     673             : }
     674             : 
     675         270 : Reference< XTablesSupplier > OConnection::getMasterTables()
     676             : {
     677             : // check if out "master connection" can supply tables
     678         270 :     if(!m_xMasterTables.is())
     679             :     {
     680             :         try
     681             :         {
     682          70 :             Reference<XDatabaseMetaData> xMeta = getMetaData();
     683          70 :             if ( xMeta.is() )
     684          70 :                 m_xMasterTables = ::dbtools::getDataDefinitionByURLAndConnection( xMeta->getURL(), m_xMasterConnection, m_aContext );
     685             :         }
     686           0 :         catch(const SQLException&)
     687             :         {
     688             :         }
     689             :     }
     690         270 :     return m_xMasterTables;
     691             : }
     692             : 
     693             : // XUsersSupplier
     694           0 : Reference< XNameAccess > SAL_CALL OConnection::getUsers(  ) throw(RuntimeException, std::exception)
     695             : {
     696           0 :     MutexGuard aGuard(m_aMutex);
     697           0 :     checkDisposed();
     698             : 
     699           0 :     Reference<XUsersSupplier> xUsr(getMasterTables(),UNO_QUERY);
     700           0 :     return xUsr.is() ? xUsr->getUsers() : Reference< XNameAccess >();
     701             : }
     702             : 
     703             : // XGroupsSupplier
     704           0 : Reference< XNameAccess > SAL_CALL OConnection::getGroups(  ) throw(RuntimeException, std::exception)
     705             : {
     706           0 :     MutexGuard aGuard(m_aMutex);
     707           0 :     checkDisposed();
     708           0 :     Reference<XGroupsSupplier> xGrp(getMasterTables(),UNO_QUERY);
     709           0 :     return xGrp.is() ? xGrp->getGroups() : Reference< XNameAccess >();
     710             : }
     711             : 
     712           0 : void OConnection::impl_loadConnectionTools_throw()
     713             : {
     714           0 :     m_xConnectionTools = css::sdb::tools::ConnectionTools::createWithConnection( m_aContext, this );
     715           0 : }
     716             : 
     717           0 : Reference< XTableName > SAL_CALL OConnection::createTableName(  ) throw (RuntimeException, std::exception)
     718             : {
     719           0 :     MutexGuard aGuard(m_aMutex);
     720           0 :     checkDisposed();
     721           0 :     impl_loadConnectionTools_throw();
     722             : 
     723           0 :     return m_xConnectionTools->createTableName();
     724             : }
     725             : 
     726           0 : Reference< XObjectNames > SAL_CALL OConnection::getObjectNames(  ) throw (RuntimeException, std::exception)
     727             : {
     728           0 :     MutexGuard aGuard(m_aMutex);
     729           0 :     checkDisposed();
     730           0 :     impl_loadConnectionTools_throw();
     731             : 
     732           0 :     return m_xConnectionTools->getObjectNames();
     733             : }
     734             : 
     735           0 : Reference< XDataSourceMetaData > SAL_CALL OConnection::getDataSourceMetaData(  ) throw (RuntimeException, std::exception)
     736             : {
     737           0 :     MutexGuard aGuard(m_aMutex);
     738           0 :     checkDisposed();
     739           0 :     impl_loadConnectionTools_throw();
     740             : 
     741           0 :     return m_xConnectionTools->getDataSourceMetaData();
     742             : }
     743             : 
     744           0 : Reference< ::com::sun::star::container::XNameAccess > SAL_CALL OConnection::getFieldsByCommandDescriptor( ::sal_Int32 commandType, const OUString& command, ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent >& keepFieldsAlive ) throw (::com::sun::star::sdbc::SQLException, RuntimeException, std::exception)
     745             : {
     746           0 :     MutexGuard aGuard(m_aMutex);
     747           0 :     checkDisposed();
     748           0 :     impl_loadConnectionTools_throw();
     749             : 
     750           0 :     return m_xConnectionTools->getFieldsByCommandDescriptor(commandType,command,keepFieldsAlive);
     751             : }
     752             : 
     753           0 : Reference< XSingleSelectQueryComposer > SAL_CALL OConnection::getComposer( ::sal_Int32 commandType, const OUString& command ) throw (::com::sun::star::uno::RuntimeException, std::exception)
     754             : {
     755           0 :     MutexGuard aGuard(m_aMutex);
     756           0 :     checkDisposed();
     757           0 :     impl_loadConnectionTools_throw();
     758             : 
     759           0 :     return m_xConnectionTools->getComposer(commandType,command);
     760             : }
     761             : 
     762          70 : void OConnection::impl_checkTableQueryNames_nothrow()
     763             : {
     764          70 :     DatabaseMetaData aMeta( static_cast< XConnection* >( this ) );
     765          70 :     if ( !aMeta.supportsSubqueriesInFrom() )
     766             :         // nothing to do
     767         132 :         return;
     768             : 
     769             :     try
     770             :     {
     771           8 :         Reference< XNameAccess > xTables( getTables() );
     772          16 :         Sequence< OUString > aTableNames( xTables->getElementNames() );
     773          16 :         ::std::set< OUString > aSortedTableNames( aTableNames.getConstArray(), aTableNames.getConstArray() + aTableNames.getLength() );
     774             : 
     775          16 :         Reference< XNameAccess > xQueries( getQueries() );
     776          16 :         Sequence< OUString > aQueryNames( xQueries->getElementNames() );
     777             : 
     778          16 :         for (   const OUString* pQueryName = aQueryNames.getConstArray();
     779           8 :                 pQueryName != aQueryNames.getConstArray() + aQueryNames.getLength();
     780             :                 ++pQueryName
     781             :             )
     782             :         {
     783           0 :             if ( aSortedTableNames.find( *pQueryName ) != aSortedTableNames.end() )
     784             :             {
     785           0 :                 OUString sConflictWarning( DBACORE_RESSTRING( RID_STR_CONFLICTING_NAMES ) );
     786           0 :                 m_aWarnings.appendWarning( sConflictWarning, "01SB0", *this );
     787             :             }
     788           8 :         }
     789             :     }
     790           0 :     catch( const Exception& )
     791             :     {
     792             :         DBG_UNHANDLED_EXCEPTION();
     793           8 :     }
     794             : }
     795             : 
     796           2 : Reference< XGraphic > SAL_CALL OConnection::getTableIcon( const OUString& _TableName, ::sal_Int32 _ColorMode ) throw (RuntimeException, std::exception)
     797             : {
     798           2 :     Reference< XGraphic > xReturn;
     799             : 
     800             :     // ask our aggregate
     801           2 :     if ( m_xTableUIProvider.is() )
     802           0 :         xReturn = m_xTableUIProvider->getTableIcon( _TableName, _ColorMode );
     803             : 
     804             :     // ask ourself
     805             :     // well, we don't have own functionality here ...
     806             :     // In the future, we might decide to delegate the complete handling to this interface.
     807             :     // In this case, we would need to load the icon here.
     808             : 
     809           2 :     return xReturn;
     810             : }
     811             : 
     812           0 : Reference< XInterface > SAL_CALL OConnection::getTableEditor( const Reference< XDatabaseDocumentUI >& _DocumentUI, const OUString& _TableName ) throw (IllegalArgumentException, WrappedTargetException, RuntimeException, std::exception)
     813             : {
     814           0 :     Reference< XInterface > xReturn;
     815             : 
     816             :     // ask our aggregate
     817           0 :     if ( m_xTableUIProvider.is() )
     818           0 :         xReturn = m_xTableUIProvider->getTableEditor( _DocumentUI, _TableName );
     819             : 
     820             :     // ask ourself
     821             :     // well, we don't have own functionality here ...
     822             :     // In the future, we might decide to delegate the complete handling to this interface.
     823             :     // In this case, we would need to instantiate an css.sdb.TableDesign here.
     824             : 
     825           0 :     return xReturn;
     826             : }
     827             : 
     828             : }   // namespace dbaccess
     829             : 
     830             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10