From 940b4d1848e8c70ab7642901a68594e8016caffc Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 27 Apr 2024 18:51:28 +0200 Subject: Adding upstream version 1:7.0.4. Signed-off-by: Daniel Baumann --- connectivity/source/sdbcx/VCatalog.cxx | 211 +++++++++++ connectivity/source/sdbcx/VCollection.cxx | 583 +++++++++++++++++++++++++++++ connectivity/source/sdbcx/VColumn.cxx | 220 +++++++++++ connectivity/source/sdbcx/VDescriptor.cxx | 128 +++++++ connectivity/source/sdbcx/VGroup.cxx | 166 ++++++++ connectivity/source/sdbcx/VIndex.cxx | 199 ++++++++++ connectivity/source/sdbcx/VIndexColumn.cxx | 102 +++++ connectivity/source/sdbcx/VKey.cxx | 202 ++++++++++ connectivity/source/sdbcx/VKeyColumn.cxx | 106 ++++++ connectivity/source/sdbcx/VTable.cxx | 304 +++++++++++++++ connectivity/source/sdbcx/VUser.cxx | 180 +++++++++ connectivity/source/sdbcx/VView.cxx | 132 +++++++ 12 files changed, 2533 insertions(+) create mode 100644 connectivity/source/sdbcx/VCatalog.cxx create mode 100644 connectivity/source/sdbcx/VCollection.cxx create mode 100644 connectivity/source/sdbcx/VColumn.cxx create mode 100644 connectivity/source/sdbcx/VDescriptor.cxx create mode 100644 connectivity/source/sdbcx/VGroup.cxx create mode 100644 connectivity/source/sdbcx/VIndex.cxx create mode 100644 connectivity/source/sdbcx/VIndexColumn.cxx create mode 100644 connectivity/source/sdbcx/VKey.cxx create mode 100644 connectivity/source/sdbcx/VKeyColumn.cxx create mode 100644 connectivity/source/sdbcx/VTable.cxx create mode 100644 connectivity/source/sdbcx/VUser.cxx create mode 100644 connectivity/source/sdbcx/VView.cxx (limited to 'connectivity/source/sdbcx') diff --git a/connectivity/source/sdbcx/VCatalog.cxx b/connectivity/source/sdbcx/VCatalog.cxx new file mode 100644 index 000000000..b30519fca --- /dev/null +++ b/connectivity/source/sdbcx/VCatalog.cxx @@ -0,0 +1,211 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace connectivity; +using namespace connectivity::sdbcx; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::sdbcx; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::lang; + +IMPLEMENT_SERVICE_INFO(OCatalog,"com.sun.star.comp.connectivity.OCatalog","com.sun.star.sdbcx.DatabaseDefinition") + +OCatalog::OCatalog(const Reference< XConnection> &_xConnection) : OCatalog_BASE(m_aMutex) +{ + try + { + m_xMetaData = _xConnection->getMetaData(); + } + catch(const Exception&) + { + OSL_FAIL("No Metadata available!"); + } +} + +OCatalog::~OCatalog() +{ +} + +void SAL_CALL OCatalog::disposing() +{ + ::osl::MutexGuard aGuard(m_aMutex); + + if(m_pTables) + m_pTables->disposing(); + if(m_pViews) + m_pViews->disposing(); + if(m_pGroups) + m_pGroups->disposing(); + if(m_pUsers) + m_pUsers->disposing(); + + OCatalog_BASE::disposing(); +} + +// XTablesSupplier +Reference< XNameAccess > SAL_CALL OCatalog::getTables( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OCatalog_BASE::rBHelper.bDisposed); + + try + { + if(!m_pTables) + refreshTables(); + } + catch( const RuntimeException& ) + { + // allowed to leave this method + throw; + } + catch( const Exception& ) + { + // allowed + } + + return m_pTables.get(); +} + +// XViewsSupplier +Reference< XNameAccess > SAL_CALL OCatalog::getViews( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OCatalog_BASE::rBHelper.bDisposed); + + try + { + if(!m_pViews) + refreshViews(); + } + catch( const RuntimeException& ) + { + // allowed to leave this method + throw; + } + catch( const Exception& ) + { + // allowed + } + + return m_pViews.get(); +} + +// XUsersSupplier +Reference< XNameAccess > SAL_CALL OCatalog::getUsers( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OCatalog_BASE::rBHelper.bDisposed); + + try + { + if(!m_pUsers) + refreshUsers(); + } + catch( const RuntimeException& ) + { + // allowed to leave this method + throw; + } + catch( const Exception& ) + { + // allowed + } + + return m_pUsers.get(); +} + +// XGroupsSupplier +Reference< XNameAccess > SAL_CALL OCatalog::getGroups( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OCatalog_BASE::rBHelper.bDisposed); + + try + { + if(!m_pGroups) + refreshGroups(); + } + catch( const RuntimeException& ) + { + // allowed to leave this method + throw; + } + catch( const Exception& ) + { + // allowed + } + + return m_pGroups.get(); +} + +OUString OCatalog::buildName(const Reference< XRow >& _xRow) +{ + OUString sCatalog = _xRow->getString(1); + if ( _xRow->wasNull() ) + sCatalog.clear(); + OUString sSchema = _xRow->getString(2); + if ( _xRow->wasNull() ) + sSchema.clear(); + OUString sTable = _xRow->getString(3); + if ( _xRow->wasNull() ) + sTable.clear(); + + OUString sComposedName( + ::dbtools::composeTableName( m_xMetaData, sCatalog, sSchema, sTable, false, ::dbtools::EComposeRule::InDataManipulation ) ); + return sComposedName; +} + +void OCatalog::fillNames(Reference< XResultSet >& _xResult,::std::vector< OUString>& _rNames) +{ + if ( _xResult.is() ) + { + _rNames.reserve(20); + Reference< XRow > xRow(_xResult,UNO_QUERY); + while ( _xResult->next() ) + { + _rNames.push_back( buildName(xRow) ); + } + xRow.clear(); + ::comphelper::disposeComponent(_xResult); + } +} + +void ODescriptor::construct() +{ + sal_Int32 nAttrib = isNew() ? 0 : css::beans::PropertyAttribute::READONLY; + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME), PROPERTY_ID_NAME ,nAttrib,&m_Name,::cppu::UnoType::get()); +} + +ODescriptor::~ODescriptor() +{ +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/sdbcx/VCollection.cxx b/connectivity/source/sdbcx/VCollection.cxx new file mode 100644 index 000000000..d7a716a59 --- /dev/null +++ b/connectivity/source/sdbcx/VCollection.cxx @@ -0,0 +1,583 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace connectivity::sdbcx; +using namespace connectivity; +using namespace comphelper; +using namespace ::cppu; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::util; + +namespace +{ + template < typename T> class OHardRefMap : public connectivity::sdbcx::IObjectCollection + { + typedef std::multimap< OUString, T , ::comphelper::UStringMixLess> ObjectMap; + typedef typename ObjectMap::iterator ObjectIter; + typedef typename ObjectMap::value_type ObjectEntry; + + // private: + // this combination of map and vector is used to have a fast name and index access + std::vector< ObjectIter > m_aElements; // hold the iterators which point to map + ObjectMap m_aNameMap; // hold the elements and a name + public: + OHardRefMap(bool _bCase) + : m_aNameMap(_bCase) + { + } + + virtual bool exists(const OUString& _sName ) override + { + return m_aNameMap.find(_sName) != m_aNameMap.end(); + } + + virtual bool empty() override + { + return m_aNameMap.empty(); + } + + virtual void swapAll() override + { + std::vector< ObjectIter >(m_aElements).swap(m_aElements); + ObjectMap(m_aNameMap).swap(m_aNameMap); + } + + virtual void swap() override + { + std::vector< ObjectIter >().swap(m_aElements); + + OSL_ENSURE( m_aNameMap.empty(), "swap: what did disposeElements do?" ); + ObjectMap( m_aNameMap ).swap( m_aNameMap ); + // Note that it's /important/ to construct the new ObjectMap from m_aNameMap before + // swapping. This way, it's ensured that the compare object held by these maps is preserved + // during the swap. If we would not do this, the UStringMixLess instance which is used would be + // default constructed (instead of being constructed from the same instance in m_aNameMap), and + // it's case-sensitive flag would have an unpredictable value. + } + + virtual void clear() override + { + m_aElements.clear(); + m_aNameMap.clear(); + } + + virtual void insert(const OUString& _sName,const ObjectType& _xObject) override + { + m_aElements.push_back(m_aNameMap.insert(m_aNameMap.begin(), ObjectEntry(_sName,_xObject))); + } + + virtual void reFill(const ::std::vector< OUString> &_rVector) override + { + OSL_ENSURE(m_aNameMap.empty(),"OCollection::reFill: collection isn't empty"); + m_aElements.reserve(_rVector.size()); + + for (auto const& elem : _rVector) + m_aElements.push_back(m_aNameMap.insert(m_aNameMap.begin(), ObjectEntry(elem,ObjectType()))); + } + + virtual bool rename(const OUString& _sOldName, const OUString& _sNewName) override + { + bool bRet = false; + ObjectIter aIter = m_aNameMap.find(_sOldName); + if ( aIter != m_aNameMap.end() ) + { + typename std::vector< ObjectIter >::iterator aFind = std::find(m_aElements.begin(),m_aElements.end(),aIter); + if(m_aElements.end() != aFind) + { + (*aFind) = m_aNameMap.insert(m_aNameMap.begin(), ObjectEntry(_sNewName,(*aFind)->second)); + m_aNameMap.erase(aIter); + + bRet = true; + } + } + return bRet; + } + + virtual sal_Int32 size() override + { + return static_cast(m_aNameMap.size()); + } + + virtual Sequence< OUString > getElementNames() override + { + Sequence< OUString > aNameList(m_aElements.size()); + + OUString* pStringArray = aNameList.getArray(); + for(const auto& rIter : m_aElements) + { + *pStringArray = rIter->first; + ++pStringArray; + } + + return aNameList; + } + + virtual OUString getName(sal_Int32 _nIndex) override + { + return m_aElements[_nIndex]->first; + } + + virtual void disposeAndErase(sal_Int32 _nIndex) override + { + OSL_ENSURE(_nIndex >= 0 && _nIndex < static_cast(m_aElements.size()),"Illegal argument!"); + Reference xComp(m_aElements[_nIndex]->second.get(),UNO_QUERY); + ::comphelper::disposeComponent(xComp); + m_aElements[_nIndex]->second = T(); + + OUString sName = m_aElements[_nIndex]->first; + m_aElements.erase(m_aElements.begin()+_nIndex); + m_aNameMap.erase(sName); + } + + virtual void disposeElements() override + { + for (auto & name : m_aNameMap) + { + Reference xComp(name.second.get(),UNO_QUERY); + if ( xComp.is() ) + { + ::comphelper::disposeComponent(xComp); + name.second = T(); + } + } + m_aElements.clear(); + m_aNameMap.clear(); + } + + virtual sal_Int32 findColumn( const OUString& columnName ) override + { + ObjectIter aIter = m_aNameMap.find(columnName); + OSL_ENSURE(aIter != m_aNameMap.end(),"findColumn:: Illegal name!"); + return m_aElements.size() - (m_aElements.end() - std::find(m_aElements.begin(),m_aElements.end(),aIter)); + } + + virtual ObjectType getObject(sal_Int32 _nIndex) override + { + OSL_ENSURE(_nIndex >= 0 && _nIndex < static_cast(m_aElements.size()),"Illegal argument!"); + return m_aElements[_nIndex]->second; + } + + virtual ObjectType getObject(const OUString& columnName) override + { + return m_aNameMap.find(columnName)->second; + } + + virtual void setObject(sal_Int32 _nIndex,const ObjectType& _xObject) override + { + OSL_ENSURE(_nIndex >= 0 && _nIndex < static_cast(m_aElements.size()),"Illegal argument!"); + m_aElements[_nIndex]->second = _xObject; + } + + bool isCaseSensitive() const override + { + return m_aNameMap.key_comp().isCaseSensitive(); + } + + }; +} + +IObjectCollection::~IObjectCollection() {} + +IMPLEMENT_SERVICE_INFO(OCollection,"com.sun.star.sdbcx.VContainer" , "com.sun.star.sdbcx.Container") + +OCollection::OCollection(::cppu::OWeakObject& _rParent + , bool _bCase + , ::osl::Mutex& _rMutex + , const ::std::vector< OUString> &_rVector + , bool _bUseIndexOnly + , bool _bUseHardRef) + :m_aContainerListeners(_rMutex) + ,m_aRefreshListeners(_rMutex) + ,m_rParent(_rParent) + ,m_rMutex(_rMutex) + ,m_bUseIndexOnly(_bUseIndexOnly) +{ + if ( _bUseHardRef ) + { + m_pElements.reset(new OHardRefMap< ObjectType >(_bCase)); + } + else + { + m_pElements.reset(new OHardRefMap< WeakReference< XPropertySet> >(_bCase)); + } + m_pElements->reFill(_rVector); +} + +OCollection::~OCollection() +{ +} + +Any SAL_CALL OCollection::queryInterface( const Type & rType ) +{ + if ( m_bUseIndexOnly && rType == cppu::UnoType::get() ) + { + return Any(); + } + return OCollectionBase::queryInterface( rType ); +} + +Sequence< Type > SAL_CALL OCollection::getTypes() +{ + if ( m_bUseIndexOnly ) + { + Sequence< Type > aTypes(OCollectionBase::getTypes()); + Type* pBegin = aTypes.getArray(); + Type* pEnd = pBegin + aTypes.getLength(); + + std::vector aOwnTypes; + aOwnTypes.reserve(aTypes.getLength()); + Type aType = cppu::UnoType::get(); + for(;pBegin != pEnd; ++pBegin) + { + if ( *pBegin != aType ) + aOwnTypes.push_back(*pBegin); + } + return Sequence< Type >(aOwnTypes.data(), aOwnTypes.size()); + } + return OCollectionBase::getTypes( ); +} + +void OCollection::clear_NoDispose() +{ + ::osl::MutexGuard aGuard(m_rMutex); + + m_pElements->clear(); + m_pElements->swapAll(); +} + + +void OCollection::disposing() +{ + m_aContainerListeners.disposeAndClear(EventObject(static_cast(this))); + m_aRefreshListeners.disposeAndClear(EventObject(static_cast(this))); + + ::osl::MutexGuard aGuard(m_rMutex); + + disposeElements(); + + m_pElements->swap(); +} + +Any SAL_CALL OCollection::getByIndex( sal_Int32 Index ) +{ + ::osl::MutexGuard aGuard(m_rMutex); + if (Index < 0 || Index >= m_pElements->size() ) + throw IndexOutOfBoundsException(OUString::number(Index),static_cast(this)); + + return makeAny(getObject(Index)); +} + +Any SAL_CALL OCollection::getByName( const OUString& aName ) +{ + ::osl::MutexGuard aGuard(m_rMutex); + + if ( !m_pElements->exists(aName) ) + { + ::connectivity::SharedResources aResources; + const OUString sError( aResources.getResourceStringWithSubstitution( + STR_NO_ELEMENT_NAME, + "$name$", aName + ) ); + throw NoSuchElementException( sError, static_cast< XTypeProvider* >( this ) ); + } + + return makeAny(getObject(m_pElements->findColumn(aName))); +} + +Sequence< OUString > SAL_CALL OCollection::getElementNames( ) +{ + ::osl::MutexGuard aGuard(m_rMutex); + return m_pElements->getElementNames(); +} + +void SAL_CALL OCollection::refresh( ) +{ + ::osl::MutexGuard aGuard(m_rMutex); + + disposeElements(); + + impl_refresh(); + EventObject aEvt(static_cast(this)); + m_aRefreshListeners.notifyEach( &XRefreshListener::refreshed, aEvt ); +} + +void OCollection::reFill(const ::std::vector< OUString> &_rVector) +{ + m_pElements->reFill(_rVector); +} + +// XDataDescriptorFactory +Reference< XPropertySet > SAL_CALL OCollection::createDataDescriptor( ) +{ + ::osl::MutexGuard aGuard(m_rMutex); + + return createDescriptor(); +} + +OUString OCollection::getNameForObject(const ObjectType& _xObject) +{ + OSL_ENSURE(_xObject.is(),"OCollection::getNameForObject: Object is NULL!"); + OUString sName; + _xObject->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= sName; + return sName; +} + +// XAppend +void SAL_CALL OCollection::appendByDescriptor( const Reference< XPropertySet >& descriptor ) +{ + ::osl::ClearableMutexGuard aGuard(m_rMutex); + + OUString sName = getNameForObject( descriptor ); + + if ( m_pElements->exists(sName) ) + throw ElementExistException(sName,static_cast(this)); + + ObjectType xNewlyCreated = appendObject( sName, descriptor ); + if ( !xNewlyCreated.is() ) + throw RuntimeException(); + + ODescriptor* pDescriptor = comphelper::getUnoTunnelImplementation( xNewlyCreated ); + if ( pDescriptor ) + pDescriptor->setNew( false ); + + sName = getNameForObject( xNewlyCreated ); + if ( !m_pElements->exists( sName ) ) // this may happen when the derived class included it itself + m_pElements->insert( sName, xNewlyCreated ); + + // notify our container listeners + ContainerEvent aEvent(static_cast(this), makeAny(sName), makeAny(xNewlyCreated), Any()); + aGuard.clear(); + m_aContainerListeners.notifyEach( &XContainerListener::elementInserted, aEvent ); +} + +// XDrop +void SAL_CALL OCollection::dropByName( const OUString& elementName ) +{ + ::osl::MutexGuard aGuard(m_rMutex); + + if ( !m_pElements->exists(elementName) ) + throw NoSuchElementException(elementName,static_cast(this)); + + dropImpl(m_pElements->findColumn(elementName)); +} + +void SAL_CALL OCollection::dropByIndex( sal_Int32 index ) +{ + ::osl::MutexGuard aGuard(m_rMutex); + if(index <0 || index >= getCount()) + throw IndexOutOfBoundsException(OUString::number(index),static_cast(this)); + + dropImpl(index); +} + +void OCollection::dropImpl(sal_Int32 _nIndex, bool _bReallyDrop) +{ + OUString elementName = m_pElements->getName(_nIndex); + + if ( _bReallyDrop ) + dropObject(_nIndex,elementName); + + m_pElements->disposeAndErase(_nIndex); + + // notify our container listeners + notifyElementRemoved(elementName); +} + +void OCollection::notifyElementRemoved(const OUString& _sName) +{ + ContainerEvent aEvent(static_cast(this), makeAny(_sName), Any(), Any()); + // note that xExistent may be empty, in case somebody removed the data source while it is not alive at this moment + OInterfaceIteratorHelper2 aListenerLoop(m_aContainerListeners); + while (aListenerLoop.hasMoreElements()) + static_cast(aListenerLoop.next())->elementRemoved(aEvent); +} + +sal_Int32 SAL_CALL OCollection::findColumn( const OUString& columnName ) +{ + if ( !m_pElements->exists(columnName) ) + { + ::dbtools::throwInvalidColumnException( columnName, static_cast< XIndexAccess*>(this) ); +#if !(defined(_MSC_VER) && defined(ENABLE_LTO)) + assert(false); +#endif + } + + return m_pElements->findColumn(columnName) + 1; // because columns start at one +} + +Reference< XEnumeration > SAL_CALL OCollection::createEnumeration( ) +{ + ::osl::MutexGuard aGuard(m_rMutex); + return new OEnumerationByIndex( static_cast< XIndexAccess*>(this)); +} + +void SAL_CALL OCollection::addContainerListener( const Reference< XContainerListener >& _rxListener ) +{ + m_aContainerListeners.addInterface(_rxListener); +} + + +void SAL_CALL OCollection::removeContainerListener( const Reference< XContainerListener >& _rxListener ) +{ + m_aContainerListeners.removeInterface(_rxListener); +} + +void SAL_CALL OCollection::acquire() throw() +{ + m_rParent.acquire(); +} + +void SAL_CALL OCollection::release() throw() +{ + m_rParent.release(); +} + +Type SAL_CALL OCollection::getElementType( ) +{ + return cppu::UnoType::get(); +} + +sal_Bool SAL_CALL OCollection::hasElements( ) +{ + ::osl::MutexGuard aGuard(m_rMutex); + return !m_pElements->empty(); +} + +sal_Int32 SAL_CALL OCollection::getCount( ) +{ + ::osl::MutexGuard aGuard(m_rMutex); + return m_pElements->size(); +} + +sal_Bool SAL_CALL OCollection::hasByName( const OUString& aName ) +{ + ::osl::MutexGuard aGuard(m_rMutex); + return m_pElements->exists(aName); +} + +void SAL_CALL OCollection::addRefreshListener( const Reference< XRefreshListener >& l ) +{ + m_aRefreshListeners.addInterface(l); +} + +void SAL_CALL OCollection::removeRefreshListener( const Reference< XRefreshListener >& l ) +{ + m_aRefreshListeners.removeInterface(l); +} + +void OCollection::insertElement(const OUString& _sElementName,const ObjectType& _xElement) +{ + OSL_ENSURE(!m_pElements->exists(_sElementName),"Element already exists"); + if ( !m_pElements->exists(_sElementName) ) + m_pElements->insert(_sElementName,_xElement); +} + +void OCollection::renameObject(const OUString& _sOldName, const OUString& _sNewName) +{ + OSL_ENSURE(m_pElements->exists(_sOldName),"Element doesn't exist"); + OSL_ENSURE(!m_pElements->exists(_sNewName),"Element already exists"); + OSL_ENSURE(!_sNewName.isEmpty(),"New name must not be empty!"); + OSL_ENSURE(!_sOldName.isEmpty(),"Old name must not be empty!"); + + if ( m_pElements->rename(_sOldName,_sNewName) ) + { + ContainerEvent aEvent(static_cast(this), makeAny(_sNewName), makeAny(m_pElements->getObject(_sNewName)),makeAny(_sOldName)); + // note that xExistent may be empty, in case somebody removed the data source while it is not alive at this moment + OInterfaceIteratorHelper2 aListenerLoop(m_aContainerListeners); + while (aListenerLoop.hasMoreElements()) + static_cast(aListenerLoop.next())->elementReplaced(aEvent); + } +} + +ObjectType OCollection::getObject(sal_Int32 _nIndex) +{ + ObjectType xName = m_pElements->getObject(_nIndex); + if ( !xName.is() ) + { + try + { + xName = createObject(m_pElements->getName(_nIndex)); + } + catch(const SQLException& e) + { + css::uno::Any anyEx = cppu::getCaughtException(); + try + { + dropImpl(_nIndex,false); + } + catch(const Exception& ) + { + } + throw WrappedTargetException(e.Message,static_cast(this),anyEx); + } + m_pElements->setObject(_nIndex,xName); + } + return xName; +} + +void OCollection::disposeElements() +{ + m_pElements->disposeElements(); +} + +Reference< XPropertySet > OCollection::createDescriptor() +{ + OSL_FAIL("createDescriptor() needs to be overridden when used!"); + throw SQLException(); +} + +ObjectType OCollection::cloneDescriptor( const ObjectType& _descriptor ) +{ + ObjectType xNewDescriptor( createDescriptor() ); + ::comphelper::copyProperties( _descriptor, xNewDescriptor ); + return xNewDescriptor; +} + +ObjectType OCollection::appendObject( const OUString& /*_rForName*/, const Reference< XPropertySet >& descriptor ) +{ + return cloneDescriptor( descriptor ); +} + +void OCollection::dropObject(sal_Int32 /*_nPos*/, const OUString& /*_sElementName*/) +{ +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/sdbcx/VColumn.cxx b/connectivity/source/sdbcx/VColumn.cxx new file mode 100644 index 000000000..239934531 --- /dev/null +++ b/connectivity/source/sdbcx/VColumn.cxx @@ -0,0 +1,220 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include +#include +#include +#include +#include +#include + +using namespace connectivity; +using namespace connectivity::sdbcx; +using namespace cppu; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::sdbc; + + +OUString SAL_CALL OColumn::getImplementationName( ) +{ + if(isNew()) + return "com.sun.star.sdbcx.VColumnDescriptor"; + return "com.sun.star.sdbcx.VColumn"; +} + +css::uno::Sequence< OUString > SAL_CALL OColumn::getSupportedServiceNames( ) +{ + return { isNew()?OUString("com.sun.star.sdbcx.ColumnDescriptor"):OUString("com.sun.star.sdbcx.Column") }; +} + +sal_Bool SAL_CALL OColumn::supportsService( const OUString& _rServiceName ) +{ + return cppu::supportsService(this, _rServiceName); +} + +OColumn::OColumn(bool _bCase) + :OColumnDescriptor_BASE(m_aMutex) + ,ODescriptor(OColumnDescriptor_BASE::rBHelper,_bCase,true) + ,m_IsNullable(ColumnValue::NULLABLE) + ,m_Precision(0) + ,m_Scale(0) + ,m_Type(0) + ,m_IsAutoIncrement(false) + ,m_IsRowVersion(false) + ,m_IsCurrency(false) +{ + construct(); +} + +OColumn::OColumn( const OUString& Name, + const OUString& TypeName, + const OUString& DefaultValue, + const OUString& Description, + sal_Int32 IsNullable, + sal_Int32 Precision, + sal_Int32 Scale, + sal_Int32 Type, + bool IsAutoIncrement, + bool IsRowVersion, + bool IsCurrency, + bool _bCase, + const OUString& CatalogName, + const OUString& SchemaName, + const OUString& TableName) + :OColumnDescriptor_BASE(m_aMutex) + ,ODescriptor(OColumnDescriptor_BASE::rBHelper,_bCase) + ,m_TypeName(TypeName) + ,m_Description(Description) + ,m_DefaultValue(DefaultValue) + ,m_IsNullable(IsNullable) + ,m_Precision(Precision) + ,m_Scale(Scale) + ,m_Type(Type) + ,m_IsAutoIncrement(IsAutoIncrement) + ,m_IsRowVersion(IsRowVersion) + ,m_IsCurrency(IsCurrency) + ,m_CatalogName(CatalogName) + ,m_SchemaName(SchemaName) + ,m_TableName(TableName) +{ + m_Name = Name; + + construct(); +} + +OColumn::~OColumn() +{ +} + +::cppu::IPropertyArrayHelper* OColumn::createArrayHelper( sal_Int32 /*_nId*/ ) const +{ + return doCreateArrayHelper(); +} + +::cppu::IPropertyArrayHelper& SAL_CALL OColumn::getInfoHelper() +{ + return *OColumn_PROP::getArrayHelper(isNew() ? 1 : 0); +} + +void SAL_CALL OColumn::acquire() throw() +{ + OColumnDescriptor_BASE::acquire(); +} + +void SAL_CALL OColumn::release() throw() +{ + OColumnDescriptor_BASE::release(); +} + +Any SAL_CALL OColumn::queryInterface( const Type & rType ) +{ + Any aRet = ODescriptor::queryInterface( rType); + if(!aRet.hasValue()) + { + if(!isNew()) + aRet = OColumn_BASE::queryInterface(rType); + if(!aRet.hasValue()) + aRet = OColumnDescriptor_BASE::queryInterface( rType); + } + return aRet; +} + +Sequence< Type > SAL_CALL OColumn::getTypes( ) +{ + if(isNew()) + return ::comphelper::concatSequences(ODescriptor::getTypes(),OColumnDescriptor_BASE::getTypes()); + + return ::comphelper::concatSequences(ODescriptor::getTypes(),OColumn_BASE::getTypes(),OColumnDescriptor_BASE::getTypes()); +} + +void OColumn::construct() +{ + ODescriptor::construct(); + + sal_Int32 nAttrib = isNew() ? 0 : PropertyAttribute::READONLY; + + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPENAME), PROPERTY_ID_TYPENAME, nAttrib, &m_TypeName, cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DESCRIPTION), PROPERTY_ID_DESCRIPTION, nAttrib, &m_Description, cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DEFAULTVALUE), PROPERTY_ID_DEFAULTVALUE, nAttrib, &m_DefaultValue, cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION), PROPERTY_ID_PRECISION, nAttrib, &m_Precision, cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE), PROPERTY_ID_TYPE, nAttrib, &m_Type, cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE), PROPERTY_ID_SCALE, nAttrib, &m_Scale, cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISNULLABLE), PROPERTY_ID_ISNULLABLE, nAttrib, &m_IsNullable, cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISAUTOINCREMENT), PROPERTY_ID_ISAUTOINCREMENT, nAttrib, &m_IsAutoIncrement, cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISROWVERSION), PROPERTY_ID_ISROWVERSION, nAttrib, &m_IsRowVersion, cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY), PROPERTY_ID_ISCURRENCY, nAttrib, &m_IsCurrency, cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CATALOGNAME), PROPERTY_ID_CATALOGNAME, nAttrib, &m_CatalogName, cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCHEMANAME), PROPERTY_ID_SCHEMANAME, nAttrib, &m_SchemaName, cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TABLENAME), PROPERTY_ID_TABLENAME, nAttrib, &m_TableName, cppu::UnoType::get()); +} + +void OColumn::disposing() +{ + OPropertySetHelper::disposing(); + + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OColumnDescriptor_BASE::rBHelper.bDisposed); + +} + +Reference< XPropertySet > SAL_CALL OColumn::createDataDescriptor( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OColumnDescriptor_BASE::rBHelper.bDisposed); + + + OColumn* pNewColumn = new OColumn( m_Name, + m_TypeName, + m_DefaultValue, + m_Description, + m_IsNullable, + m_Precision, + m_Scale, + m_Type, + m_IsAutoIncrement, + m_IsRowVersion, + m_IsCurrency, + isCaseSensitive(), + m_CatalogName, + m_SchemaName, + m_TableName); + pNewColumn->setNew(true); + return pNewColumn; +} + +css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL OColumn::getPropertySetInfo( ) +{ + return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper()); +} + +// XNamed +OUString SAL_CALL OColumn::getName( ) +{ + return m_Name; +} + +void SAL_CALL OColumn::setName( const OUString& aName ) +{ + m_Name = aName; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/sdbcx/VDescriptor.cxx b/connectivity/source/sdbcx/VDescriptor.cxx new file mode 100644 index 000000000..8a32a1b58 --- /dev/null +++ b/connectivity/source/sdbcx/VDescriptor.cxx @@ -0,0 +1,128 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include +#include +#include +#include +#include + +#include + +namespace connectivity::sdbcx +{ + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::beans; + + + // = ODescriptor + + + ODescriptor::ODescriptor(::cppu::OBroadcastHelper& _rBHelper, bool _bCase, bool _bNew) + :ODescriptor_PBASE(_rBHelper) + ,m_aCase(_bCase) + ,m_bNew(_bNew) + { + } + + + // css::lang::XUnoTunnel + sal_Int64 SAL_CALL ODescriptor::getSomething( const Sequence< sal_Int8 >& rId ) + { + return (isUnoTunnelId(rId)) + ? reinterpret_cast< sal_Int64 >( this ) + : 0; + } + + + namespace + { + struct ResetROAttribute + { + void operator ()( Property& _rProperty ) const + { + _rProperty.Attributes &= ~PropertyAttribute::READONLY; + } + }; + struct SetROAttribute + { + void operator ()( Property& _rProperty ) const + { + _rProperty.Attributes |= PropertyAttribute::READONLY; + } + }; + } + + + ::cppu::IPropertyArrayHelper* ODescriptor::doCreateArrayHelper() const + { + Sequence< Property > aProperties; + describeProperties( aProperties ); + + if ( isNew() ) + std::for_each( aProperties.begin(), aProperties.end(), ResetROAttribute() ); + else + std::for_each( aProperties.begin(), aProperties.end(), SetROAttribute() ); + + return new ::cppu::OPropertyArrayHelper( aProperties ); + } + + + bool ODescriptor::isNew( const Reference< XInterface >& _rxDescriptor ) + { + ODescriptor* pImplementation = comphelper::getUnoTunnelImplementation( _rxDescriptor ); + return pImplementation && pImplementation->isNew(); + } + + + Sequence< sal_Int8 > ODescriptor::getUnoTunnelId() + { + static ::cppu::OImplementationId implId; + + return implId.getImplementationId(); + } + + + Any SAL_CALL ODescriptor::queryInterface( const Type & rType ) + { + Any aRet = ::cppu::queryInterface(rType,static_cast< XUnoTunnel*> (this)); + return aRet.hasValue() ? aRet : ODescriptor_PBASE::queryInterface(rType); + } + + + void ODescriptor::setNew(bool _bNew) + { + m_bNew = _bNew; + } + + + Sequence< Type > SAL_CALL ODescriptor::getTypes( ) + { + ::cppu::OTypeCollection aTypes( cppu::UnoType::get(), + cppu::UnoType::get(), + cppu::UnoType::get(), + cppu::UnoType::get()); + return aTypes.getTypes(); + } + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/sdbcx/VGroup.cxx b/connectivity/source/sdbcx/VGroup.cxx new file mode 100644 index 000000000..ed11a6175 --- /dev/null +++ b/connectivity/source/sdbcx/VGroup.cxx @@ -0,0 +1,166 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + + +#include +#include +#include + + +using namespace ::connectivity::sdbcx; +using namespace ::connectivity; +using namespace ::dbtools; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::beans; + +IMPLEMENT_SERVICE_INFO(OGroup,"com.sun.star.sdbcx.VGroup","com.sun.star.sdbcx.Group"); + +OGroup::OGroup(bool _bCase) : OGroup_BASE(m_aMutex) + , ODescriptor(OGroup_BASE::rBHelper,_bCase) +{ +} + +OGroup::OGroup(const OUString& Name, bool _bCase) : OGroup_BASE(m_aMutex) + ,ODescriptor(OGroup_BASE::rBHelper,_bCase) +{ + m_Name = Name; +} + +OGroup::~OGroup() +{ +} + +Any SAL_CALL OGroup::queryInterface( const Type & rType ) +{ + Any aRet = ODescriptor::queryInterface( rType); + return aRet.hasValue() ? aRet : OGroup_BASE::queryInterface( rType); +} + +Sequence< Type > SAL_CALL OGroup::getTypes( ) +{ + return ::comphelper::concatSequences(ODescriptor::getTypes(),OGroup_BASE::getTypes()); +} + +void OGroup::disposing() +{ + OPropertySetHelper::disposing(); + + ::osl::MutexGuard aGuard(m_aMutex); + + if(m_pUsers) + m_pUsers->disposing(); +} + +::cppu::IPropertyArrayHelper* OGroup::createArrayHelper( ) const +{ + Sequence< Property > aProps; + describeProperties(aProps); + return new ::cppu::OPropertyArrayHelper(aProps); +} + +::cppu::IPropertyArrayHelper & OGroup::getInfoHelper() +{ + return *getArrayHelper(); +} + +Reference< XNameAccess > SAL_CALL OGroup::getUsers( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OGroup_BASE::rBHelper.bDisposed); + + try + { + if ( !m_pUsers ) + refreshUsers(); + } + catch( const RuntimeException& ) + { + // allowed to leave this method + throw; + } + catch( const Exception& ) + { + // allowed + } + + return m_pUsers.get(); +} + + +sal_Int32 SAL_CALL OGroup::getPrivileges( const OUString& /*objName*/, sal_Int32 /*objType*/ ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OGroup_BASE::rBHelper.bDisposed); + + return 0; +} + +sal_Int32 SAL_CALL OGroup::getGrantablePrivileges( const OUString& /*objName*/, sal_Int32 /*objType*/ ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OGroup_BASE::rBHelper.bDisposed); + + return 0; +} + +void SAL_CALL OGroup::grantPrivileges( const OUString& /*objName*/, sal_Int32 /*objType*/, sal_Int32 /*objPrivileges*/ ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OGroup_BASE::rBHelper.bDisposed); + throwFeatureNotImplementedSQLException( "XAuthorizable::grantPrivileges", *this ); +} + +void SAL_CALL OGroup::revokePrivileges( const OUString& /*objName*/, sal_Int32 /*objType*/, sal_Int32 /*objPrivileges*/ ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OGroup_BASE::rBHelper.bDisposed); + throwFeatureNotImplementedSQLException( "XAuthorizable::revokePrivileges", *this ); +} + +css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL OGroup::getPropertySetInfo( ) +{ + return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper()); +} + +OUString SAL_CALL OGroup::getName( ) +{ + return m_Name; +} + +void SAL_CALL OGroup::setName( const OUString& /*aName*/ ) +{ + throwFeatureNotImplementedRuntimeException( "XNamed::setName", *this ); +} + +// XInterface +void SAL_CALL OGroup::acquire() throw() +{ + OGroup_BASE::acquire(); +} + +void SAL_CALL OGroup::release() throw() +{ + OGroup_BASE::release(); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/sdbcx/VIndex.cxx b/connectivity/source/sdbcx/VIndex.cxx new file mode 100644 index 000000000..1649ff83a --- /dev/null +++ b/connectivity/source/sdbcx/VIndex.cxx @@ -0,0 +1,199 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::connectivity; +using namespace ::dbtools; +using namespace ::connectivity::sdbcx; +using namespace ::cppu; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::sdbcx; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::lang; + + +OUString SAL_CALL OIndex::getImplementationName( ) +{ + if(isNew()) + return "com.sun.star.sdbcx.VIndexDescriptor"; + return "com.sun.star.sdbcx.VIndex"; +} + +css::uno::Sequence< OUString > SAL_CALL OIndex::getSupportedServiceNames( ) +{ + return { isNew()?OUString("com.sun.star.sdbcx.IndexDescriptor"):OUString("com.sun.star.sdbcx.Index") }; +} + +sal_Bool SAL_CALL OIndex::supportsService( const OUString& _rServiceName ) +{ + return cppu::supportsService(this, _rServiceName); +} + +OIndex::OIndex(bool _bCase) : ODescriptor_BASE(m_aMutex) + , ODescriptor(ODescriptor_BASE::rBHelper,_bCase,true) + ,m_IsUnique(false) + ,m_IsPrimaryKeyIndex(false) + ,m_IsClustered(false) +{ +} + +OIndex::OIndex( const OUString& Name, + const OUString& Catalog, + bool _isUnique, + bool _isPrimaryKeyIndex, + bool _isClustered, + bool _bCase) : ODescriptor_BASE(m_aMutex) + ,ODescriptor(ODescriptor_BASE::rBHelper, _bCase) + ,m_Catalog(Catalog) + ,m_IsUnique(_isUnique) + ,m_IsPrimaryKeyIndex(_isPrimaryKeyIndex) + ,m_IsClustered(_isClustered) +{ + m_Name = Name; +} + +OIndex::~OIndex( ) +{ +} + +::cppu::IPropertyArrayHelper* OIndex::createArrayHelper( sal_Int32 /*_nId*/ ) const +{ + return doCreateArrayHelper(); +} + +::cppu::IPropertyArrayHelper& SAL_CALL OIndex::getInfoHelper() +{ + return *OIndex_PROP::getArrayHelper(isNew() ? 1 : 0); +} + +Any SAL_CALL OIndex::queryInterface( const Type & rType ) +{ + Any aRet = ODescriptor::queryInterface( rType); + if(!aRet.hasValue()) + { + if(!isNew()) + aRet = OIndex_BASE::queryInterface(rType); + if(!aRet.hasValue()) + aRet = ODescriptor_BASE::queryInterface( rType); + } + return aRet; +} + +Sequence< Type > SAL_CALL OIndex::getTypes( ) +{ + if(isNew()) + return ::comphelper::concatSequences(ODescriptor::getTypes(),ODescriptor_BASE::getTypes()); + return ::comphelper::concatSequences(ODescriptor::getTypes(),ODescriptor_BASE::getTypes(),OIndex_BASE::getTypes()); +} + +void OIndex::construct() +{ + ODescriptor::construct(); + + sal_Int32 nAttrib = isNew() ? 0 : PropertyAttribute::READONLY; + + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CATALOG), PROPERTY_ID_CATALOG, nAttrib,&m_Catalog, ::cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISUNIQUE), PROPERTY_ID_ISUNIQUE, nAttrib,&m_IsUnique, cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISPRIMARYKEYINDEX),PROPERTY_ID_ISPRIMARYKEYINDEX, nAttrib,&m_IsPrimaryKeyIndex, cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCLUSTERED), PROPERTY_ID_ISCLUSTERED, nAttrib,&m_IsClustered, cppu::UnoType::get()); +} + +void OIndex::disposing() +{ + OPropertySetHelper::disposing(); + + ::osl::MutexGuard aGuard(m_aMutex); + + if(m_pColumns) + m_pColumns->disposing(); +} + +Reference< css::container::XNameAccess > SAL_CALL OIndex::getColumns( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(ODescriptor_BASE::rBHelper.bDisposed); + + try + { + if ( !m_pColumns ) + refreshColumns(); + } + catch( const RuntimeException& ) + { + // allowed to leave this method + throw; + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "connectivity.commontools", "OIndex::getColumns" ); + } + + return m_pColumns.get(); +} + +Reference< XPropertySet > SAL_CALL OIndex::createDataDescriptor( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(ODescriptor_BASE::rBHelper.bDisposed); + + + return this; +} + +css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL OIndex::getPropertySetInfo( ) +{ + return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper()); +} + +OUString SAL_CALL OIndex::getName( ) +{ + return m_Name; +} + +void SAL_CALL OIndex::setName( const OUString& /*aName*/ ) +{ +} + +// XInterface +void SAL_CALL OIndex::acquire() throw() +{ + ODescriptor_BASE::acquire(); +} + +void SAL_CALL OIndex::release() throw() +{ + ODescriptor_BASE::release(); +} + +void OIndex::refreshColumns() +{ +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/sdbcx/VIndexColumn.cxx b/connectivity/source/sdbcx/VIndexColumn.cxx new file mode 100644 index 000000000..edd1ea93e --- /dev/null +++ b/connectivity/source/sdbcx/VIndexColumn.cxx @@ -0,0 +1,102 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include +#include +#include +#include + +using namespace connectivity; +using namespace connectivity::sdbcx; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::uno; + +OUString SAL_CALL OIndexColumn::getImplementationName( ) +{ + if(isNew()) + return "com.sun.star.sdbcx.VIndexColumnDescriptor"; + return "com.sun.star.sdbcx.VIndexColumn"; +} + +css::uno::Sequence< OUString > SAL_CALL OIndexColumn::getSupportedServiceNames( ) +{ + return { isNew()?OUString("com.sun.star.sdbcx.IndexColumnDescriptor"):OUString("com.sun.star.sdbcx.IndexColumn") }; +} + +sal_Bool SAL_CALL OIndexColumn::supportsService( const OUString& _rServiceName ) +{ + return cppu::supportsService(this, _rServiceName); +} + +OIndexColumn::OIndexColumn(bool _bCase) : OColumn(_bCase), m_IsAscending(true) +{ + construct(); +} + + +OIndexColumn::OIndexColumn( bool IsAscending, + const OUString& Name, + const OUString& TypeName, + const OUString& DefaultValue, + sal_Int32 IsNullable, + sal_Int32 Precision, + sal_Int32 Scale, + sal_Int32 Type, + bool _bCase, + const OUString& CatalogName, + const OUString& SchemaName, + const OUString& TableName + ) : OColumn(Name, + TypeName, + DefaultValue, + OUString(), + IsNullable, + Precision, + Scale, + Type, + false/*IsAutoIncrement*/, + false/*IsRowVersion*/, + false/*IsCurrency*/, + _bCase, + CatalogName, + SchemaName, + TableName) + , m_IsAscending(IsAscending) +{ + construct(); +} + +::cppu::IPropertyArrayHelper* OIndexColumn::createArrayHelper( sal_Int32 /*_nId*/ ) const +{ + return doCreateArrayHelper(); +} + +::cppu::IPropertyArrayHelper& SAL_CALL OIndexColumn::getInfoHelper() +{ + return *OIndexColumn_PROP::getArrayHelper(isNew() ? 1 : 0); +} + +void OIndexColumn::construct() +{ + sal_Int32 nAttrib = isNew() ? 0 : PropertyAttribute::READONLY; + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISASCENDING), PROPERTY_ID_ISASCENDING, nAttrib,&m_IsAscending, cppu::UnoType::get()); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/sdbcx/VKey.cxx b/connectivity/source/sdbcx/VKey.cxx new file mode 100644 index 000000000..33e9340b5 --- /dev/null +++ b/connectivity/source/sdbcx/VKey.cxx @@ -0,0 +1,202 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include +#include +#include +#include +#include +#include +#include + +using namespace connectivity; +using namespace connectivity::sdbcx; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::sdbcx; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::lang; + + +OUString SAL_CALL OKey::getImplementationName( ) +{ + if(isNew()) + return "com.sun.star.sdbcx.VKeyDescriptor"; + return "com.sun.star.sdbcx.VKey"; +} + +css::uno::Sequence< OUString > SAL_CALL OKey::getSupportedServiceNames( ) +{ + return { isNew()?OUString("com.sun.star.sdbcx.KeyDescriptor"):OUString("com.sun.star.sdbcx.Key") }; +} + +sal_Bool SAL_CALL OKey::supportsService( const OUString& _rServiceName ) +{ + return cppu::supportsService(this, _rServiceName); +} + +OKey::OKey(bool _bCase) : ODescriptor_BASE(m_aMutex) + , ODescriptor(ODescriptor_BASE::rBHelper, _bCase, true) + , m_aProps(std::make_shared()) +{ +} + +OKey::OKey(const OUString& Name,const std::shared_ptr& _rProps, bool _bCase) +: ODescriptor_BASE(m_aMutex) + ,ODescriptor(ODescriptor_BASE::rBHelper, _bCase) + ,m_aProps(_rProps) +{ + m_Name = Name; +} +//OKey::OKey( const OUString& _Name, +// const OUString& _ReferencedTable, +// sal_Int32 _Type, +// sal_Int32 _UpdateRule, +// sal_Int32 _DeleteRule, +// sal_Bool _bCase) : ODescriptor_BASE(m_aMutex) +// ,ODescriptor(ODescriptor_BASE::rBHelper,_bCase) +// ,m_ReferencedTable(_ReferencedTable) +// ,m_Type(_Type) +// ,m_UpdateRule(_UpdateRule) +// ,m_DeleteRule(_DeleteRule) +// ,m_pColumns(NULL) +//{ +// m_Name = _Name; +//} + +OKey::~OKey( ) +{ +} + +Any SAL_CALL OKey::queryInterface( const Type & rType ) +{ + Any aRet = ODescriptor::queryInterface( rType); + if(!aRet.hasValue()) + { + if(!isNew()) + aRet = OKey_BASE::queryInterface(rType); + if(!aRet.hasValue()) + aRet = ODescriptor_BASE::queryInterface( rType); + } + + return aRet; +} + +Sequence< Type > SAL_CALL OKey::getTypes( ) +{ + if(isNew()) + return ::comphelper::concatSequences(ODescriptor::getTypes(),ODescriptor_BASE::getTypes()); + + return ::comphelper::concatSequences(ODescriptor::getTypes(),ODescriptor_BASE::getTypes(),OKey_BASE::getTypes()); +} + +void OKey::construct() +{ + ODescriptor::construct(); + + sal_Int32 nAttrib = isNew() ? 0 : PropertyAttribute::READONLY; + + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_REFERENCEDTABLE), PROPERTY_ID_REFERENCEDTABLE, nAttrib,&m_aProps->m_ReferencedTable, ::cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE), PROPERTY_ID_TYPE, nAttrib,&m_aProps->m_Type, ::cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_UPDATERULE), PROPERTY_ID_UPDATERULE, nAttrib,&m_aProps->m_UpdateRule, ::cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DELETERULE), PROPERTY_ID_DELETERULE, nAttrib,&m_aProps->m_DeleteRule, ::cppu::UnoType::get()); +} + +void SAL_CALL OKey::disposing() +{ + OPropertySetHelper::disposing(); + + ::osl::MutexGuard aGuard(m_aMutex); + + if(m_pColumns) + m_pColumns->disposing(); + + ODescriptor_BASE::disposing(); +} + +::cppu::IPropertyArrayHelper* OKey::createArrayHelper( sal_Int32 /*_nId*/ ) const +{ + return doCreateArrayHelper(); +} + +::cppu::IPropertyArrayHelper & OKey::getInfoHelper() +{ + return *getArrayHelper(isNew() ? 1 : 0); +} + +Reference< css::container::XNameAccess > SAL_CALL OKey::getColumns( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(ODescriptor_BASE::rBHelper.bDisposed); + + try + { + if ( !m_pColumns ) + refreshColumns(); + } + catch( const RuntimeException& ) + { + // allowed to leave this method + throw; + } + catch( const Exception& ) + { + // allowed + } + + return m_pColumns.get(); +} + +Reference< XPropertySet > SAL_CALL OKey::createDataDescriptor( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(ODescriptor_BASE::rBHelper.bDisposed); + + + return this; +} + +css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL OKey::getPropertySetInfo( ) +{ + return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper()); +} + +OUString SAL_CALL OKey::getName( ) +{ + return m_Name; +} + +void SAL_CALL OKey::setName( const OUString& /*aName*/ ) +{ +} + +// XInterface +void SAL_CALL OKey::acquire() throw() +{ + ODescriptor_BASE::acquire(); +} + +void SAL_CALL OKey::release() throw() +{ + ODescriptor_BASE::release(); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/sdbcx/VKeyColumn.cxx b/connectivity/source/sdbcx/VKeyColumn.cxx new file mode 100644 index 000000000..b6f69e65c --- /dev/null +++ b/connectivity/source/sdbcx/VKeyColumn.cxx @@ -0,0 +1,106 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include +#include +#include +#include + +using namespace connectivity; +using namespace connectivity::sdbcx; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::uno; +using namespace cppu; + +OUString SAL_CALL OKeyColumn::getImplementationName( ) +{ + if(isNew()) + return "com.sun.star.sdbcx.VKeyColumnDescriptor"; + return "com.sun.star.sdbcx.VKeyColumn"; +} + +css::uno::Sequence< OUString > SAL_CALL OKeyColumn::getSupportedServiceNames( ) +{ + return { isNew()?OUString("com.sun.star.sdbcx.KeyColumnDescriptor"):OUString("com.sun.star.sdbcx.KeyColumn") }; +} + +sal_Bool SAL_CALL OKeyColumn::supportsService( const OUString& _rServiceName ) +{ + return cppu::supportsService(this, _rServiceName); +} + +OKeyColumn::OKeyColumn(bool _bCase) : OColumn(_bCase) +{ + construct(); +} + +OKeyColumn::OKeyColumn( const OUString& ReferencedColumn, + const OUString& Name, + const OUString& TypeName, + const OUString& DefaultValue, + sal_Int32 IsNullable, + sal_Int32 Precision, + sal_Int32 Scale, + sal_Int32 Type, + bool _bCase, + const OUString& CatalogName, + const OUString& SchemaName, + const OUString& TableName + ) : OColumn(Name, + TypeName, + DefaultValue, + OUString(), + IsNullable, + Precision, + Scale, + Type, + false/*IsAutoIncrement*/, + false/*IsRowVersion*/, + false/*IsCurrency*/, + _bCase, + CatalogName, + SchemaName, + TableName) + , m_ReferencedColumn(ReferencedColumn) +{ + construct(); +} + +OKeyColumn::~OKeyColumn() +{ +} + +::cppu::IPropertyArrayHelper* OKeyColumn::createArrayHelper( sal_Int32 /*_nId*/ ) const +{ + return doCreateArrayHelper(); +} + +::cppu::IPropertyArrayHelper& SAL_CALL OKeyColumn::getInfoHelper() +{ + return *OKeyColumn_PROP::getArrayHelper(isNew() ? 1 : 0); +} + +void OKeyColumn::construct() +{ + sal_Int32 nAttrib = isNew() ? 0 : PropertyAttribute::READONLY; + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RELATEDCOLUMN), PROPERTY_ID_RELATEDCOLUMN, nAttrib,&m_ReferencedColumn, ::cppu::UnoType::get()); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/sdbcx/VTable.cxx b/connectivity/source/sdbcx/VTable.cxx new file mode 100644 index 000000000..90c742782 --- /dev/null +++ b/connectivity/source/sdbcx/VTable.cxx @@ -0,0 +1,304 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::connectivity; +using namespace ::connectivity::sdbcx; +using namespace ::dbtools; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::sdbcx; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::lang; + + +OUString SAL_CALL OTable::getImplementationName( ) +{ + if(isNew()) + return "com.sun.star.sdbcx.VTableDescriptor"; + return "com.sun.star.sdbcx.Table"; +} + + +css::uno::Sequence< OUString > SAL_CALL OTable::getSupportedServiceNames( ) +{ + return { isNew()?OUString("com.sun.star.sdbcx.TableDescriptor"):OUString("com.sun.star.sdbcx.Table") }; +} + +sal_Bool SAL_CALL OTable::supportsService( const OUString& _rServiceName ) +{ + return cppu::supportsService(this, _rServiceName); +} + +OTable::OTable(OCollection* _pTables, + bool _bCase) + : OTableDescriptor_BASE(m_aMutex) + ,ODescriptor(OTableDescriptor_BASE::rBHelper,_bCase,true) + ,m_pTables(_pTables) +{ +} + +OTable::OTable( OCollection* _pTables, + bool _bCase, + const OUString& Name, const OUString& Type, + const OUString& Description,const OUString& SchemaName, + const OUString& CatalogName) : OTableDescriptor_BASE(m_aMutex) + ,ODescriptor(OTableDescriptor_BASE::rBHelper,_bCase) + ,m_CatalogName(CatalogName) + ,m_SchemaName(SchemaName) + ,m_Description(Description) + ,m_Type(Type) + ,m_pTables(_pTables) +{ + m_Name = Name; +} + +OTable::~OTable() +{ +} + +void OTable::construct() +{ + ODescriptor::construct(); + + sal_Int32 nAttrib = isNew() ? 0 : PropertyAttribute::READONLY; + + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CATALOGNAME), PROPERTY_ID_CATALOGNAME,nAttrib,&m_CatalogName, ::cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCHEMANAME), PROPERTY_ID_SCHEMANAME, nAttrib,&m_SchemaName, ::cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DESCRIPTION), PROPERTY_ID_DESCRIPTION,nAttrib,&m_Description, ::cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE), PROPERTY_ID_TYPE, nAttrib,&m_Type, ::cppu::UnoType::get()); +} + +void SAL_CALL OTable::acquire() throw() +{ + OTableDescriptor_BASE::acquire(); +} + +void SAL_CALL OTable::release() throw() +{ + OTableDescriptor_BASE::release(); +} + + +Any SAL_CALL OTable::queryInterface( const Type & rType ) +{ + Any aRet = ODescriptor::queryInterface( rType); + if(!aRet.hasValue()) + { + if(!isNew()) + aRet = OTable_BASE::queryInterface( rType); + if(isNew() && (rType == cppu::UnoType::get())) + return Any(); + if(!aRet.hasValue()) + aRet = OTableDescriptor_BASE::queryInterface( rType); + } + return aRet; +} + +Sequence< Type > SAL_CALL OTable::getTypes( ) +{ + if(isNew()) + return ::comphelper::concatSequences(ODescriptor::getTypes(),OTableDescriptor_BASE::getTypes()); + return ::comphelper::concatSequences(ODescriptor::getTypes(),OTableDescriptor_BASE::getTypes(),OTable_BASE::getTypes()); +} + +void SAL_CALL OTable::disposing() +{ + ODescriptor::disposing(); + + ::osl::MutexGuard aGuard(m_aMutex); + + if(m_xKeys) + m_xKeys->disposing(); + if(m_xColumns) + m_xColumns->disposing(); + if(m_xIndexes) + m_xIndexes->disposing(); + + m_pTables = nullptr; +} + +// XColumnsSupplier +Reference< XNameAccess > SAL_CALL OTable::getColumns( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed); + + try + { + if ( !m_xColumns ) + refreshColumns(); + } + catch( const RuntimeException& ) + { + // allowed to leave this method + throw; + } + catch( const Exception& ) + { + // allowed + } + + return m_xColumns.get(); +} + + +// XKeysSupplier +Reference< XIndexAccess > SAL_CALL OTable::getKeys( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed); + + Reference< XIndexAccess > xKeys; + + try + { + if ( !m_xKeys ) + refreshKeys(); + xKeys = m_xKeys.get(); + } + catch( const RuntimeException& ) + { + // allowed to leave this method + throw; + } + catch( const Exception& ) + { + // allowed + } + + return xKeys; +} + +cppu::IPropertyArrayHelper* OTable::createArrayHelper( sal_Int32 /*_nId*/ ) const +{ + return doCreateArrayHelper(); +} + +cppu::IPropertyArrayHelper & OTable::getInfoHelper() +{ + return *getArrayHelper(isNew() ? 1 : 0); +} + +Reference< XPropertySet > SAL_CALL OTable::createDataDescriptor( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed); + + OTable* pTable = new OTable(m_pTables,isCaseSensitive(),m_Name,m_Type,m_Description,m_SchemaName,m_CatalogName); + pTable->setNew(true); + return pTable; +} + +// XIndexesSupplier +Reference< XNameAccess > SAL_CALL OTable::getIndexes( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed); + + try + { + if ( !m_xIndexes ) + refreshIndexes(); + } + catch( const RuntimeException& ) + { + // allowed to leave this method + throw; + } + catch( const Exception& ) + { + // allowed + } + + return m_xIndexes.get(); +} + +// XRename +void SAL_CALL OTable::rename( const OUString& newName ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed); + + const OUString sOldComposedName = getName(); + const Reference< XDatabaseMetaData> xMetaData = getMetaData(); + if ( xMetaData.is() ) + ::dbtools::qualifiedNameComponents(xMetaData,newName,m_CatalogName,m_SchemaName,m_Name,::dbtools::EComposeRule::InDataManipulation); + else + m_Name = newName; + + m_pTables->renameObject(sOldComposedName,newName); +} + +Reference< XDatabaseMetaData> OTable::getMetaData() const +{ + return nullptr; +} + +// XAlterTable +void SAL_CALL OTable::alterColumnByName( const OUString& /*colName*/, const Reference< XPropertySet >& /*descriptor*/ ) +{ + throwFeatureNotImplementedSQLException( "XAlterTable::alterColumnByName", *this ); +} + +void SAL_CALL OTable::alterColumnByIndex( sal_Int32 /*index*/, const Reference< XPropertySet >& /*descriptor*/ ) +{ + throwFeatureNotImplementedSQLException( "XAlterTable::alterColumnByIndex", *this ); +} + +css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL OTable::getPropertySetInfo( ) +{ + return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper()); +} + +OUString SAL_CALL OTable::getName() +{ + // this is only correct for tables who haven't a schema or catalog name + OSL_ENSURE(m_CatalogName.isEmpty(),"getName(): forgot to override getName()!"); + OSL_ENSURE(m_SchemaName.isEmpty(),"getName(): forgot to override getName()!"); + return m_Name; +} + +void SAL_CALL OTable::setName( const OUString& /*aName*/ ) +{ +} + +void OTable::refreshColumns() +{ +} + +void OTable::refreshKeys() +{ +} + +void OTable::refreshIndexes() +{ +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/sdbcx/VUser.cxx b/connectivity/source/sdbcx/VUser.cxx new file mode 100644 index 000000000..9cecd7dfd --- /dev/null +++ b/connectivity/source/sdbcx/VUser.cxx @@ -0,0 +1,180 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + + +#include +#include +#include +#include + + +using namespace connectivity; +using namespace connectivity::sdbcx; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::lang; + +IMPLEMENT_SERVICE_INFO(OUser,"com.sun.star.sdbcx.VUser","com.sun.star.sdbcx.User"); + +OUser::OUser(bool _bCase) : OUser_BASE(m_aMutex) + , ODescriptor(OUser_BASE::rBHelper,_bCase,true) +{ +} + +OUser::OUser(const OUString& Name, bool _bCase) : OUser_BASE(m_aMutex) + ,ODescriptor(OUser_BASE::rBHelper,_bCase) +{ + m_Name = Name; +} + +OUser::~OUser( ) +{ +} + +void OUser::disposing() +{ + OPropertySetHelper::disposing(); + ::osl::MutexGuard aGuard(m_aMutex); + if(m_pGroups) + m_pGroups->disposing(); +} + +Any SAL_CALL OUser::queryInterface( const Type & rType ) +{ + Any aRet = ODescriptor::queryInterface( rType); + return aRet.hasValue() ? aRet : OUser_BASE::queryInterface( rType); +} + +Sequence< Type > SAL_CALL OUser::getTypes( ) +{ + return ::comphelper::concatSequences(ODescriptor::getTypes(),OUser_BASE::getTypes()); +} + +::cppu::IPropertyArrayHelper* OUser::createArrayHelper( ) const +{ + Sequence< Property > aProps; + describeProperties(aProps); + return new ::cppu::OPropertyArrayHelper(aProps); + +} + +::cppu::IPropertyArrayHelper & OUser::getInfoHelper() +{ + return *getArrayHelper(); +} + +// XUser +void SAL_CALL OUser::changePassword( const OUString& /*objPassword*/, const OUString& /*newPassword*/ ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OUser_BASE::rBHelper.bDisposed); + ::dbtools::throwFeatureNotImplementedSQLException( "XUser::changePassword", *this ); +} + +// XGroupsSupplier +Reference< XNameAccess > SAL_CALL OUser::getGroups( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OUser_BASE::rBHelper.bDisposed); + + try + { + if ( !m_pGroups ) + refreshGroups(); + } + catch( const RuntimeException& ) + { + // allowed to leave this method + throw; + } + catch( const Exception& ) + { + // allowed + } + + return m_pGroups.get(); +} + + +SAL_WNOUNREACHABLE_CODE_PUSH + +sal_Int32 SAL_CALL OUser::getPrivileges( const OUString& /*objName*/, sal_Int32 /*objType*/ ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OUser_BASE::rBHelper.bDisposed); + ::dbtools::throwFeatureNotImplementedSQLException( "XAuthorizable::changePassword", *this ); + return 0; +} + +sal_Int32 SAL_CALL OUser::getGrantablePrivileges( const OUString& /*objName*/, sal_Int32 /*objType*/ ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OUser_BASE::rBHelper.bDisposed); + ::dbtools::throwFeatureNotImplementedSQLException( "XAuthorizable::getGrantablePrivileges", *this ); + return 0; +} + +SAL_WNOUNREACHABLE_CODE_POP + + +void SAL_CALL OUser::grantPrivileges( const OUString& /*objName*/, sal_Int32 /*objType*/, sal_Int32 /*objPrivileges*/ ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OUser_BASE::rBHelper.bDisposed); + ::dbtools::throwFeatureNotImplementedSQLException( "XAuthorizable::grantPrivileges", *this ); +} + +void SAL_CALL OUser::revokePrivileges( const OUString& /*objName*/, sal_Int32 /*objType*/, sal_Int32 /*objPrivileges*/ ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(OUser_BASE::rBHelper.bDisposed); + ::dbtools::throwFeatureNotImplementedSQLException( "XAuthorizable::revokePrivileges", *this ); +} + +css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL OUser::getPropertySetInfo( ) +{ + return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper()); +} + +OUString SAL_CALL OUser::getName( ) +{ + return m_Name; +} + +void SAL_CALL OUser::setName( const OUString& /*aName*/ ) +{ + OSL_FAIL( "OUser::setName: not implemented!" ); + // not allowed to throw an SQLException here ... +} + +// XInterface +void SAL_CALL OUser::acquire() throw() +{ + OUser_BASE::acquire(); +} + +void SAL_CALL OUser::release() throw() +{ + OUser_BASE::release(); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/sdbcx/VView.cxx b/connectivity/source/sdbcx/VView.cxx new file mode 100644 index 000000000..317e985b5 --- /dev/null +++ b/connectivity/source/sdbcx/VView.cxx @@ -0,0 +1,132 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include +#include +#include +#include +#include + + +using namespace connectivity; +using namespace connectivity::sdbcx; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::sdbcx; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::lang; + +IMPLEMENT_SERVICE_INFO(OView,"com.sun.star.sdbcx.VView","com.sun.star.sdbcx.View"); + +OView::OView(bool _bCase, + const OUString& Name, + const css::uno::Reference< css::sdbc::XDatabaseMetaData >& _xMetaData, + const OUString& Command, + const OUString& SchemaName, + const OUString& CatalogName) : ODescriptor(::comphelper::OMutexAndBroadcastHelper::m_aBHelper,_bCase) + ,m_CatalogName(CatalogName) + ,m_SchemaName(SchemaName) + ,m_Command(Command) + ,m_CheckOption(0) + ,m_xMetaData(_xMetaData) + +{ + m_Name = Name; + construct(); +} + +OView::OView(bool _bCase, const css::uno::Reference< css::sdbc::XDatabaseMetaData >& _xMetaData) + : ODescriptor(::comphelper::OMutexAndBroadcastHelper::m_aBHelper, _bCase, true) + ,m_xMetaData(_xMetaData) +{ + construct(); +} + +OView::~OView() +{ +} + +void OView::construct() +{ + ODescriptor::construct(); + + sal_Int32 nAttrib = isNew() ? 0 : PropertyAttribute::READONLY; + + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CATALOGNAME), PROPERTY_ID_CATALOGNAME,nAttrib,&m_CatalogName, ::cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCHEMANAME), PROPERTY_ID_SCHEMANAME, nAttrib,&m_SchemaName, ::cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_COMMAND), PROPERTY_ID_COMMAND, nAttrib,&m_Command, ::cppu::UnoType::get()); + registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CHECKOPTION), PROPERTY_ID_CHECKOPTION,nAttrib,&m_CheckOption, ::cppu::UnoType::get()); +} + +Sequence< Type > SAL_CALL OView::getTypes( ) +{ + return ::comphelper::concatSequences(ODescriptor::getTypes(),OView_BASE::getTypes()); +} + +Any SAL_CALL OView::queryInterface( const Type & rType ) +{ + Any aRet = OView_BASE::queryInterface( rType); + return aRet.hasValue() ? aRet : ODescriptor::queryInterface( rType); +} + +::cppu::IPropertyArrayHelper* OView::createArrayHelper( sal_Int32 /*_nId*/ ) const +{ + return doCreateArrayHelper(); +} + +::cppu::IPropertyArrayHelper & OView::getInfoHelper() +{ + return *getArrayHelper(isNew() ? 1 : 0); +} + +OUString SAL_CALL OView::getName() +{ + OUString sComposedName; + if(m_xMetaData.is()) + sComposedName = ::dbtools::composeTableName( m_xMetaData, m_CatalogName, m_SchemaName, m_Name, false, ::dbtools::EComposeRule::InDataManipulation ); + else + { + Any aValue; + getFastPropertyValue(aValue,PROPERTY_ID_NAME); + aValue >>= sComposedName; + } + return sComposedName; +} + +css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL OView::getPropertySetInfo( ) +{ + return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper()); +} + +void SAL_CALL OView::setName( const OUString& ) +{ +} + +void SAL_CALL OView::acquire() throw() +{ + OView_BASE::acquire(); +} + +void SAL_CALL OView::release() throw() +{ + OView_BASE::release(); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3