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