connectivity/source/sdbcx/VTable.cxx

   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 <connectivity/sdbcx/VTable.hxx>
  21 #include <com/sun/star/lang/DisposedException.hpp>
  22 #include <com/sun/star/beans/PropertyAttribute.hpp>
  23 #include <connectivity/sdbcx/VIndex.hxx>
  24 #include <comphelper/sequence.hxx>
  25 #include <connectivity/sdbcx/VCollection.hxx>
  26 #include <TConnection.hxx>
  27 #include <connectivity/sdbcx/VColumn.hxx>
  28 #include <connectivity/sdbcx/VKey.hxx>
  29 #include <connectivity/dbtools.hxx>
  30 #include <connectivity/dbexception.hxx>
  31 #include <cppuhelper/supportsservice.hxx>
  32
  33 using namespace ::connectivity;
  34 using namespace ::connectivity::sdbcx;
  35 using namespace ::dbtools;
  36 using namespace ::com::sun::star::beans;
  37 using namespace ::com::sun::star::uno;
  38 using namespace ::com::sun::star::sdbc;
  39 using namespace ::com::sun::star::sdbcx;
  40 using namespace ::com::sun::star::container;
  41 using namespace ::com::sun::star::lang;
  42
  43
  44 OUString SAL_CALL OTable::getImplementationName(  )
  45 {
  46     if(isNew())
  47         return OUString("com.sun.star.sdbcx.VTableDescriptor");
  48     return OUString("com.sun.star.sdbcx.Table");
  49 }
  50
  51
  52 css::uno::Sequence< OUString > SAL_CALL OTable::getSupportedServiceNames(  )
  53 {
  54     css::uno::Sequence< OUString > aSupported(1);
  55     if(isNew())
  56         aSupported[0] = "com.sun.star.sdbcx.TableDescriptor";
  57     else
  58         aSupported[0] = "com.sun.star.sdbcx.Table";
  59
  60     return aSupported;
  61 }
  62
  63 sal_Bool SAL_CALL OTable::supportsService( const OUString& _rServiceName )
  64 {
  65     return cppu::supportsService(this, _rServiceName);
  66 }
  67
  68 OTable::OTable(OCollection* _pTables,
  69                bool _bCase)
  70                : OTableDescriptor_BASE(m_aMutex)
  71                 ,ODescriptor(OTableDescriptor_BASE::rBHelper,_bCase,true)
  72                 ,m_pTables(_pTables)
  73 {
  74 }
  75
  76 OTable::OTable( OCollection*    _pTables,
  77                 bool            _bCase,
  78                 const OUString& Name,       const OUString& Type,
  79                 const OUString& Description,const OUString& SchemaName,
  80                 const OUString& CatalogName) :  OTableDescriptor_BASE(m_aMutex)
  81                 ,ODescriptor(OTableDescriptor_BASE::rBHelper,_bCase)
  82                 ,m_CatalogName(CatalogName)
  83                 ,m_SchemaName(SchemaName)
  84                 ,m_Description(Description)
  85                 ,m_Type(Type)
  86                 ,m_pTables(_pTables)
  87 {
  88     m_Name = Name;
  89 }
  90
  91 OTable::~OTable()
  92 {
  93 }
  94
  95 void OTable::construct()
  96 {
  97     ODescriptor::construct();
  98
  99     sal_Int32 nAttrib = isNew() ? 0 : PropertyAttribute::READONLY;
 100
 101     registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CATALOGNAME),     PROPERTY_ID_CATALOGNAME,nAttrib,&m_CatalogName, ::cppu::UnoType<OUString>::get());
 102     registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCHEMANAME),      PROPERTY_ID_SCHEMANAME, nAttrib,&m_SchemaName,  ::cppu::UnoType<OUString>::get());
 103     registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DESCRIPTION),     PROPERTY_ID_DESCRIPTION,nAttrib,&m_Description, ::cppu::UnoType<OUString>::get());
 104     registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE),            PROPERTY_ID_TYPE,       nAttrib,&m_Type,        ::cppu::UnoType<OUString>::get());
 105 }
 106
 107 void SAL_CALL OTable::acquire() throw()
 108 {
 109     OTableDescriptor_BASE::acquire();
 110 }
 111
 112 void SAL_CALL OTable::release() throw()
 113 {
 114     OTableDescriptor_BASE::release();
 115 }
 116
 117
 118 Any SAL_CALL OTable::queryInterface( const Type & rType )
 119 {
 120     Any aRet = ODescriptor::queryInterface( rType);
 121     if(!aRet.hasValue())
 122     {
 123         if(!isNew())
 124             aRet = OTable_BASE::queryInterface( rType);
 125         if(isNew() && (rType == cppu::UnoType<XIndexesSupplier>::get()))
 126             return Any();
 127         if(!aRet.hasValue())
 128             aRet = OTableDescriptor_BASE::queryInterface( rType);
 129     }
 130     return aRet;
 131 }
 132
 133 Sequence< Type > SAL_CALL OTable::getTypes(  )
 134 {
 135     if(isNew())
 136         return ::comphelper::concatSequences(ODescriptor::getTypes(),OTableDescriptor_BASE::getTypes());
 137     return ::comphelper::concatSequences(ODescriptor::getTypes(),OTableDescriptor_BASE::getTypes(),OTable_BASE::getTypes());
 138 }
 139
 140 void SAL_CALL OTable::disposing()
 141 {
 142     ODescriptor::disposing();
 143
 144     ::osl::MutexGuard aGuard(m_aMutex);
 145
 146     if(m_xKeys)
 147         m_xKeys->disposing();
 148     if(m_xColumns)
 149         m_xColumns->disposing();
 150     if(m_xIndexes)
 151         m_xIndexes->disposing();
 152
 153     m_pTables = nullptr;
 154 }
 155
 156 // XColumnsSupplier
 157 Reference< XNameAccess > SAL_CALL OTable::getColumns(  )
 158 {
 159     ::osl::MutexGuard aGuard(m_aMutex);
 160     checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
 161
 162     try
 163     {
 164         if ( !m_xColumns )
 165             refreshColumns();
 166     }
 167     catch( const RuntimeException& )
 168     {
 169         // allowed to leave this method
 170         throw;
 171     }
 172     catch( const Exception& )
 173     {
 174         // allowed
 175     }
 176
 177     return m_xColumns.get();
 178 }
 179
 180
 181 // XKeysSupplier
 182 Reference< XIndexAccess > SAL_CALL OTable::getKeys(  )
 183 {
 184     ::osl::MutexGuard aGuard(m_aMutex);
 185     checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
 186
 187     Reference< XIndexAccess > xKeys;
 188
 189     try
 190     {
 191         if ( !m_xKeys )
 192             refreshKeys();
 193         xKeys = m_xKeys.get();
 194     }
 195     catch( const RuntimeException& )
 196     {
 197         // allowed to leave this method
 198         throw;
 199     }
 200     catch( const Exception& )
 201     {
 202         // allowed
 203     }
 204
 205     return xKeys;
 206 }
 207
 208 cppu::IPropertyArrayHelper* OTable::createArrayHelper( sal_Int32 /*_nId*/ ) const
 209 {
 210     return doCreateArrayHelper();
 211 }
 212
 213 cppu::IPropertyArrayHelper & OTable::getInfoHelper()
 214 {
 215     return *getArrayHelper(isNew() ? 1 : 0);
 216 }
 217
 218 Reference< XPropertySet > SAL_CALL OTable::createDataDescriptor(  )
 219 {
 220     ::osl::MutexGuard aGuard(m_aMutex);
 221     checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
 222
 223     OTable* pTable = new OTable(m_pTables,isCaseSensitive(),m_Name,m_Type,m_Description,m_SchemaName,m_CatalogName);
 224     pTable->setNew(true);
 225     return pTable;
 226 }
 227
 228 // XIndexesSupplier
 229 Reference< XNameAccess > SAL_CALL OTable::getIndexes(  )
 230 {
 231     ::osl::MutexGuard aGuard(m_aMutex);
 232     checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
 233
 234     try
 235     {
 236         if ( !m_xIndexes )
 237             refreshIndexes();
 238     }
 239     catch( const RuntimeException& )
 240     {
 241         // allowed to leave this method
 242         throw;
 243     }
 244     catch( const Exception& )
 245     {
 246         // allowed
 247     }
 248
 249     return m_xIndexes.get();
 250 }
 251
 252 // XRename
 253 void SAL_CALL OTable::rename( const OUString& newName )
 254 {
 255     ::osl::MutexGuard aGuard(m_aMutex);
 256     checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
 257
 258     const OUString sOldComposedName = getName();
 259     const Reference< XDatabaseMetaData> xMetaData = getMetaData();
 260     if ( xMetaData.is() )
 261         ::dbtools::qualifiedNameComponents(xMetaData,newName,m_CatalogName,m_SchemaName,m_Name,::dbtools::EComposeRule::InDataManipulation);
 262     else
 263         m_Name = newName;
 264
 265     m_pTables->renameObject(sOldComposedName,newName);
 266 }
 267
 268 Reference< XDatabaseMetaData> OTable::getMetaData() const
 269 {
 270     return nullptr;
 271 }
 272
 273 // XAlterTable
 274 void SAL_CALL OTable::alterColumnByName( const OUString& /*colName*/, const Reference< XPropertySet >& /*descriptor*/ )
 275 {
 276     throwFeatureNotImplementedSQLException( "XAlterTable::alterColumnByName", *this );
 277 }
 278
 279 void SAL_CALL OTable::alterColumnByIndex( sal_Int32 /*index*/, const Reference< XPropertySet >& /*descriptor*/ )
 280 {
 281     throwFeatureNotImplementedSQLException( "XAlterTable::alterColumnByIndex", *this );
 282 }
 283
 284 css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL OTable::getPropertySetInfo(  )
 285 {
 286     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 287 }
 288
 289 OUString SAL_CALL OTable::getName()
 290 {
 291     // this is only correct for tables who haven't a schema or catalog name
 292     OSL_ENSURE(m_CatalogName.isEmpty(),"getName(): forgot to override getName()!");
 293     OSL_ENSURE(m_SchemaName.isEmpty(),"getName(): forgot to override getName()!");
 294     return m_Name;
 295 }
 296
 297 void SAL_CALL OTable::setName( const OUString& /*aName*/ )
 298 {
 299 }
 300
 301 void OTable::refreshColumns()
 302 {
 303 }
 304
 305 void OTable::refreshKeys()
 306 {
 307 }
 308
 309 void OTable::refreshIndexes()
 310 {
 311 }
 312
 313
 314 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */