dbaccess/source/core/api/tablecontainer.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 "tablecontainer.hxx"
  21 #include "dbastrings.hrc"
  22 #include "table.hxx"
  23 #include <comphelper/property.hxx>
  24 #include <comphelper/processfactory.hxx>
  25 #include <tools/debug.hxx>
  26 #include <comphelper/enumhelper.hxx>
  27 #include "core_resource.hxx"
  28 #include "core_resource.hrc"
  29 #include <com/sun/star/sdb/CommandType.hpp>
  30 #include <com/sun/star/beans/XPropertySet.hpp>
  31 #include <com/sun/star/beans/PropertyState.hpp>
  32 #include <com/sun/star/beans/XPropertyState.hpp>
  33 #include <com/sun/star/sdb/TableDefinition.hpp>
  34 #include <com/sun/star/sdbc/XConnection.hpp>
  35 #include <com/sun/star/sdbc/XDatabaseMetaData.hpp>
  36 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
  37 #include <com/sun/star/sdbcx/XTablesSupplier.hpp>
  38 #include <com/sun/star/sdbc/KeyRule.hpp>
  39 #include <com/sun/star/sdbcx/KeyType.hpp>
  40 #include <com/sun/star/sdbc/ColumnValue.hpp>
  41 #include <com/sun/star/sdbc/XRow.hpp>
  42 #include <comphelper/types.hxx>
  43 #include <connectivity/dbtools.hxx>
  44 #include <comphelper/extract.hxx>
  45 #include <connectivity/dbexception.hxx>
  46 #include "TableDeco.hxx"
  47 #include "sdbcoretools.hxx"
  48 #include "ContainerMediator.hxx"
  49 #include "definitioncolumn.hxx"
  50 #include "objectnameapproval.hxx"
  51 #include <tools/diagnose_ex.h>
  52
  53 using namespace dbaccess;
  54 using namespace dbtools;
  55 using namespace ::com::sun::star::uno;
  56 using namespace ::com::sun::star::lang;
  57 using namespace ::com::sun::star::beans;
  58 using namespace ::com::sun::star::sdbc;
  59 using namespace ::com::sun::star::sdb;
  60 using namespace ::com::sun::star::sdbcx;
  61 using namespace ::com::sun::star::container;
  62 using namespace ::com::sun::star::util;
  63 using namespace ::osl;
  64 using namespace ::comphelper;
  65 using namespace ::cppu;
  66 using namespace ::connectivity::sdbcx;
  67
  68 namespace
  69 {
  70     bool lcl_isPropertySetDefaulted(const Sequence< OUString>& _aNames,const Reference<XPropertySet>& _xProp)
  71     {
  72         Reference<XPropertyState> xState(_xProp,UNO_QUERY);
  73         if ( xState.is() )
  74         {
  75             const OUString* pIter = _aNames.getConstArray();
  76             const OUString* pEnd   = pIter + _aNames.getLength();
  77             for(;pIter != pEnd;++pIter)
  78             {
  79                 try
  80                 {
  81                     PropertyState aState = xState->getPropertyState(*pIter);
  82                     if ( aState != PropertyState_DEFAULT_VALUE )
  83                         break;
  84                 }
  85                 catch(const Exception&)
  86                 {
  87                     SAL_WARN("dbaccess", "lcl_isPropertySetDefaulted: Exception caught!" );
  88                 }
  89             }
  90             return ( pIter == pEnd );
  91         }
  92         return false;
  93     }
  94 }
  95
  96 // OTableContainer
  97
  98 OTableContainer::OTableContainer(::cppu::OWeakObject& _rParent,
  99                                  ::osl::Mutex& _rMutex,
 100                                  const Reference< XConnection >& _xCon,
 101                                  bool _bCase,
 102                                  const Reference< XNameContainer >& _xTableDefinitions,
 103                                  IRefreshListener*  _pRefreshListener,
 104                                  ::dbtools::IWarningsContainer* _pWarningsContainer
 105                                  ,oslInterlockedCount& _nInAppend)
 106     :OFilteredContainer(_rParent,_rMutex,_xCon,_bCase,_pRefreshListener,_pWarningsContainer,_nInAppend)
 107     ,m_xTableDefinitions(_xTableDefinitions)
 108     ,m_pTableMediator( NULL )
 109     ,m_bInDrop(false)
 110 {
 111 }
 112
 113 OTableContainer::~OTableContainer()
 114 {
 115 }
 116
 117 void OTableContainer::removeMasterContainerListener()
 118 {
 119     try
 120     {
 121         Reference<XContainer> xCont( m_xMasterContainer, UNO_QUERY_THROW );
 122         xCont->removeContainerListener( this );
 123     }
 124     catch( const Exception& )
 125     {
 126         DBG_UNHANDLED_EXCEPTION();
 127     }
 128 }
 129
 130 OUString OTableContainer::getTableTypeRestriction() const
 131 {
 132     // no restriction at all (other than the ones provided externally)
 133     return OUString();
 134 }
 135
 136 // XServiceInfo
 137 IMPLEMENT_SERVICE_INFO2(OTableContainer, "com.sun.star.sdb.dbaccess.OTableContainer", SERVICE_SDBCX_CONTAINER, SERVICE_SDBCX_TABLES)
 138
 139 namespace
 140 {
 141 void lcl_createDefintionObject(const OUString& _rName
 142                            ,const Reference< XNameContainer >& _xTableDefinitions
 143                            ,Reference<XPropertySet>& _xTableDefinition
 144                            ,Reference<XNameAccess>& _xColumnDefinitions)
 145 {
 146     if ( _xTableDefinitions.is() )
 147     {
 148         if ( _xTableDefinitions->hasByName(_rName) )
 149             _xTableDefinition.set(_xTableDefinitions->getByName(_rName),UNO_QUERY);
 150         else
 151         {
 152             // set as folder
 153             _xTableDefinition.set( TableDefinition::createWithName( ::comphelper::getProcessComponentContext(), _rName ), UNO_QUERY);
 154             _xTableDefinitions->insertByName(_rName,makeAny(_xTableDefinition));
 155         }
 156         Reference<XColumnsSupplier> xColumnsSupplier(_xTableDefinition,UNO_QUERY);
 157         if ( xColumnsSupplier.is() )
 158             _xColumnDefinitions = xColumnsSupplier->getColumns();
 159     }
 160 }
 161
 162 }
 163
 164 connectivity::sdbcx::ObjectType OTableContainer::createObject(const OUString& _rName)
 165 {
 166     Reference<XColumnsSupplier > xSup;
 167     if(m_xMasterContainer.is() && m_xMasterContainer->hasByName(_rName))
 168         xSup.set(m_xMasterContainer->getByName(_rName),UNO_QUERY);
 169
 170     connectivity::sdbcx::ObjectType xRet;
 171     if ( m_xMetaData.is() )
 172     {
 173         Reference<XPropertySet> xTableDefinition;
 174         Reference<XNameAccess> xColumnDefinitions;
 175         lcl_createDefintionObject(_rName,m_xTableDefinitions,xTableDefinition,xColumnDefinitions);
 176
 177         if ( xSup.is() )
 178         {
 179             ODBTableDecorator* pTable = new ODBTableDecorator( m_xConnection, xSup, ::dbtools::getNumberFormats( m_xConnection ) ,xColumnDefinitions);
 180             xRet = pTable;
 181             pTable->construct();
 182         }
 183         else
 184         {
 185             OUString sCatalog,sSchema,sTable;
 186             ::dbtools::qualifiedNameComponents(m_xMetaData,
 187                                                 _rName,
 188                                                 sCatalog,
 189                                                 sSchema,
 190                                                 sTable,
 191                                                 ::dbtools::eInDataManipulation);
 192             Any aCatalog;
 193             if(!sCatalog.isEmpty())
 194                 aCatalog <<= sCatalog;
 195             OUString sType,sDescription;
 196             Sequence< OUString> aTypeFilter;
 197             getAllTableTypeFilter( aTypeFilter );
 198
 199             Reference< XResultSet > xRes =  m_xMetaData.is() ? m_xMetaData->getTables(aCatalog,sSchema,sTable,aTypeFilter) : Reference< XResultSet >();
 200             if(xRes.is() && xRes->next())
 201             {
 202                 Reference< XRow > xRow(xRes,UNO_QUERY);
 203                 if(xRow.is())
 204                 {
 205                     sType           = xRow->getString(4);
 206                     sDescription    = xRow->getString(5);
 207                 }
 208             }
 209             ::comphelper::disposeComponent(xRes);
 210             ODBTable* pTable = new ODBTable(this
 211                                 ,m_xConnection
 212                                 ,sCatalog
 213                                 ,sSchema
 214                                 ,sTable
 215                                 ,sType
 216                                 ,sDescription
 217                                 ,xColumnDefinitions);
 218             xRet = pTable;
 219             pTable->construct();
 220         }
 221         Reference<XPropertySet> xDest(xRet,UNO_QUERY);
 222         if ( xTableDefinition.is() )
 223             ::comphelper::copyProperties(xTableDefinition,xDest);
 224
 225         if ( !m_pTableMediator.is() )
 226             m_pTableMediator = new OContainerMediator(
 227                     this, m_xTableDefinitions.get(), m_xConnection );
 228         if ( m_pTableMediator.is() )
 229             m_pTableMediator->notifyElementCreated(_rName,xDest);
 230     }
 231
 232     return xRet;
 233 }
 234
 235 Reference< XPropertySet > OTableContainer::createDescriptor()
 236 {
 237     Reference< XPropertySet > xRet;
 238
 239     // first we have to look if the master tables support this
 240     // and if so then create a table object as well with the master tables
 241     Reference<XColumnsSupplier > xMasterColumnsSup;
 242     Reference<XDataDescriptorFactory> xDataFactory(m_xMasterContainer,UNO_QUERY);
 243     if ( xDataFactory.is() && m_xMetaData.is() )
 244     {
 245         xMasterColumnsSup = Reference< XColumnsSupplier >( xDataFactory->createDataDescriptor(), UNO_QUERY );
 246         ODBTableDecorator* pTable = new ODBTableDecorator( m_xConnection, xMasterColumnsSup, ::dbtools::getNumberFormats( m_xConnection ) ,NULL);
 247         xRet = pTable;
 248         pTable->construct();
 249     }
 250     else
 251     {
 252         ODBTable* pTable = new ODBTable(this, m_xConnection);
 253         xRet = pTable;
 254         pTable->construct();
 255     }
 256     return xRet;
 257 }
 258
 259 // XAppend
 260 ObjectType OTableContainer::appendObject( const OUString& _rForName, const Reference< XPropertySet >& descriptor )
 261 {
 262     // append the new table with a create stmt
 263     OUString aName = getString(descriptor->getPropertyValue(PROPERTY_NAME));
 264     if(m_xMasterContainer.is() && m_xMasterContainer->hasByName(aName))
 265     {
 266         OUString sMessage(DBACORE_RESSTRING(RID_STR_TABLE_IS_FILTERED));
 267         throw SQLException(sMessage.replaceAll("$name$", aName),static_cast<XTypeProvider*>(static_cast<OFilteredContainer*>(this)),SQLSTATE_GENERAL,1000,Any());
 268     }
 269
 270     Reference< XConnection > xConnection( m_xConnection.get(), UNO_QUERY );
 271     PContainerApprove pApprove( new ObjectNameApproval( xConnection, ObjectNameApproval::TypeTable ) );
 272     pApprove->approveElement( aName, descriptor );
 273
 274     try
 275     {
 276         EnsureReset aReset(m_nInAppend);
 277         Reference<XAppend> xAppend(m_xMasterContainer,UNO_QUERY);
 278         if(xAppend.is())
 279         {
 280             xAppend->appendByDescriptor(descriptor);
 281         }
 282         else
 283         {
 284             OUString aSql = ::dbtools::createSqlCreateTableStatement(descriptor,m_xConnection);
 285
 286             Reference<XConnection> xCon = m_xConnection;
 287             OSL_ENSURE(xCon.is(),"Connection is null!");
 288             if ( xCon.is() )
 289             {
 290                 Reference< XStatement > xStmt = xCon->createStatement(  );
 291                 if ( xStmt.is() )
 292                     xStmt->execute(aSql);
 293                 ::comphelper::disposeComponent(xStmt);
 294             }
 295         }
 296     }
 297     catch(const Exception&)
 298     {
 299         throw;
 300     }
 301
 302     Reference<XPropertySet> xTableDefinition;
 303     Reference<XNameAccess> xColumnDefinitions;
 304     lcl_createDefintionObject(getNameForObject(descriptor),m_xTableDefinitions,xTableDefinition,xColumnDefinitions);
 305     Reference<XColumnsSupplier> xSup(descriptor,UNO_QUERY);
 306     Reference<XDataDescriptorFactory> xFac(xColumnDefinitions,UNO_QUERY);
 307     Reference<XAppend> xAppend(xColumnDefinitions,UNO_QUERY);
 308     bool bModified = false;
 309     if ( xSup.is() && xColumnDefinitions.is() && xFac.is() && xAppend.is() )
 310     {
 311         Reference<XNameAccess> xNames = xSup->getColumns();
 312         if ( xNames.is() )
 313         {
 314             Reference<XPropertySet> xProp = xFac->createDataDescriptor();
 315             Sequence< OUString> aSeq = xNames->getElementNames();
 316             const OUString* pIter = aSeq.getConstArray();
 317             const OUString* pEnd   = pIter + aSeq.getLength();
 318             for(;pIter != pEnd;++pIter)
 319             {
 320                 if ( !xColumnDefinitions->hasByName(*pIter) )
 321                 {
 322                     Reference<XPropertySet> xColumn(xNames->getByName(*pIter),UNO_QUERY);
 323                     if ( !OColumnSettings::hasDefaultSettings( xColumn ) )
 324                     {
 325                         ::comphelper::copyProperties( xColumn, xProp );
 326                         xAppend->appendByDescriptor( xProp );
 327                         bModified = true;
 328                     }
 329                 }
 330             }
 331         }
 332     }
 333     const static OUString s_pTableProps[] = {    OUString(PROPERTY_FILTER), OUString(PROPERTY_ORDER)
 334                                                     , OUString(PROPERTY_APPLYFILTER), OUString(PROPERTY_FONT)
 335                                                     , OUString(PROPERTY_ROW_HEIGHT), OUString(PROPERTY_TEXTCOLOR)
 336                                                     , OUString(PROPERTY_TEXTLINECOLOR), OUString(PROPERTY_TEXTEMPHASIS)
 337                                                     , OUString(PROPERTY_TEXTRELIEF) };
 338     Sequence< OUString> aNames(s_pTableProps,sizeof(s_pTableProps)/sizeof(s_pTableProps[0]));
 339     if ( bModified || !lcl_isPropertySetDefaulted(aNames,xTableDefinition) )
 340         ::dbaccess::notifyDataSourceModified(m_xTableDefinitions,true);
 341
 342     return createObject( _rForName );
 343 }
 344
 345 // XDrop
 346 void OTableContainer::dropObject(sal_Int32 _nPos, const OUString& _sElementName)
 347 {
 348     m_bInDrop = true;
 349     try
 350     {
 351         Reference< XDrop > xDrop(m_xMasterContainer,UNO_QUERY);
 352         if(xDrop.is())
 353             xDrop->dropByName(_sElementName);
 354         else
 355         {
 356             OUString sCatalog,sSchema,sTable,sComposedName;
 357
 358             bool bIsView = false;
 359             Reference<XPropertySet> xTable(getObject(_nPos),UNO_QUERY);
 360             if ( xTable.is() && m_xMetaData.is() )
 361             {
 362                 if( m_xMetaData.is() && m_xMetaData->supportsCatalogsInTableDefinitions() )
 363                     xTable->getPropertyValue(PROPERTY_CATALOGNAME)  >>= sCatalog;
 364                 if( m_xMetaData.is() && m_xMetaData->supportsSchemasInTableDefinitions() )
 365                     xTable->getPropertyValue(PROPERTY_SCHEMANAME)   >>= sSchema;
 366                 xTable->getPropertyValue(PROPERTY_NAME)         >>= sTable;
 367
 368                 sComposedName = ::dbtools::composeTableName( m_xMetaData, sCatalog, sSchema, sTable, true, ::dbtools::eInTableDefinitions );
 369
 370                 OUString sType;
 371                 xTable->getPropertyValue(PROPERTY_TYPE)         >>= sType;
 372                 bIsView = sType.equalsIgnoreAsciiCase("VIEW");
 373             }
 374
 375             if(sComposedName.isEmpty())
 376                 ::dbtools::throwFunctionSequenceException(static_cast<XTypeProvider*>(static_cast<OFilteredContainer*>(this)));
 377
 378             OUString aSql("DROP ");
 379
 380             if ( bIsView ) // here we have a view
 381                 aSql += "VIEW ";
 382             else
 383                 aSql += "TABLE ";
 384             aSql += sComposedName;
 385             Reference<XConnection> xCon = m_xConnection;
 386             OSL_ENSURE(xCon.is(),"Connection is null!");
 387             if ( xCon.is() )
 388             {
 389                 Reference< XStatement > xStmt = xCon->createStatement(  );
 390                 if(xStmt.is())
 391                     xStmt->execute(aSql);
 392                 ::comphelper::disposeComponent(xStmt);
 393             }
 394         }
 395
 396         if ( m_xTableDefinitions.is() && m_xTableDefinitions->hasByName(_sElementName) )
 397         {
 398             m_xTableDefinitions->removeByName(_sElementName);
 399         }
 400     }
 401     catch(const Exception&)
 402     {
 403         m_bInDrop = false;
 404         throw;
 405     }
 406     m_bInDrop = false;
 407 }
 408
 409 void SAL_CALL OTableContainer::elementInserted( const ContainerEvent& Event ) throw (RuntimeException, std::exception)
 410 {
 411     ::osl::MutexGuard aGuard(m_rMutex);
 412     OUString sName;
 413     Event.Accessor >>= sName;
 414     if ( !m_nInAppend && !hasByName(sName) )
 415     {
 416         if(!m_xMasterContainer.is() || m_xMasterContainer->hasByName(sName))
 417         {
 418             ObjectType xName = createObject(sName);
 419             insertElement(sName,xName);
 420             // and notify our listeners
 421             ContainerEvent aEvent(static_cast<XContainer*>(this), makeAny(sName), makeAny(xName), Any());
 422             m_aContainerListeners.notifyEach( &XContainerListener::elementInserted, aEvent );
 423         }
 424     }
 425 }
 426
 427 void SAL_CALL OTableContainer::elementRemoved( const ContainerEvent& /*Event*/ ) throw (RuntimeException, std::exception)
 428 {
 429 }
 430
 431 void SAL_CALL OTableContainer::elementReplaced( const ContainerEvent& Event ) throw (RuntimeException, std::exception)
 432 {
 433     // create a new config entry
 434     {
 435         OUString sOldComposedName,sNewComposedName;
 436         Event.ReplacedElement   >>= sOldComposedName;
 437         Event.Accessor          >>= sNewComposedName;
 438
 439         renameObject(sOldComposedName,sNewComposedName);
 440     }
 441 }
 442
 443 void SAL_CALL OTableContainer::disposing()
 444 {
 445     OFilteredContainer::disposing();
 446     // say goodbye to our listeners
 447     m_xTableDefinitions = NULL;
 448     m_pTableMediator = NULL;
 449 }
 450
 451 void SAL_CALL OTableContainer::disposing( const ::com::sun::star::lang::EventObject& /*Source*/ ) throw (::com::sun::star::uno::RuntimeException, std::exception)
 452 {
 453 }
 454
 455 void OTableContainer::addMasterContainerListener()
 456 {
 457     try
 458     {
 459         Reference< XContainer > xCont( m_xMasterContainer, UNO_QUERY_THROW );
 460         xCont->addContainerListener( this );
 461     }
 462     catch( const Exception& )
 463     {
 464         DBG_UNHANDLED_EXCEPTION();
 465     }
 466 }
 467
 468 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */