dbaccess/source/core/api/column.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 <ContainerMediator.hxx>
  21 #include <column.hxx>
  22 #include <strings.hrc>
  23 #include <strings.hxx>
  24 #include <core_resource.hxx>
  25 #include <stringconstants.hxx>
  26 #include <sdbcoretools.hxx>
  27
  28 #include <com/sun/star/beans/PropertyAttribute.hpp>
  29 #include <com/sun/star/sdb/tools/XTableAlteration.hpp>
  30
  31 #include <comphelper/sequence.hxx>
  32 #include <comphelper/types.hxx>
  33 #include <comphelper/uno3.hxx>
  34 #include <connectivity/TTableHelper.hxx>
  35 #include <connectivity/dbexception.hxx>
  36 #include <cppuhelper/supportsservice.hxx>
  37 #include <osl/diagnose.h>
  38
  39 using namespace dbaccess;
  40 using namespace connectivity;
  41 using namespace ::com::sun::star::sdbc;
  42 using namespace ::com::sun::star::sdbcx;
  43 using namespace ::com::sun::star::beans;
  44 using namespace ::com::sun::star::uno;
  45 using namespace ::com::sun::star::lang;
  46 using namespace ::com::sun::star::awt;
  47 using namespace ::com::sun::star::io;
  48 using namespace ::com::sun::star::container;
  49 using namespace ::com::sun::star::util;
  50 using namespace ::osl;
  51 using namespace ::comphelper;
  52 using namespace ::cppu;
  53
  54
  55 // OColumn
  56 OColumn::OColumn( const bool _bNameIsReadOnly )
  57         :OColumnBase( m_aMutex )
  58         ,::comphelper::OPropertyContainer( OColumnBase::rBHelper )
  59 {
  60
  61     registerProperty( PROPERTY_NAME, PROPERTY_ID_NAME, _bNameIsReadOnly ? PropertyAttribute::READONLY : 0,
  62         &m_sName, cppu::UnoType<decltype(m_sName)>::get() );
  63 }
  64
  65 OColumn::~OColumn()
  66 {
  67 }
  68
  69 // css::lang::XTypeProvider
  70 Sequence< Type > OColumn::getTypes()
  71 {
  72     return ::comphelper::concatSequences(
  73         OColumnBase::getTypes(),
  74         getBaseTypes()
  75     );
  76 }
  77
  78 // css::uno::XInterface
  79 IMPLEMENT_FORWARD_XINTERFACE2( OColumn, OColumnBase, ::comphelper::OPropertyContainer )
  80
  81 // css::lang::XServiceInfo
  82 OUString OColumn::getImplementationName(  )
  83 {
  84     return "com.sun.star.sdb.OColumn";
  85 }
  86
  87 sal_Bool OColumn::supportsService( const OUString& _rServiceName )
  88 {
  89     return cppu::supportsService(this, _rServiceName);
  90 }
  91
  92 Sequence< OUString > OColumn::getSupportedServiceNames(  )
  93 {
  94     return { SERVICE_SDBCX_COLUMN };
  95 }
  96
  97 // OComponentHelper
  98 void OColumn::disposing()
  99 {
 100     OPropertyContainer::disposing();
 101 }
 102
 103 // css::beans::XPropertySet
 104 Reference< XPropertySetInfo > OColumn::getPropertySetInfo()
 105 {
 106     return createPropertySetInfo( getInfoHelper() ) ;
 107 }
 108
 109 OUString SAL_CALL OColumn::getName(  )
 110 {
 111     return m_sName;
 112 }
 113
 114 void SAL_CALL OColumn::setName( const OUString& _rName )
 115 {
 116     m_sName = _rName;
 117 }
 118
 119 void OColumn::registerProperty( const OUString& _rName, sal_Int32 _nHandle, sal_Int32 _nAttributes, void* _pPointerToMember, const Type& _rMemberType )
 120 {
 121     ::comphelper::OPropertyContainer::registerProperty( _rName, _nHandle, _nAttributes, _pPointerToMember, _rMemberType );
 122 }
 123
 124 void OColumn::registerMayBeVoidProperty( const OUString& _rName, sal_Int32 _nHandle, sal_Int32 _nAttributes, Any* _pPointerToMember, const Type& _rExpectedType )
 125 {
 126     ::comphelper::OPropertyContainer::registerMayBeVoidProperty( _rName, _nHandle, _nAttributes, _pPointerToMember, _rExpectedType );
 127 }
 128
 129 // OColumns
 130
 131 OColumns::OColumns(::cppu::OWeakObject& _rParent,
 132                    ::osl::Mutex& _rMutex,
 133                    bool _bCaseSensitive,const std::vector< OUString> &_rVector,
 134                    IColumnFactory* _pColFactory,
 135                    ::connectivity::sdbcx::IRefreshableColumns* _pRefresh,
 136                    bool _bAddColumn,
 137                    bool _bDropColumn,
 138                    bool _bUseHardRef)
 139                    : OColumns_BASE(_rParent,_bCaseSensitive,_rMutex,_rVector,_bUseHardRef)
 140     ,m_pMediator(nullptr)
 141     ,m_pColFactoryImpl(_pColFactory)
 142     ,m_pRefreshColumns(_pRefresh)
 143     ,m_bInitialized(false)
 144     ,m_bAddColumn(_bAddColumn)
 145     ,m_bDropColumn(_bDropColumn)
 146 {
 147 }
 148
 149 OColumns::OColumns(::cppu::OWeakObject& _rParent, ::osl::Mutex& _rMutex,
 150         const css::uno::Reference< css::container::XNameAccess >& _rxDrvColumns,
 151         bool _bCaseSensitive,const std::vector< OUString> &_rVector,
 152         IColumnFactory* _pColFactory,
 153         ::connectivity::sdbcx::IRefreshableColumns* _pRefresh,
 154         bool _bAddColumn,
 155         bool _bDropColumn,
 156         bool _bUseHardRef)
 157        : OColumns_BASE(_rParent,_bCaseSensitive,_rMutex,_rVector,_bUseHardRef)
 158     ,m_pMediator(nullptr)
 159     ,m_xDrvColumns(_rxDrvColumns)
 160     ,m_pColFactoryImpl(_pColFactory)
 161     ,m_pRefreshColumns(_pRefresh)
 162     ,m_bInitialized(false)
 163     ,m_bAddColumn(_bAddColumn)
 164     ,m_bDropColumn(_bDropColumn)
 165 {
 166 }
 167
 168 OColumns::~OColumns()
 169 {
 170 }
 171
 172 // XServiceInfo
 173 OUString OColumns::getImplementationName(  )
 174 {
 175     return "com.sun.star.sdb.OColumns";
 176 }
 177
 178 sal_Bool OColumns::supportsService( const OUString& _rServiceName )
 179 {
 180     return cppu::supportsService(this, _rServiceName);
 181 }
 182
 183 Sequence< OUString > OColumns::getSupportedServiceNames(  )
 184 {
 185     return { SERVICE_SDBCX_CONTAINER };
 186 }
 187
 188 void OColumns::append( const OUString& _rName, OColumn* _pColumn )
 189 {
 190     MutexGuard aGuard(m_rMutex);
 191
 192     OSL_ENSURE( _pColumn, "OColumns::append: invalid column!" );
 193     OSL_ENSURE( !m_pElements->exists( _rName ),"OColumns::append: Column already exists");
 194
 195     _pColumn->m_sName = _rName;
 196
 197     // now really insert the column
 198     insertElement( _rName, _pColumn );
 199 }
 200
 201 void OColumns::clearColumns()
 202 {
 203     MutexGuard aGuard(m_rMutex);
 204     disposing();
 205 }
 206
 207 void OColumns::disposing()
 208 {
 209     MutexGuard aGuard(m_rMutex);
 210     m_xDrvColumns = nullptr;
 211     m_pMediator = nullptr;
 212     m_pColFactoryImpl = nullptr;
 213     OColumns_BASE::disposing();
 214 }
 215
 216 void OColumns::impl_refresh()
 217 {
 218     if (m_pRefreshColumns)
 219         m_pRefreshColumns->refreshColumns();
 220 }
 221
 222 connectivity::sdbcx::ObjectType OColumns::createObject(const OUString& _rName)
 223 {
 224     OSL_ENSURE(m_pColFactoryImpl, "OColumns::createObject: no column factory!");
 225
 226     connectivity::sdbcx::ObjectType xRet;
 227     if ( m_pColFactoryImpl )
 228     {
 229         xRet = m_pColFactoryImpl->createColumn(_rName);
 230         Reference<XChild> xChild(xRet,UNO_QUERY);
 231         if ( xChild.is() )
 232             xChild->setParent(static_cast<XChild*>(static_cast<TXChild*>(this)));
 233     }
 234
 235     Reference<XPropertySet> xDest(xRet,UNO_QUERY);
 236     if ( m_pMediator && xDest.is() )
 237         m_pMediator->notifyElementCreated(_rName,xDest);
 238
 239     return xRet;
 240 }
 241
 242 Reference< XPropertySet > OColumns::createDescriptor()
 243 {
 244     if ( m_pColFactoryImpl )
 245     {
 246         Reference<XPropertySet> xRet = m_pColFactoryImpl->createColumnDescriptor();
 247         Reference<XChild> xChild(xRet,UNO_QUERY);
 248         if ( xChild.is() )
 249             xChild->setParent(static_cast<XChild*>(static_cast<TXChild*>(this)));
 250         return xRet;
 251     }
 252     else
 253         return Reference< XPropertySet >();
 254 }
 255
 256 Any SAL_CALL OColumns::queryInterface( const Type & rType )
 257 {
 258     Any aRet;
 259     if(m_xDrvColumns.is())
 260     {
 261         aRet = m_xDrvColumns->queryInterface(rType);
 262         if ( aRet.hasValue() )
 263             aRet = OColumns_BASE::queryInterface( rType);
 264         if ( !aRet.hasValue() )
 265             aRet = TXChild::queryInterface( rType);
 266         return aRet;
 267     }
 268     else if(!m_pTable || !m_pTable->isNew())
 269     {
 270         if(!m_bAddColumn    && rType == cppu::UnoType<XAppend>::get())
 271             return Any();
 272         if(!m_bDropColumn   && rType == cppu::UnoType<XDrop>::get())
 273             return Any();
 274     }
 275
 276     aRet = OColumns_BASE::queryInterface( rType);
 277     if ( !aRet.hasValue() )
 278         aRet = TXChild::queryInterface( rType);
 279     return aRet;
 280 }
 281
 282 Sequence< Type > SAL_CALL OColumns::getTypes(  )
 283 {
 284     bool bAppendFound = false,bDropFound = false;
 285
 286     sal_Int32 nSize = 0;
 287     Type aAppendType = cppu::UnoType<XAppend>::get();
 288     Type aDropType   = cppu::UnoType<XDrop>::get();
 289     if(m_xDrvColumns.is())
 290     {
 291         Reference<XTypeProvider> xTypes(m_xDrvColumns,UNO_QUERY);
 292         Sequence< Type > aTypes(xTypes->getTypes());
 293
 294         const Type* pBegin = aTypes.getConstArray();
 295         const Type* pEnd = pBegin + aTypes.getLength();
 296         for (;pBegin != pEnd ; ++pBegin)
 297         {
 298             if(aAppendType == *pBegin)
 299                 bAppendFound = true;
 300             else if(aDropType == *pBegin)
 301                 bDropFound = true;
 302         }
 303         nSize = (bDropFound ? (bAppendFound ? 0 : 1) : (bAppendFound ? 1 : 2));
 304     }
 305     else
 306     {
 307         if (m_pTable && m_pTable->isNew())
 308             nSize = 0;
 309         else if (m_bDropColumn)
 310             nSize = m_bAddColumn ? 0 : 1;
 311         else
 312             nSize = m_bAddColumn ? 1 : 2;
 313         bDropFound      = (m_pTable && m_pTable->isNew()) || m_bDropColumn;
 314         bAppendFound    = (m_pTable && m_pTable->isNew()) || m_bAddColumn;
 315     }
 316     Sequence< Type > aTypes(::comphelper::concatSequences(OColumns_BASE::getTypes(),TXChild::getTypes()));
 317     Sequence< Type > aRet(aTypes.getLength() - nSize);
 318
 319     const Type* pBegin = aTypes.getConstArray();
 320     const Type* pEnd = pBegin + aTypes.getLength();
 321     for(sal_Int32 i=0;pBegin != pEnd ;++pBegin)
 322     {
 323         if(*pBegin != aAppendType && *pBegin != aDropType)
 324             aRet.getArray()[i++] = *pBegin;
 325         else if(bDropFound && *pBegin == aDropType)
 326             aRet.getArray()[i++] = *pBegin;
 327         else if(bAppendFound && *pBegin == aAppendType)
 328             aRet.getArray()[i++] = *pBegin;
 329     }
 330     return aRet;
 331 }
 332
 333 // XAppend
 334 sdbcx::ObjectType OColumns::appendObject( const OUString& _rForName, const Reference< XPropertySet >& descriptor )
 335 {
 336     sdbcx::ObjectType xReturn;
 337
 338     Reference< XAppend > xAppend( m_xDrvColumns, UNO_QUERY );
 339     if ( xAppend.is() )
 340     {
 341         xAppend->appendByDescriptor(descriptor);
 342         xReturn = createObject( _rForName );
 343     }
 344     else if ( m_pTable && !m_pTable->isNew() )
 345     {
 346         if ( m_bAddColumn )
 347         {
 348             Reference< css::sdb::tools::XTableAlteration> xAlterService = m_pTable->getAlterService();
 349             if ( xAlterService.is() )
 350             {
 351                 xAlterService->addColumn(m_pTable,descriptor);
 352                 xReturn = createObject( _rForName );
 353             }
 354             else
 355                 xReturn = OColumns_BASE::appendObject( _rForName, descriptor );
 356         }
 357         else
 358             ::dbtools::throwGenericSQLException( DBA_RES( RID_STR_NO_COLUMN_ADD ), static_cast<XChild*>(static_cast<TXChild*>(this)) );
 359     }
 360     else
 361         xReturn = cloneDescriptor( descriptor );
 362
 363     if ( m_pColFactoryImpl )
 364         m_pColFactoryImpl->columnAppended( descriptor );
 365
 366     ::dbaccess::notifyDataSourceModified(m_xParent);
 367
 368     return xReturn;
 369 }
 370
 371 // XDrop
 372 void OColumns::dropObject(sal_Int32 _nPos, const OUString& _sElementName)
 373 {
 374     Reference< XDrop > xDrop( m_xDrvColumns, UNO_QUERY );
 375     if ( xDrop.is() )
 376     {
 377         xDrop->dropByName( _sElementName );
 378     }
 379     else if ( m_pTable && !m_pTable->isNew() )
 380     {
 381         if ( m_bDropColumn )
 382         {
 383             Reference< css::sdb::tools::XTableAlteration> xAlterService = m_pTable->getAlterService();
 384             if ( xAlterService.is() )
 385                 xAlterService->dropColumn(m_pTable,_sElementName);
 386             else
 387                 OColumns_BASE::dropObject(_nPos,_sElementName);
 388         }
 389         else
 390             ::dbtools::throwGenericSQLException( DBA_RES( RID_STR_NO_COLUMN_DROP ), static_cast<XChild*>(static_cast<TXChild*>(this)) );
 391     }
 392
 393     if ( m_pColFactoryImpl )
 394         m_pColFactoryImpl->columnDropped(_sElementName);
 395
 396     ::dbaccess::notifyDataSourceModified(m_xParent);
 397 }
 398
 399 Reference< XInterface > SAL_CALL OColumns::getParent(  )
 400 {
 401     ::osl::MutexGuard aGuard(m_rMutex);
 402     return m_xParent;
 403 }
 404
 405 void SAL_CALL OColumns::setParent( const Reference< XInterface >& _xParent )
 406 {
 407     ::osl::MutexGuard aGuard(m_rMutex);
 408     m_xParent = _xParent;
 409 }
 410
 411 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */