dbaccess/source/core/api/TableDeco.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 <TableDeco.hxx>
  21 #include <apitools.hxx>
  22 #include <definitioncolumn.hxx>
  23 #include <stringconstants.hxx>
  24 #include <core_resource.hxx>
  25 #include <strings.hrc>
  26 #include <osl/diagnose.h>
  27 #include <sal/log.hxx>
  28
  29 #include <cppuhelper/typeprovider.hxx>
  30 #include <comphelper/property.hxx>
  31 #include <comphelper/servicehelper.hxx>
  32 #include <com/sun/star/sdbc/SQLException.hpp>
  33 #include <com/sun/star/sdbc/XConnection.hpp>
  34 #include <com/sun/star/beans/PropertyAttribute.hpp>
  35 #include <connectivity/dbtools.hxx>
  36 #include <connectivity/dbexception.hxx>
  37 #include <ContainerMediator.hxx>
  38
  39 using namespace dbaccess;
  40 using namespace ::com::sun::star::uno;
  41 using namespace ::com::sun::star::util;
  42 using namespace ::com::sun::star::lang;
  43 using namespace ::com::sun::star::beans;
  44 using namespace ::com::sun::star::sdbc;
  45 using namespace ::com::sun::star::sdbcx;
  46 using namespace ::com::sun::star::container;
  47 using namespace ::osl;
  48 using namespace ::comphelper;
  49 using namespace ::dbtools;
  50 using namespace ::cppu;
  51
  52 // ODBTableDecorator
  53
  54 ODBTableDecorator::ODBTableDecorator( const Reference< XConnection >& _rxConnection, const Reference< XColumnsSupplier >& _rxNewTable,
  55         const Reference< XNumberFormatsSupplier >& _rxNumberFormats, const Reference< XNameAccess >& _xColumnDefinitions )
  56     :OTableDescriptor_BASE(m_aMutex)
  57     ,ODataSettings(OTableDescriptor_BASE::rBHelper)
  58     ,m_xTable(_rxNewTable)
  59     ,m_xColumnDefinitions(_xColumnDefinitions)
  60     ,m_xConnection( _rxConnection )
  61     ,m_xMetaData( _rxConnection.is() ? _rxConnection->getMetaData() : Reference< XDatabaseMetaData >() )
  62     ,m_xNumberFormats( _rxNumberFormats )
  63     ,m_nPrivileges(-1)
  64 {
  65     ODataSettings::registerPropertiesFor(this);
  66 }
  67
  68 ODBTableDecorator::~ODBTableDecorator()
  69 {
  70 }
  71
  72 Sequence< sal_Int8 > ODBTableDecorator::getImplementationId()
  73 {
  74     return css::uno::Sequence<sal_Int8>();
  75 }
  76
  77 // OComponentHelper
  78 void SAL_CALL ODBTableDecorator::disposing()
  79 {
  80     OPropertySetHelper::disposing();
  81     OTableDescriptor_BASE::disposing();
  82
  83     MutexGuard aGuard(m_aMutex);
  84     m_xTable        = nullptr;
  85     m_xMetaData     = nullptr;
  86     m_xColumnDefinitions = nullptr;
  87     m_xNumberFormats = nullptr;
  88     if ( m_pColumns )
  89         m_pColumns->disposing();
  90     m_xColumnMediator = nullptr;
  91 }
  92
  93 sal_Bool SAL_CALL ODBTableDecorator::convertFastPropertyValue(
  94                             Any & rConvertedValue,
  95                             Any & rOldValue,
  96                             sal_Int32 nHandle,
  97                             const Any& rValue )
  98 {
  99     bool bRet = true;
 100     switch(nHandle)
 101     {
 102         case PROPERTY_ID_PRIVILEGES:
 103         case PROPERTY_ID_FILTER:
 104         case PROPERTY_ID_ORDER:
 105         case PROPERTY_ID_APPLYFILTER:
 106         case PROPERTY_ID_FONT:
 107         case PROPERTY_ID_ROW_HEIGHT:
 108         case PROPERTY_ID_AUTOGROW:
 109         case PROPERTY_ID_TEXTCOLOR:
 110         case PROPERTY_ID_TEXTLINECOLOR:
 111         case PROPERTY_ID_TEXTEMPHASIS:
 112         case PROPERTY_ID_TEXTRELIEF:
 113         case PROPERTY_ID_FONTCHARWIDTH:
 114         case PROPERTY_ID_FONTCHARSET:
 115         case PROPERTY_ID_FONTFAMILY:
 116         case PROPERTY_ID_FONTHEIGHT:
 117         case PROPERTY_ID_FONTKERNING:
 118         case PROPERTY_ID_FONTNAME:
 119         case PROPERTY_ID_FONTORIENTATION:
 120         case PROPERTY_ID_FONTPITCH:
 121         case PROPERTY_ID_FONTSLANT:
 122         case PROPERTY_ID_FONTSTRIKEOUT:
 123         case PROPERTY_ID_FONTSTYLENAME:
 124         case PROPERTY_ID_FONTUNDERLINE:
 125         case PROPERTY_ID_FONTWEIGHT:
 126         case PROPERTY_ID_FONTWIDTH:
 127         case PROPERTY_ID_FONTWORDLINEMODE:
 128         case PROPERTY_ID_FONTTYPE:
 129             bRet = ODataSettings::convertFastPropertyValue(rConvertedValue, rOldValue,nHandle,rValue);
 130             break;
 131
 132         default:
 133             {
 134                 Any aValue;
 135                 getFastPropertyValue(aValue,nHandle);
 136                 bRet = ::comphelper::tryPropertyValue(rConvertedValue,rOldValue,rValue,aValue,::cppu::UnoType<OUString>::get());
 137             }
 138             break; // we assume that it works
 139     }
 140     return bRet;
 141 }
 142
 143 void ODBTableDecorator::setFastPropertyValue_NoBroadcast(sal_Int32 _nHandle, const Any& _rValue)
 144 {
 145     switch(_nHandle)
 146     {
 147         case PROPERTY_ID_PRIVILEGES:
 148             SAL_WARN("dbaccess", "Property is readonly!");
 149             [[fallthrough]];
 150         case PROPERTY_ID_FILTER:
 151         case PROPERTY_ID_ORDER:
 152         case PROPERTY_ID_APPLYFILTER:
 153         case PROPERTY_ID_FONT:
 154         case PROPERTY_ID_ROW_HEIGHT:
 155         case PROPERTY_ID_AUTOGROW:
 156         case PROPERTY_ID_TEXTCOLOR:
 157         case PROPERTY_ID_TEXTLINECOLOR:
 158         case PROPERTY_ID_TEXTEMPHASIS:
 159         case PROPERTY_ID_TEXTRELIEF:
 160         case PROPERTY_ID_FONTCHARWIDTH:
 161         case PROPERTY_ID_FONTCHARSET:
 162         case PROPERTY_ID_FONTFAMILY:
 163         case PROPERTY_ID_FONTHEIGHT:
 164         case PROPERTY_ID_FONTKERNING:
 165         case PROPERTY_ID_FONTNAME:
 166         case PROPERTY_ID_FONTORIENTATION:
 167         case PROPERTY_ID_FONTPITCH:
 168         case PROPERTY_ID_FONTSLANT:
 169         case PROPERTY_ID_FONTSTRIKEOUT:
 170         case PROPERTY_ID_FONTSTYLENAME:
 171         case PROPERTY_ID_FONTUNDERLINE:
 172         case PROPERTY_ID_FONTWEIGHT:
 173         case PROPERTY_ID_FONTWIDTH:
 174         case PROPERTY_ID_FONTWORDLINEMODE:
 175         case PROPERTY_ID_FONTTYPE:
 176
 177             ODataSettings::setFastPropertyValue_NoBroadcast(_nHandle, _rValue);
 178             break;
 179         case PROPERTY_ID_CATALOGNAME:
 180             {
 181                 Reference<XPropertySet> xProp(m_xTable,UNO_QUERY);
 182                 xProp->setPropertyValue(PROPERTY_CATALOGNAME,_rValue);
 183             }
 184             break;
 185         case PROPERTY_ID_SCHEMANAME:
 186             {
 187                 Reference<XPropertySet> xProp(m_xTable,UNO_QUERY);
 188                 xProp->setPropertyValue(PROPERTY_SCHEMANAME,_rValue);
 189             }
 190             break;
 191         case PROPERTY_ID_NAME:
 192             {
 193                 Reference<XPropertySet> xProp(m_xTable,UNO_QUERY);
 194                 xProp->setPropertyValue(PROPERTY_NAME,_rValue);
 195             }
 196             break;
 197         case PROPERTY_ID_DESCRIPTION:
 198             {
 199                 Reference<XPropertySet> xProp(m_xTable,UNO_QUERY);
 200                 xProp->setPropertyValue(PROPERTY_DESCRIPTION,_rValue);
 201             }
 202             break;
 203         case PROPERTY_ID_TYPE:
 204             {
 205                 Reference<XPropertySet> xProp(m_xTable,UNO_QUERY);
 206                 xProp->setPropertyValue(PROPERTY_TYPE,_rValue);
 207             }
 208             break;
 209     }
 210 }
 211
 212 void ODBTableDecorator::getFastPropertyValue(Any& _rValue, sal_Int32 _nHandle) const
 213 {
 214
 215     switch(_nHandle)
 216     {
 217         case PROPERTY_ID_PRIVILEGES:
 218             {
 219                 if ( -1 == m_nPrivileges )
 220                     fillPrivileges();
 221                 Reference<XPropertySet> xProp(m_xTable,UNO_QUERY);
 222                 Reference<XPropertySetInfo> xInfo = xProp->getPropertySetInfo();
 223                 if ( xInfo->hasPropertyByName(PROPERTY_PRIVILEGES) )
 224                 {
 225                     _rValue <<= m_nPrivileges;
 226                     break;
 227                 }
 228             }
 229             [[fallthrough]];
 230
 231         case PROPERTY_ID_FILTER:
 232         case PROPERTY_ID_ORDER:
 233         case PROPERTY_ID_APPLYFILTER:
 234         case PROPERTY_ID_FONT:
 235         case PROPERTY_ID_ROW_HEIGHT:
 236         case PROPERTY_ID_AUTOGROW:
 237         case PROPERTY_ID_TEXTCOLOR:
 238         case PROPERTY_ID_TEXTLINECOLOR:
 239         case PROPERTY_ID_TEXTEMPHASIS:
 240         case PROPERTY_ID_TEXTRELIEF:
 241         case PROPERTY_ID_FONTCHARWIDTH:
 242         case PROPERTY_ID_FONTCHARSET:
 243         case PROPERTY_ID_FONTFAMILY:
 244         case PROPERTY_ID_FONTHEIGHT:
 245         case PROPERTY_ID_FONTKERNING:
 246         case PROPERTY_ID_FONTNAME:
 247         case PROPERTY_ID_FONTORIENTATION:
 248         case PROPERTY_ID_FONTPITCH:
 249         case PROPERTY_ID_FONTSLANT:
 250         case PROPERTY_ID_FONTSTRIKEOUT:
 251         case PROPERTY_ID_FONTSTYLENAME:
 252         case PROPERTY_ID_FONTUNDERLINE:
 253         case PROPERTY_ID_FONTWEIGHT:
 254         case PROPERTY_ID_FONTWIDTH:
 255         case PROPERTY_ID_FONTWORDLINEMODE:
 256         case PROPERTY_ID_FONTTYPE:
 257             ODataSettings::getFastPropertyValue(_rValue, _nHandle);
 258             break;
 259         case PROPERTY_ID_CATALOGNAME:
 260             {
 261                 Reference<XPropertySet> xProp(m_xTable,UNO_QUERY);
 262                 _rValue = xProp->getPropertyValue(PROPERTY_CATALOGNAME);
 263             }
 264             break;
 265         case PROPERTY_ID_SCHEMANAME:
 266             {
 267                 Reference<XPropertySet> xProp(m_xTable,UNO_QUERY);
 268                 _rValue = xProp->getPropertyValue(PROPERTY_SCHEMANAME);
 269             }
 270             break;
 271         case PROPERTY_ID_NAME:
 272             {
 273                 Reference<XPropertySet> xProp(m_xTable,UNO_QUERY);
 274                 _rValue = xProp->getPropertyValue(PROPERTY_NAME);
 275             }
 276             break;
 277         case PROPERTY_ID_DESCRIPTION:
 278             {
 279                 Reference<XPropertySet> xProp(m_xTable,UNO_QUERY);
 280                 _rValue = xProp->getPropertyValue(PROPERTY_DESCRIPTION);
 281             }
 282             break;
 283         case PROPERTY_ID_TYPE:
 284             {
 285                 Reference<XPropertySet> xProp(m_xTable,UNO_QUERY);
 286                 _rValue = xProp->getPropertyValue(PROPERTY_TYPE);
 287             }
 288             break;
 289         default:
 290             SAL_WARN("dbaccess", "Invalid Handle for table");
 291     }
 292 }
 293
 294 void ODBTableDecorator::construct()
 295 {
 296     bool bNotFound = true;
 297     Reference<XPropertySet> xProp(m_xTable,UNO_QUERY);
 298     if ( xProp.is() )
 299     {
 300         Reference<XPropertySetInfo> xInfo = xProp->getPropertySetInfo();
 301         bNotFound = !xInfo->hasPropertyByName(PROPERTY_PRIVILEGES);
 302     }
 303     if ( bNotFound )
 304         registerProperty(PROPERTY_PRIVILEGES, PROPERTY_ID_PRIVILEGES, PropertyAttribute::BOUND  | PropertyAttribute::READONLY,
 305                         &m_nPrivileges, ::cppu::UnoType<sal_Int32>::get());
 306 }
 307
 308 ::cppu::IPropertyArrayHelper* ODBTableDecorator::createArrayHelper(sal_Int32 /*_nId*/) const
 309 {
 310     Reference<XPropertySet> xProp(m_xTable,UNO_QUERY);
 311     Reference<XPropertySetInfo> xInfo = xProp->getPropertySetInfo();
 312
 313     Sequence< Property > aTableProps = xInfo->getProperties();
 314     for (Property & prop : aTableProps)
 315     {
 316         if (prop.Name == PROPERTY_CATALOGNAME)
 317             prop.Handle = PROPERTY_ID_CATALOGNAME;
 318         else if (prop.Name == PROPERTY_SCHEMANAME)
 319             prop.Handle = PROPERTY_ID_SCHEMANAME;
 320         else if (prop.Name == PROPERTY_NAME)
 321             prop.Handle = PROPERTY_ID_NAME;
 322         else if (prop.Name == PROPERTY_DESCRIPTION)
 323             prop.Handle = PROPERTY_ID_DESCRIPTION;
 324         else if (prop.Name == PROPERTY_TYPE)
 325             prop.Handle = PROPERTY_ID_TYPE;
 326         else if (prop.Name == PROPERTY_PRIVILEGES)
 327             prop.Handle = PROPERTY_ID_PRIVILEGES;
 328     }
 329
 330     describeProperties(aTableProps);
 331
 332     return new ::cppu::OPropertyArrayHelper(aTableProps);
 333 }
 334
 335 ::cppu::IPropertyArrayHelper & SAL_CALL ODBTableDecorator::getInfoHelper()
 336 {
 337     Reference<XPropertySet> xProp(m_xTable,UNO_QUERY);
 338
 339     Reference<XPropertySetInfo> xInfo = xProp->getPropertySetInfo();
 340     bool bIsDescriptor = (xInfo->getPropertyByName(PROPERTY_NAME).Attributes & PropertyAttribute::READONLY) == 0;
 341
 342     return *ODBTableDecorator_PROP::getArrayHelper( bIsDescriptor ? 0 : 1 );
 343
 344     // TODO: this is a HACK, and prone to errors
 345     // The OIdPropertyArrayUsageHelper is intended for classes where there exists a known, limited
 346     // number of different property set infos (distinguished by the ID), all implemented by this very
 347     // same class.
 348     // However, in this case here we have an unknown, potentially unlimited number of different
 349     // property set infos: Depending on the table for which we act as decorator, different property
 350     // sets might exist.
 351 }
 352
 353 // XServiceInfo
 354 IMPLEMENT_SERVICE_INFO1(ODBTableDecorator, "com.sun.star.sdb.dbaccess.ODBTableDecorator", SERVICE_SDBCX_TABLE)
 355
 356 Any SAL_CALL ODBTableDecorator::queryInterface( const Type & rType )
 357 {
 358     Any aRet;
 359     if(m_xTable.is())
 360     {
 361         aRet = m_xTable->queryInterface(rType);
 362         if(aRet.hasValue())
 363         {   // now we know that our table supports this type so we return ourself
 364             aRet = OTableDescriptor_BASE::queryInterface(rType);
 365             if(!aRet.hasValue())
 366                 aRet = ODataSettings::queryInterface(rType);
 367         }
 368     }
 369
 370     return aRet;
 371 }
 372
 373 Sequence< Type > SAL_CALL ODBTableDecorator::getTypes(  )
 374 {
 375     Reference<XTypeProvider> xTypes(m_xTable,UNO_QUERY);
 376     OSL_ENSURE(xTypes.is(),"Table must be a TypeProvider!");
 377     return xTypes->getTypes();
 378 }
 379
 380 // XRename,
 381 void SAL_CALL ODBTableDecorator::rename( const OUString& _rNewName )
 382 {
 383     ::osl::MutexGuard aGuard(m_aMutex);
 384     ::connectivity::checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
 385     Reference<XRename> xRename(m_xTable,UNO_QUERY);
 386     if(!xRename.is())
 387         throw SQLException(DBA_RES(RID_STR_NO_TABLE_RENAME),*this,SQLSTATE_GENERAL,1000,Any() );
 388     // not supported
 389     xRename->rename(_rNewName);
 390 }
 391
 392 // XAlterTable,
 393 void SAL_CALL ODBTableDecorator::alterColumnByName( const OUString& _rName, const Reference< XPropertySet >& _rxDescriptor )
 394 {
 395     ::osl::MutexGuard aGuard(m_aMutex);
 396     ::connectivity::checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
 397     Reference<XAlterTable> xAlter(m_xTable,UNO_QUERY);
 398     if(!xAlter.is())
 399         throw SQLException(DBA_RES(RID_STR_COLUMN_ALTER_BY_NAME),*this,SQLSTATE_GENERAL,1000,Any() );
 400     xAlter->alterColumnByName(_rName,_rxDescriptor);
 401     if(m_pColumns)
 402         m_pColumns->refresh();
 403 }
 404
 405 void SAL_CALL ODBTableDecorator::alterColumnByIndex( sal_Int32 _nIndex, const Reference< XPropertySet >& _rxDescriptor )
 406 {
 407     ::osl::MutexGuard aGuard(m_aMutex);
 408     ::connectivity::checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
 409     Reference<XAlterTable> xAlter(m_xTable,UNO_QUERY);
 410     if(!xAlter.is())
 411         throw SQLException(DBA_RES(RID_STR_COLUMN_ALTER_BY_INDEX),*this,SQLSTATE_GENERAL,1000,Any() );
 412     // not supported
 413     xAlter->alterColumnByIndex(_nIndex,_rxDescriptor);
 414     if(m_pColumns)
 415         m_pColumns->refresh();
 416 }
 417
 418 Reference< XNameAccess> ODBTableDecorator::getIndexes()
 419 {
 420     ::osl::MutexGuard aGuard(m_aMutex);
 421     ::connectivity::checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
 422     return Reference< XIndexesSupplier>(m_xTable,UNO_QUERY_THROW)->getIndexes();
 423 }
 424
 425 Reference< XIndexAccess> ODBTableDecorator::getKeys()
 426 {
 427     ::osl::MutexGuard aGuard(m_aMutex);
 428     ::connectivity::checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
 429     return Reference< XKeysSupplier>(m_xTable,UNO_QUERY_THROW)->getKeys();
 430 }
 431
 432 Reference< XNameAccess> ODBTableDecorator::getColumns()
 433 {
 434     ::osl::MutexGuard aGuard(m_aMutex);
 435     ::connectivity::checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
 436
 437     if(!m_pColumns)
 438         refreshColumns();
 439
 440     return m_pColumns.get();
 441 }
 442
 443 OUString SAL_CALL ODBTableDecorator::getName()
 444 {
 445     ::osl::MutexGuard aGuard(m_aMutex);
 446     ::connectivity::checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
 447     Reference<XNamed> xName(m_xTable,UNO_QUERY);
 448     OSL_ENSURE(xName.is(),"Table should support the XNamed interface");
 449     return xName->getName();
 450 }
 451
 452 sal_Int64 SAL_CALL ODBTableDecorator::getSomething( const Sequence< sal_Int8 >& rId )
 453 {
 454     if (isUnoTunnelId<ODBTableDecorator>(rId))
 455         return reinterpret_cast<sal_Int64>(this);
 456
 457     sal_Int64 nRet = 0;
 458     Reference<XUnoTunnel> xTunnel(m_xTable,UNO_QUERY);
 459     if(xTunnel.is())
 460         nRet = xTunnel->getSomething(rId);
 461     return nRet;
 462 }
 463
 464 Sequence< sal_Int8 > ODBTableDecorator::getUnoTunnelId()
 465 {
 466     static ::cppu::OImplementationId implId;
 467
 468     return implId.getImplementationId();
 469 }
 470
 471 void ODBTableDecorator::fillPrivileges() const
 472 {
 473     // somebody is asking for the privileges and we do not know them, yet
 474     m_nPrivileges = 0;
 475     try
 476     {
 477         Reference<XPropertySet> xProp(m_xTable,UNO_QUERY);
 478         if ( xProp.is() )
 479         {
 480             if ( xProp->getPropertySetInfo()->hasPropertyByName(PROPERTY_PRIVILEGES) )
 481             {
 482                 xProp->getPropertyValue(PROPERTY_PRIVILEGES) >>= m_nPrivileges;
 483             }
 484             if ( m_nPrivileges == 0 ) // second chance
 485             {
 486                 OUString sCatalog,sSchema,sName;
 487                 xProp->getPropertyValue(PROPERTY_CATALOGNAME)   >>= sCatalog;
 488                 xProp->getPropertyValue(PROPERTY_SCHEMANAME)    >>= sSchema;
 489                 xProp->getPropertyValue(PROPERTY_NAME)          >>= sName;
 490                 m_nPrivileges = ::dbtools::getTablePrivileges(m_xMetaData, sCatalog,sSchema, sName);
 491             }
 492         }
 493     }
 494     catch(const SQLException&)
 495     {
 496         SAL_WARN("dbaccess", "ODBTableDecorator::ODBTableDecorator : could not collect the privileges !");
 497     }
 498 }
 499
 500 Reference< XPropertySet > SAL_CALL ODBTableDecorator::createDataDescriptor(  )
 501 {
 502     ::osl::MutexGuard aGuard(m_aMutex);
 503     ::connectivity::checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
 504
 505     Reference< XDataDescriptorFactory > xFactory( m_xTable, UNO_QUERY );
 506     OSL_ENSURE( xFactory.is(), "ODBTableDecorator::createDataDescriptor: invalid table!" );
 507     Reference< XColumnsSupplier > xColsSupp;
 508     if ( xFactory.is() )
 509         xColsSupp.set(xFactory->createDataDescriptor(), css::uno::UNO_QUERY);
 510
 511     return new ODBTableDecorator(
 512         m_xConnection,
 513         xColsSupp,
 514         m_xNumberFormats,
 515         nullptr
 516     );
 517 }
 518
 519 Reference< css::beans::XPropertySetInfo > SAL_CALL ODBTableDecorator::getPropertySetInfo(  )
 520 {
 521     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 522 }
 523
 524 void ODBTableDecorator::refreshColumns()
 525 {
 526     ::osl::MutexGuard aGuard(m_aMutex);
 527     ::connectivity::checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
 528
 529     std::vector< OUString> aVector;
 530
 531     Reference<XNameAccess> xNames;
 532     if(m_xTable.is())
 533     {
 534         xNames = m_xTable->getColumns();
 535         if(xNames.is())
 536         {
 537             Sequence< OUString> aNames = xNames->getElementNames();
 538             const OUString* pIter    = aNames.getConstArray();
 539             const OUString* pEnd     = pIter + aNames.getLength();
 540             for(;pIter != pEnd;++pIter)
 541                 aVector.push_back(*pIter);
 542         }
 543     }
 544     if(!m_pColumns)
 545     {
 546         OColumns* pCol = new OColumns(*this,m_aMutex,xNames,m_xMetaData.is() && m_xMetaData->supportsMixedCaseQuotedIdentifiers(),aVector,
 547                                     this,this,
 548                                     m_xMetaData.is() && m_xMetaData->supportsAlterTableWithAddColumn(),
 549                                     m_xMetaData.is() && m_xMetaData->supportsAlterTableWithDropColumn());
 550
 551         pCol->setParent(*this);
 552         OContainerMediator* pMediator = new OContainerMediator( pCol, m_xColumnDefinitions );
 553         m_xColumnMediator = pMediator;
 554         pCol->setMediator( pMediator );
 555         m_pColumns.reset(pCol);
 556     }
 557     else
 558         m_pColumns->reFill(aVector);
 559 }
 560
 561 OColumn* ODBTableDecorator::createColumn(const OUString& _rName) const
 562 {
 563     OColumn* pReturn = nullptr;
 564
 565     Reference<XNameAccess> xNames;
 566     if ( m_xTable.is() )
 567     {
 568         xNames = m_xTable->getColumns();
 569
 570         if ( xNames.is() && xNames->hasByName(_rName) )
 571         {
 572             Reference<XPropertySet> xProp(xNames->getByName(_rName),UNO_QUERY);
 573
 574             Reference<XPropertySet> xColumnDefinition;
 575             if ( m_xColumnDefinitions.is() && m_xColumnDefinitions->hasByName(_rName))
 576                 xColumnDefinition.set(m_xColumnDefinitions->getByName(_rName),UNO_QUERY);
 577
 578             pReturn = new OTableColumnWrapper( xProp, xColumnDefinition, false );
 579         }
 580     }
 581     return pReturn;
 582 }
 583
 584 void ODBTableDecorator::columnAppended( const Reference< XPropertySet >& /*_rxSourceDescriptor*/ )
 585 {
 586     // not interested in
 587 }
 588
 589 void ODBTableDecorator::columnDropped(const OUString& _sName)
 590 {
 591     Reference<XDrop> xDrop(m_xColumnDefinitions,UNO_QUERY);
 592     if ( xDrop.is() && m_xColumnDefinitions->hasByName(_sName) )
 593         xDrop->dropByName(_sName);
 594 }
 595
 596 Reference< XPropertySet > ODBTableDecorator::createColumnDescriptor()
 597 {
 598     Reference<XDataDescriptorFactory> xNames;
 599     if(m_xTable.is())
 600         xNames.set(m_xTable->getColumns(),UNO_QUERY);
 601     Reference< XPropertySet > xRet;
 602     if ( xNames.is() )
 603         xRet = new OTableColumnDescriptorWrapper( xNames->createDataDescriptor(), false, true );
 604     return xRet;
 605 }
 606
 607 void SAL_CALL ODBTableDecorator::acquire() throw()
 608 {
 609     OTableDescriptor_BASE::acquire();
 610 }
 611
 612 void SAL_CALL ODBTableDecorator::release() throw()
 613 {
 614     OTableDescriptor_BASE::release();
 615 }
 616
 617 void SAL_CALL ODBTableDecorator::setName( const OUString& /*aName*/ )
 618 {
 619     throwFunctionNotSupportedRuntimeException( "XNamed::setName", *this );
 620 }
 621
 622 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */