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