dbaccess/source/core/misc/DatabaseDataProvider.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 "DatabaseDataProvider.hxx"
  21 #include "dbastrings.hrc"
  22 #include "cppuhelper/implbase1.hxx"
  23 #include <comphelper/types.hxx>
  24 #include <comphelper/namedvaluecollection.hxx>
  25 #include <connectivity/FValue.hxx>
  26 #include <connectivity/dbtools.hxx>
  27 #include <rtl/ustrbuf.hxx>
  28 #include <rtl/math.hxx>
  29 #include <sal/macros.h>
  30 #include <tools/diagnose_ex.h>
  31
  32 #include <com/sun/star/task/XInteractionHandler.hpp>
  33 #include <com/sun/star/sdb/XCompletedExecution.hpp>
  34 #include <com/sun/star/sdb/CommandType.hpp>
  35 #include <com/sun/star/sdbc/DataType.hpp>
  36 #include <com/sun/star/sdbc/XRow.hpp>
  37 #include <com/sun/star/sdbc/XResultSet.hpp>
  38 #include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp>
  39 #include <com/sun/star/sdbc/XResultSetMetaData.hpp>
  40 #include <com/sun/star/sdbc/XColumnLocate.hpp>
  41 #include <com/sun/star/beans/NamedValue.hpp>
  42 #include <com/sun/star/chart/ChartDataRowSource.hpp>
  43 #include <com/sun/star/chart/XChartDataArray.hpp>
  44 #include <com/sun/star/chart/XDateCategories.hpp>
  45
  46 #include <vector>
  47 #include <list>
  48
  49 namespace dbaccess
  50 {
  51 using namespace ::com::sun::star;
  52 using ::com::sun::star::sdbc::SQLException;
  53 using ::com::sun::star::uno::Reference;
  54 using ::com::sun::star::uno::RuntimeException;
  55 // -----------------------------------------------------------------------------
  56 DatabaseDataProvider::DatabaseDataProvider(uno::Reference< uno::XComponentContext > const & context) :
  57     TDatabaseDataProvider(m_aMutex),
  58     ::cppu::PropertySetMixin< chart2::data::XDatabaseDataProvider >(
  59         context, static_cast< Implements >(
  60             IMPLEMENTS_PROPERTY_SET), uno::Sequence< ::rtl::OUString >()),
  61     m_aParameterManager( m_aMutex, context ),
  62     m_aFilterManager( uno::Reference< lang::XMultiServiceFactory >(context->getServiceManager(),uno::UNO_QUERY) ),
  63     m_xContext(context),
  64     m_CommandType(sdb::CommandType::COMMAND), // #i94114
  65     m_RowLimit(0),
  66     m_EscapeProcessing(sal_True),
  67     m_ApplyFilter(sal_True)
  68 {
  69     m_xInternal.set( m_xContext->getServiceManager()->createInstanceWithContext(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.chart.InternalDataProvider")),m_xContext ), uno::UNO_QUERY );
  70     m_xRangeConversion.set(m_xInternal,uno::UNO_QUERY);
  71     m_xComplexDescriptionAccess.set(m_xInternal,uno::UNO_QUERY);
  72
  73     osl_atomic_increment( &m_refCount );
  74     {
  75         m_xRowSet.set( m_xContext->getServiceManager()->createInstanceWithContext(SERVICE_SDB_ROWSET,m_xContext ), uno::UNO_QUERY );
  76         m_xAggregate.set(m_xRowSet,uno::UNO_QUERY);
  77         m_xAggregateSet.set(m_xRowSet,uno::UNO_QUERY);
  78         uno::Reference<beans::XPropertySet> xProp(static_cast< ::cppu::OWeakObject* >( this ),uno::UNO_QUERY);
  79         m_aFilterManager.initialize( m_xAggregateSet );
  80         m_aParameterManager.initialize( xProp, m_xAggregate );
  81         m_xAggregateSet->setPropertyValue(PROPERTY_COMMAND_TYPE,uno::makeAny(m_CommandType));
  82         m_xAggregateSet->setPropertyValue(PROPERTY_ESCAPE_PROCESSING,uno::makeAny(m_EscapeProcessing));
  83     }
  84     osl_atomic_decrement( &m_refCount );
  85 }
  86 // -----------------------------------------------------------------------------
  87 void SAL_CALL DatabaseDataProvider::disposing()
  88 {
  89     lang::EventObject aEvt(static_cast<XWeak*>(this));
  90     m_aParameterManager.disposing( aEvt );
  91
  92     m_aParameterManager.dispose();   // (to free any references it may have to me)
  93     m_aFilterManager.dispose();      // (dito)
  94
  95     m_xParent.clear();
  96     m_xAggregateSet.clear();
  97     m_xAggregate.clear();
  98     m_xRangeConversion.clear();
  99     ::comphelper::disposeComponent(m_xRowSet);
 100     ::comphelper::disposeComponent(m_xInternal);
 101     m_xActiveConnection.clear();
 102 }
 103 // -----------------------------------------------------------------------------
 104 uno::Any DatabaseDataProvider::queryInterface(uno::Type const & type) throw (uno::RuntimeException)
 105 {
 106     return TDatabaseDataProvider::queryInterface(type);
 107 }
 108 // -----------------------------------------------------------------------------
 109
 110 //------------------------------------------------------------------------------
 111 rtl::OUString DatabaseDataProvider::getImplementationName_Static(  ) throw(uno::RuntimeException)
 112 {
 113     return rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.dbaccess.DatabaseDataProvider"));
 114 }
 115 // -----------------------------------------------------------------------------
 116 // -------------------------------------------------------------------------
 117 // XServiceInfo
 118 ::rtl::OUString SAL_CALL DatabaseDataProvider::getImplementationName(  ) throw(uno::RuntimeException)
 119 {
 120     return getImplementationName_Static();
 121 }
 122 // -----------------------------------------------------------------------------
 123 // -------------------------------------------------------------------------
 124 sal_Bool SAL_CALL DatabaseDataProvider::supportsService( const ::rtl::OUString& _rServiceName ) throw(uno::RuntimeException)
 125 {
 126     return ::comphelper::findValue(getSupportedServiceNames(), _rServiceName, sal_True).getLength() != 0;
 127 }
 128 // -----------------------------------------------------------------------------
 129 //------------------------------------------------------------------------------
 130 uno::Sequence< ::rtl::OUString > DatabaseDataProvider::getSupportedServiceNames_Static(  ) throw (uno::RuntimeException)
 131 {
 132     uno::Sequence< rtl::OUString > aSNS( 1 );
 133     aSNS[0] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.chart2.data.DatabaseDataProvider"));
 134     return aSNS;
 135 }
 136 // -----------------------------------------------------------------------------
 137 uno::Sequence< ::rtl::OUString > SAL_CALL DatabaseDataProvider::getSupportedServiceNames(  ) throw(uno::RuntimeException)
 138 {
 139     return getSupportedServiceNames_Static();
 140 }
 141 // -----------------------------------------------------------------------------
 142 uno::Reference< uno::XInterface > DatabaseDataProvider::Create(uno::Reference< uno::XComponentContext > const & context)
 143 {
 144     return *(new DatabaseDataProvider(context)) ;
 145 }
 146 // -----------------------------------------------------------------------------
 147 // lang::XInitialization:
 148 void SAL_CALL DatabaseDataProvider::initialize(const uno::Sequence< uno::Any > & aArguments) throw (uno::RuntimeException, uno::Exception)
 149 {
 150     osl::MutexGuard g(m_aMutex);
 151     const uno::Any* pIter   = aArguments.getConstArray();
 152     const uno::Any* pEnd    = pIter + aArguments.getLength();
 153     for(;pIter != pEnd;++pIter)
 154     {
 155         if ( !m_xActiveConnection.is() )
 156             (*pIter) >>= m_xActiveConnection;
 157         else if ( !m_xHandler.is() )
 158             (*pIter) >>= m_xHandler;
 159     }
 160     m_xAggregateSet->setPropertyValue( PROPERTY_ACTIVE_CONNECTION, uno::makeAny( m_xActiveConnection ) );
 161 }
 162 // -----------------------------------------------------------------------------
 163
 164 // chart2::data::XDataProvider:
 165 ::sal_Bool SAL_CALL DatabaseDataProvider::createDataSourcePossible(const uno::Sequence< beans::PropertyValue > & _aArguments) throw (uno::RuntimeException)
 166 {
 167     const beans::PropertyValue* pArgIter = _aArguments.getConstArray();
 168     const beans::PropertyValue* pArgEnd  = pArgIter + _aArguments.getLength();
 169     for(;pArgIter != pArgEnd;++pArgIter)
 170     {
 171         if ( pArgIter->Name == "DataRowSource" )
 172         {
 173             ::com::sun::star::chart::ChartDataRowSource eRowSource = ::com::sun::star::chart::ChartDataRowSource_COLUMNS;
 174             pArgIter->Value >>= eRowSource;
 175             if ( eRowSource != ::com::sun::star::chart::ChartDataRowSource_COLUMNS )
 176                 return sal_False;
 177         }
 178         else if ( pArgIter->Name == "CellRangeRepresentation" )
 179         {
 180             ::rtl::OUString sRange;
 181             pArgIter->Value >>= sRange;
 182             if ( !sRange.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("all")) )
 183                 return sal_False;
 184         }
 185         else if ( pArgIter->Name == "FirstCellAsLabel" )
 186         {
 187             sal_Bool bFirstCellAsLabel = sal_True;
 188             pArgIter->Value >>= bFirstCellAsLabel;
 189             if ( !bFirstCellAsLabel )
 190                 return sal_False;
 191         }
 192     }
 193     return sal_True;
 194 }
 195 // -----------------------------------------------------------------------------
 196 // -----------------------------------------------------------------------------
 197 uno::Reference< chart2::data::XDataSource > SAL_CALL DatabaseDataProvider::createDataSource(const uno::Sequence< beans::PropertyValue > & _aArguments) throw (uno::RuntimeException, lang::IllegalArgumentException)
 198 {
 199     osl::ResettableMutexGuard aClearForNotifies(m_aMutex);
 200     if ( createDataSourcePossible(_aArguments) )
 201     {
 202         try
 203         {
 204             uno::Reference< chart::XChartDataArray> xChartData( m_xInternal, uno::UNO_QUERY_THROW );
 205             xChartData->setData( uno::Sequence< uno::Sequence< double > >() );
 206             xChartData->setColumnDescriptions( uno::Sequence< ::rtl::OUString >() );
 207             if ( m_xInternal->hasDataByRangeRepresentation( ::rtl::OUString::valueOf( sal_Int32(0) ) ) )
 208                 m_xInternal->deleteSequence(0);
 209         }
 210         catch( const uno::Exception& )
 211         {
 212             DBG_UNHANDLED_EXCEPTION();
 213         }
 214
 215         ::comphelper::NamedValueCollection aArgs( _aArguments );
 216         const sal_Bool bHasCategories = aArgs.getOrDefault( "HasCategories", sal_True );
 217         uno::Sequence< ::rtl::OUString > aColumnNames =
 218             aArgs.getOrDefault( "ColumnDescriptions", uno::Sequence< ::rtl::OUString >() );
 219
 220         bool bRet = false;
 221         if ( !m_Command.isEmpty() && m_xActiveConnection.is() )
 222         {
 223             try
 224             {
 225                 impl_fillRowSet_throw();
 226                 impl_executeRowSet_throw(aClearForNotifies);
 227                 impl_fillInternalDataProvider_throw(bHasCategories,aColumnNames);
 228                 bRet = true;
 229             }
 230             catch(const uno::Exception& /*e*/)
 231             {
 232             }
 233         }
 234         if ( !bRet ) // no command set or an error occurred, use Internal data handler
 235         {
 236             uno::Reference< lang::XInitialization> xIni(m_xInternal,uno::UNO_QUERY);
 237             if ( xIni.is() )
 238             {
 239                 uno::Sequence< uno::Any > aInitArgs(1);
 240                 beans::NamedValue aParam(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CreateDefaultData")),uno::makeAny(sal_True));
 241                 aInitArgs[0] <<= aParam;
 242                 xIni->initialize(aInitArgs);
 243             }
 244         }
 245
 246     }
 247     return m_xInternal->createDataSource(_aArguments);
 248 }
 249 // -----------------------------------------------------------------------------
 250
 251 uno::Sequence< beans::PropertyValue > SAL_CALL DatabaseDataProvider::detectArguments(const uno::Reference< chart2::data::XDataSource > & _xDataSource) throw (uno::RuntimeException)
 252 {
 253     ::comphelper::NamedValueCollection aArguments;
 254     aArguments.put( "CellRangeRepresentation", uno::Any( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "all" ) ) ) );
 255     aArguments.put( "DataRowSource", uno::makeAny( chart::ChartDataRowSource_COLUMNS ) );
 256     // internal data always contains labels and categories
 257     aArguments.put( "FirstCellAsLabel", uno::makeAny( sal_True ) );
 258
 259     sal_Bool bHasCategories = sal_False;
 260     if( _xDataSource.is())
 261     {
 262         uno::Sequence< uno::Reference< chart2::data::XLabeledDataSequence > > aSequences(_xDataSource->getDataSequences());
 263         const sal_Int32 nCount( aSequences.getLength());
 264         for( sal_Int32 nIdx=0; nIdx<nCount; ++nIdx )
 265         {
 266             if( aSequences[nIdx].is() )
 267             {
 268                 uno::Reference< beans::XPropertySet > xSeqProp( aSequences[nIdx]->getValues(), uno::UNO_QUERY );
 269                 ::rtl::OUString aRole;
 270                 if  (   xSeqProp.is()
 271                     &&  ( xSeqProp->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Role" ) ) ) >>= aRole )
 272                     &&  aRole == "categories"
 273                     )
 274                 {
 275                     bHasCategories = sal_True;
 276                     break;
 277                 }
 278             }
 279         }
 280     }
 281     aArguments.put( "HasCategories", uno::makeAny( bHasCategories ) );
 282     return aArguments.getPropertyValues();
 283 }
 284 // -----------------------------------------------------------------------------
 285
 286 ::sal_Bool SAL_CALL DatabaseDataProvider::createDataSequenceByRangeRepresentationPossible(const ::rtl::OUString & /*aRangeRepresentation*/) throw (uno::RuntimeException)
 287 {
 288     return sal_True;
 289 }
 290 // -----------------------------------------------------------------------------
 291 uno::Any DatabaseDataProvider::impl_getNumberFormatKey_nothrow(const ::rtl::OUString & _sRangeRepresentation) const
 292 {
 293     ::std::map< ::rtl::OUString,com::sun::star::uno::Any>::const_iterator aFind = m_aNumberFormats.find(_sRangeRepresentation);
 294     if ( aFind != m_aNumberFormats.end() )
 295         return aFind->second;
 296     return uno::makeAny(sal_Int32(0));
 297 }
 298 // -----------------------------------------------------------------------------
 299 uno::Reference< chart2::data::XDataSequence > SAL_CALL DatabaseDataProvider::createDataSequenceByRangeRepresentation(const ::rtl::OUString & _sRangeRepresentation) throw (uno::RuntimeException, lang::IllegalArgumentException)
 300 {
 301     osl::MutexGuard g(m_aMutex);
 302     uno::Reference< chart2::data::XDataSequence > xData = m_xInternal->createDataSequenceByRangeRepresentation(_sRangeRepresentation);
 303     uno::Reference<beans::XPropertySet> xProp(xData,uno::UNO_QUERY);
 304     const static ::rtl::OUString s_sNumberFormatKey(RTL_CONSTASCII_USTRINGPARAM("NumberFormatKey"));
 305     if ( xProp.is() && xProp->getPropertySetInfo()->hasPropertyByName(s_sNumberFormatKey) )
 306     {
 307         xProp->setPropertyValue(s_sNumberFormatKey,impl_getNumberFormatKey_nothrow(_sRangeRepresentation));
 308     }
 309     return xData;
 310 }
 311
 312 uno::Sequence< uno::Sequence< rtl::OUString > > SAL_CALL DatabaseDataProvider::getComplexRowDescriptions() throw (uno::RuntimeException)
 313 {
 314     return m_xComplexDescriptionAccess->getComplexRowDescriptions();
 315 }
 316 void SAL_CALL DatabaseDataProvider::setComplexRowDescriptions( const uno::Sequence< uno::Sequence< ::rtl::OUString > >& aRowDescriptions ) throw (uno::RuntimeException)
 317 {
 318     m_xComplexDescriptionAccess->setComplexRowDescriptions(aRowDescriptions);
 319 }
 320 uno::Sequence< uno::Sequence< rtl::OUString > > SAL_CALL DatabaseDataProvider::getComplexColumnDescriptions() throw (uno::RuntimeException)
 321 {
 322     return m_xComplexDescriptionAccess->getComplexColumnDescriptions();
 323 }
 324 void SAL_CALL DatabaseDataProvider::setComplexColumnDescriptions( const uno::Sequence< uno::Sequence< rtl::OUString > >& aColumnDescriptions ) throw (uno::RuntimeException)
 325 {
 326     m_xComplexDescriptionAccess->setComplexColumnDescriptions(aColumnDescriptions);
 327 }
 328 // ____ XChartDataArray ____
 329 uno::Sequence< uno::Sequence< double > > SAL_CALL DatabaseDataProvider::getData()    throw (uno::RuntimeException)
 330 {
 331     return m_xComplexDescriptionAccess->getData();
 332 }
 333
 334 void SAL_CALL DatabaseDataProvider::setData( const uno::Sequence< uno::Sequence< double > >& rDataInRows )    throw (uno::RuntimeException)
 335 {
 336     m_xComplexDescriptionAccess->setData(rDataInRows);
 337 }
 338
 339 void SAL_CALL DatabaseDataProvider::setRowDescriptions( const uno::Sequence< rtl::OUString >& aRowDescriptions )    throw (uno::RuntimeException)
 340 {
 341     m_xComplexDescriptionAccess->setRowDescriptions(aRowDescriptions);
 342 }
 343
 344 void SAL_CALL DatabaseDataProvider::setColumnDescriptions( const uno::Sequence< rtl::OUString >& aColumnDescriptions )    throw (uno::RuntimeException)
 345 {
 346     m_xComplexDescriptionAccess->setColumnDescriptions(aColumnDescriptions);
 347 }
 348
 349 uno::Sequence< rtl::OUString > SAL_CALL DatabaseDataProvider::getRowDescriptions()    throw (uno::RuntimeException)
 350 {
 351     return m_xComplexDescriptionAccess->getRowDescriptions();
 352 }
 353
 354 uno::Sequence< rtl::OUString > SAL_CALL DatabaseDataProvider::getColumnDescriptions()    throw (uno::RuntimeException)
 355 {
 356     return m_xComplexDescriptionAccess->getColumnDescriptions();
 357 }
 358
 359 // ____ XChartData (base of XChartDataArray) ____
 360 void SAL_CALL DatabaseDataProvider::addChartDataChangeEventListener(const uno::Reference< ::com::sun::star::chart::XChartDataChangeEventListener >& x)    throw (uno::RuntimeException)
 361 {
 362     m_xComplexDescriptionAccess->addChartDataChangeEventListener(x);
 363 }
 364
 365 void SAL_CALL DatabaseDataProvider::removeChartDataChangeEventListener(const uno::Reference< ::com::sun::star::chart::XChartDataChangeEventListener >& x)    throw (uno::RuntimeException)
 366 {
 367     m_xComplexDescriptionAccess->removeChartDataChangeEventListener(x);
 368 }
 369
 370 double SAL_CALL DatabaseDataProvider::getNotANumber()    throw (uno::RuntimeException)
 371 {
 372     return m_xComplexDescriptionAccess->getNotANumber();
 373 }
 374
 375 ::sal_Bool SAL_CALL DatabaseDataProvider::isNotANumber( double nNumber )    throw (uno::RuntimeException)
 376 {
 377     return m_xComplexDescriptionAccess->isNotANumber(nNumber);
 378 }
 379
 380 // -----------------------------------------------------------------------------
 381
 382 uno::Reference< sheet::XRangeSelection > SAL_CALL DatabaseDataProvider::getRangeSelection() throw (uno::RuntimeException)
 383 {
 384     // TODO: Exchange the default return implementation for "getRangeSelection" !!!
 385     // Exchange the default return implementation.
 386     // NOTE: Default initialized polymorphic structs can cause problems because of
 387     // missing default initialization of primitive types of some C++ compilers or
 388     // different Any initialization in Java and C++ polymorphic structs.
 389     return uno::Reference< sheet::XRangeSelection >();
 390 }
 391 // -----------------------------------------------------------------------------
 392 // chart2::data::XRangeXMLConversion:
 393 ::rtl::OUString SAL_CALL DatabaseDataProvider::convertRangeToXML(const ::rtl::OUString & _sRangeRepresentation) throw (uno::RuntimeException, lang::IllegalArgumentException)
 394 {
 395     osl::MutexGuard g(m_aMutex);
 396     return m_xRangeConversion->convertRangeToXML(_sRangeRepresentation);
 397 }
 398 // -----------------------------------------------------------------------------
 399
 400 ::rtl::OUString SAL_CALL DatabaseDataProvider::convertRangeFromXML(const ::rtl::OUString & _sXMLRange) throw (uno::RuntimeException, lang::IllegalArgumentException)
 401 {
 402     osl::MutexGuard g(m_aMutex);
 403     return m_xRangeConversion->convertRangeFromXML(_sXMLRange);
 404 }
 405 // -----------------------------------------------------------------------------
 406
 407 // com.sun.star.beans.XPropertySet:
 408 uno::Reference< beans::XPropertySetInfo > SAL_CALL DatabaseDataProvider::getPropertySetInfo() throw (uno::RuntimeException)
 409 {
 410     return ::cppu::PropertySetMixin< chart2::data::XDatabaseDataProvider >::getPropertySetInfo();
 411 }
 412 // -----------------------------------------------------------------------------
 413
 414 void SAL_CALL DatabaseDataProvider::setPropertyValue(const ::rtl::OUString & aPropertyName, const uno::Any & aValue) throw (uno::RuntimeException, beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException)
 415 {
 416     ::cppu::PropertySetMixin< chart2::data::XDatabaseDataProvider >::setPropertyValue(aPropertyName, aValue);
 417 }
 418 // -----------------------------------------------------------------------------
 419
 420 uno::Any SAL_CALL DatabaseDataProvider::getPropertyValue(const ::rtl::OUString & aPropertyName) throw (uno::RuntimeException, beans::UnknownPropertyException, lang::WrappedTargetException)
 421 {
 422     return ::cppu::PropertySetMixin< chart2::data::XDatabaseDataProvider >::getPropertyValue(aPropertyName);
 423 }
 424 // -----------------------------------------------------------------------------
 425
 426 void SAL_CALL DatabaseDataProvider::addPropertyChangeListener(const ::rtl::OUString & aPropertyName, const uno::Reference< beans::XPropertyChangeListener > & xListener) throw (uno::RuntimeException, beans::UnknownPropertyException, lang::WrappedTargetException)
 427 {
 428     ::cppu::PropertySetMixin< chart2::data::XDatabaseDataProvider >::addPropertyChangeListener(aPropertyName, xListener);
 429 }
 430 // -----------------------------------------------------------------------------
 431
 432 void SAL_CALL DatabaseDataProvider::removePropertyChangeListener(const ::rtl::OUString & aPropertyName, const uno::Reference< beans::XPropertyChangeListener > & xListener) throw (uno::RuntimeException, beans::UnknownPropertyException, lang::WrappedTargetException)
 433 {
 434     ::cppu::PropertySetMixin< chart2::data::XDatabaseDataProvider >::removePropertyChangeListener(aPropertyName, xListener);
 435 }
 436 // -----------------------------------------------------------------------------
 437
 438 void SAL_CALL DatabaseDataProvider::addVetoableChangeListener(const ::rtl::OUString & aPropertyName, const uno::Reference< beans::XVetoableChangeListener > & xListener) throw (uno::RuntimeException, beans::UnknownPropertyException, lang::WrappedTargetException)
 439 {
 440     ::cppu::PropertySetMixin< chart2::data::XDatabaseDataProvider >::addVetoableChangeListener(aPropertyName, xListener);
 441 }
 442 // -----------------------------------------------------------------------------
 443
 444 void SAL_CALL DatabaseDataProvider::removeVetoableChangeListener(const ::rtl::OUString & aPropertyName, const uno::Reference< beans::XVetoableChangeListener > & xListener) throw (uno::RuntimeException, beans::UnknownPropertyException, lang::WrappedTargetException)
 445 {
 446     ::cppu::PropertySetMixin< chart2::data::XDatabaseDataProvider >::removeVetoableChangeListener(aPropertyName, xListener);
 447 }
 448 // -----------------------------------------------------------------------------
 449
 450 // chart2::data::XDatabaseDataProvider:
 451 uno::Sequence< ::rtl::OUString > SAL_CALL DatabaseDataProvider::getMasterFields() throw (uno::RuntimeException)
 452 {
 453     osl::MutexGuard g(m_aMutex);
 454     return m_MasterFields;
 455 }
 456 // -----------------------------------------------------------------------------
 457
 458 void SAL_CALL DatabaseDataProvider::setMasterFields(const uno::Sequence< ::rtl::OUString > & the_value) throw (uno::RuntimeException)
 459 {
 460     impl_invalidateParameter_nothrow();
 461     set(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MasterFields")),the_value,m_MasterFields);
 462 }
 463 // -----------------------------------------------------------------------------
 464
 465 uno::Sequence< ::rtl::OUString > SAL_CALL DatabaseDataProvider::getDetailFields() throw (uno::RuntimeException)
 466 {
 467     osl::MutexGuard g(m_aMutex);
 468     return m_DetailFields;
 469 }
 470 // -----------------------------------------------------------------------------
 471
 472 void SAL_CALL DatabaseDataProvider::setDetailFields(const uno::Sequence< ::rtl::OUString > & the_value) throw (uno::RuntimeException)
 473 {
 474     set(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DetailFields")),the_value,m_DetailFields);
 475 }
 476 // -----------------------------------------------------------------------------
 477 ::rtl::OUString SAL_CALL DatabaseDataProvider::getCommand() throw (uno::RuntimeException)
 478 {
 479     osl::MutexGuard g(m_aMutex);
 480     return m_Command;
 481 }
 482 // -----------------------------------------------------------------------------
 483
 484 void SAL_CALL DatabaseDataProvider::setCommand(const ::rtl::OUString & the_value) throw (uno::RuntimeException)
 485 {
 486     {
 487         osl::MutexGuard g(m_aMutex);
 488         impl_invalidateParameter_nothrow();
 489         m_xAggregateSet->setPropertyValue( PROPERTY_COMMAND,   uno::makeAny( the_value ) );
 490     }
 491     set(PROPERTY_COMMAND,the_value,m_Command);
 492 }
 493 // -----------------------------------------------------------------------------
 494
 495 ::sal_Int32 SAL_CALL DatabaseDataProvider::getCommandType() throw (uno::RuntimeException)
 496 {
 497     osl::MutexGuard g(m_aMutex);
 498     return m_CommandType;
 499 }
 500 // -----------------------------------------------------------------------------
 501
 502 void SAL_CALL DatabaseDataProvider::setCommandType(::sal_Int32 the_value) throw (uno::RuntimeException)
 503 {
 504     {
 505         osl::MutexGuard g(m_aMutex);
 506         m_xAggregateSet->setPropertyValue( PROPERTY_COMMAND_TYPE,   uno::makeAny( the_value ) );
 507     }
 508     set(PROPERTY_COMMAND_TYPE,the_value,m_CommandType);
 509 }
 510 // -----------------------------------------------------------------------------
 511
 512 ::rtl::OUString SAL_CALL DatabaseDataProvider::getFilter() throw (uno::RuntimeException)
 513 {
 514     osl::MutexGuard g(m_aMutex);
 515     return m_aFilterManager.getFilterComponent( dbtools::FilterManager::fcPublicFilter );
 516 }
 517 // -----------------------------------------------------------------------------
 518
 519 void SAL_CALL DatabaseDataProvider::setFilter(const ::rtl::OUString & the_value) throw (uno::RuntimeException)
 520 {
 521     {
 522         osl::MutexGuard g(m_aMutex);
 523         m_aFilterManager.setFilterComponent( dbtools::FilterManager::fcPublicFilter, the_value );
 524     }
 525     set(PROPERTY_FILTER,the_value,m_Filter);
 526 }
 527 // -----------------------------------------------------------------------------
 528 ::sal_Bool SAL_CALL DatabaseDataProvider::getApplyFilter() throw (RuntimeException)
 529 {
 530     osl::MutexGuard g(m_aMutex);
 531     return m_ApplyFilter;
 532 }
 533 // -----------------------------------------------------------------------------
 534 void SAL_CALL DatabaseDataProvider::setApplyFilter( ::sal_Bool the_value ) throw (RuntimeException)
 535 {
 536     {
 537         osl::MutexGuard g(m_aMutex);
 538         m_xAggregateSet->setPropertyValue( PROPERTY_APPLYFILTER,   uno::makeAny( the_value ) );
 539     }
 540     set(PROPERTY_APPLYFILTER,the_value,m_ApplyFilter);
 541 }
 542 // -----------------------------------------------------------------------------
 543 ::rtl::OUString SAL_CALL DatabaseDataProvider::getHavingClause() throw (uno::RuntimeException)
 544 {
 545     osl::MutexGuard g(m_aMutex);
 546     return m_HavingClause;
 547 }
 548 // -----------------------------------------------------------------------------
 549 void SAL_CALL DatabaseDataProvider::setHavingClause( const ::rtl::OUString& the_value ) throw (beans::UnknownPropertyException, uno::RuntimeException)
 550 {
 551     {
 552         osl::MutexGuard g(m_aMutex);
 553         m_xAggregateSet->setPropertyValue( PROPERTY_HAVING_CLAUSE,   uno::makeAny( the_value ) );
 554     }
 555     set(PROPERTY_HAVING_CLAUSE,the_value,m_HavingClause);
 556 }
 557 // -----------------------------------------------------------------------------
 558 ::rtl::OUString SAL_CALL DatabaseDataProvider::getGroupBy() throw (uno::RuntimeException)
 559 {
 560     osl::MutexGuard g(m_aMutex);
 561     return m_GroupBy;
 562 }
 563 // -----------------------------------------------------------------------------
 564 void SAL_CALL DatabaseDataProvider::setGroupBy( const ::rtl::OUString& the_value ) throw (beans::UnknownPropertyException, uno::RuntimeException)
 565 {
 566     {
 567         osl::MutexGuard g(m_aMutex);
 568         m_xAggregateSet->setPropertyValue( PROPERTY_GROUP_BY,   uno::makeAny( the_value ) );
 569     }
 570     set(PROPERTY_GROUP_BY,the_value,m_GroupBy);
 571 }
 572 // -----------------------------------------------------------------------------
 573 ::rtl::OUString SAL_CALL DatabaseDataProvider::getOrder() throw (uno::RuntimeException)
 574 {
 575     osl::MutexGuard g(m_aMutex);
 576     return m_Order;
 577 }
 578 // -----------------------------------------------------------------------------
 579 void SAL_CALL DatabaseDataProvider::setOrder( const ::rtl::OUString& the_value ) throw (uno::RuntimeException)
 580 {
 581     {
 582         osl::MutexGuard g(m_aMutex);
 583         m_xAggregateSet->setPropertyValue( PROPERTY_ORDER,   uno::makeAny( the_value ) );
 584     }
 585     set(PROPERTY_ORDER,the_value,m_Order);
 586 }
 587 // -----------------------------------------------------------------------------
 588 ::sal_Bool SAL_CALL DatabaseDataProvider::getEscapeProcessing() throw (uno::RuntimeException)
 589 {
 590     osl::MutexGuard g(m_aMutex);
 591     return m_EscapeProcessing;
 592 }
 593 // -----------------------------------------------------------------------------
 594
 595 void SAL_CALL DatabaseDataProvider::setEscapeProcessing(::sal_Bool the_value) throw (uno::RuntimeException)
 596 {
 597     set(PROPERTY_ESCAPE_PROCESSING,the_value,m_EscapeProcessing);
 598 }
 599 // -----------------------------------------------------------------------------
 600 ::sal_Int32 SAL_CALL DatabaseDataProvider::getRowLimit() throw (uno::RuntimeException)
 601 {
 602     osl::MutexGuard g(m_aMutex);
 603     return m_RowLimit;
 604 }
 605 // -----------------------------------------------------------------------------
 606
 607 void SAL_CALL DatabaseDataProvider::setRowLimit(::sal_Int32 the_value) throw (uno::RuntimeException)
 608 {
 609     set(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RowLimit")),the_value,m_RowLimit);
 610 }
 611 // -----------------------------------------------------------------------------
 612 uno::Reference< sdbc::XConnection > SAL_CALL DatabaseDataProvider::getActiveConnection() throw (uno::RuntimeException)
 613 {
 614     osl::MutexGuard g(m_aMutex);
 615     return m_xActiveConnection;
 616 }
 617 // -----------------------------------------------------------------------------
 618
 619 void SAL_CALL DatabaseDataProvider::setActiveConnection(const uno::Reference< sdbc::XConnection > & the_value) throw (uno::RuntimeException, lang::IllegalArgumentException)
 620 {
 621     if ( !the_value.is() )
 622         throw lang::IllegalArgumentException();
 623     set(PROPERTY_ACTIVE_CONNECTION,the_value,m_xActiveConnection);
 624 }
 625 // -----------------------------------------------------------------------------
 626 ::rtl::OUString SAL_CALL DatabaseDataProvider::getDataSourceName() throw (uno::RuntimeException)
 627 {
 628     osl::MutexGuard g(m_aMutex);
 629     return m_DataSourceName;
 630 }
 631 // -----------------------------------------------------------------------------
 632
 633 void SAL_CALL DatabaseDataProvider::setDataSourceName(const ::rtl::OUString& the_value) throw (uno::RuntimeException)
 634 {
 635     set(PROPERTY_DATASOURCENAME,the_value,m_DataSourceName);
 636 }
 637 // -----------------------------------------------------------------------------
 638 void DatabaseDataProvider::impl_executeRowSet_throw(::osl::ResettableMutexGuard& _rClearForNotifies)
 639 {
 640     if ( impl_fillParameters_nothrow(_rClearForNotifies) )
 641         m_xRowSet->execute();
 642 }
 643
 644 // -----------------------------------------------------------------------------
 645 namespace
 646 {
 647     struct ColumnDescription
 648     {
 649         ::rtl::OUString sName;
 650         sal_Int32       nResultSetPosition;
 651         sal_Int32       nDataType;
 652
 653         ColumnDescription()
 654             :sName()
 655             ,nResultSetPosition( 0 )
 656             ,nDataType( sdbc::DataType::VARCHAR )
 657         {
 658         }
 659         explicit ColumnDescription( const ::rtl::OUString& i_rName )
 660             :sName( i_rName )
 661             ,nResultSetPosition( 0 )
 662             ,nDataType( sdbc::DataType::VARCHAR )
 663         {
 664         }
 665     };
 666
 667     struct CreateColumnDescription : public ::std::unary_function< ::rtl::OUString, ColumnDescription >
 668     {
 669         ColumnDescription operator()( const ::rtl::OUString& i_rName )
 670         {
 671             return ColumnDescription( i_rName );
 672         }
 673     };
 674
 675     struct SelectColumnName : public ::std::unary_function< ColumnDescription, ::rtl::OUString >
 676     {
 677         const ::rtl::OUString& operator()( const ColumnDescription& i_rColumn )
 678         {
 679             return i_rColumn.sName;
 680         }
 681     };
 682 }
 683
 684 // -----------------------------------------------------------------------------
 685 void DatabaseDataProvider::impl_fillInternalDataProvider_throw(sal_Bool _bHasCategories,const uno::Sequence< ::rtl::OUString >& i_aColumnNames)
 686 {
 687     // clear the data before fill the new one
 688     uno::Reference< sdbcx::XColumnsSupplier > xColSup(m_xRowSet,uno::UNO_QUERY_THROW);
 689     uno::Reference< container::XNameAccess > xColumns( xColSup->getColumns(), uno::UNO_SET_THROW );
 690     const uno::Sequence< ::rtl::OUString > aRowSetColumnNames( xColumns->getElementNames() );
 691
 692     typedef ::std::vector< ColumnDescription > ColumnDescriptions;
 693     ColumnDescriptions aColumns;
 694     bool bFirstColumnIsCategory = _bHasCategories;
 695     if ( i_aColumnNames.getLength() )
 696     {
 697         // some normalizations ...
 698         uno::Sequence< ::rtl::OUString > aImposedColumnNames( i_aColumnNames );
 699
 700         // strangely, there exist documents where the ColumnDescriptions end with a number of empty strings. /me
 701         // thinks they're generated when you have a chart based on a result set with n columns, but remove some
 702         // of those columns from the chart - it looks like a bug in the report XML export to me.
 703         // So, get rid of the "trailing" empty columns
 704         sal_Int32 nLastNonEmptyColName = aImposedColumnNames.getLength() - 1;
 705         for ( ; nLastNonEmptyColName >= 0; --nLastNonEmptyColName )
 706         {
 707             if ( !aImposedColumnNames[ nLastNonEmptyColName ].isEmpty() )
 708                 break;
 709         }
 710         aImposedColumnNames.realloc( nLastNonEmptyColName + 1 );
 711
 712         // second, for X-Y-charts the ColumnDescriptions exported by chart miss the name of the first (non-category)
 713         // column. This, this results in a ColumnDescriptions array like <"", "col2", "col3">, where you'd expect
 714         // <"col1", "col2", "col3">.
 715         // Fix this with some heuristics:
 716         if ( ( aImposedColumnNames.getLength() > 0 ) && ( !aImposedColumnNames[0].isEmpty() ) )
 717         {
 718             const sal_Int32 nAssumedRowSetColumnIndex = _bHasCategories ? 1 : 0;
 719             if ( nAssumedRowSetColumnIndex < aRowSetColumnNames.getLength() )
 720                 aImposedColumnNames[0] = aRowSetColumnNames[ nAssumedRowSetColumnIndex ];
 721         }
 722
 723         const sal_Int32 nCount = aImposedColumnNames.getLength();
 724         for ( sal_Int32 i = 0 ; i < nCount; ++i )
 725         {
 726             const ::rtl::OUString sColumnName( aImposedColumnNames[i] );
 727             if ( !xColumns->hasByName( sColumnName ) )
 728                 continue;
 729
 730             if ( _bHasCategories && aColumns.empty() )
 731             {
 732                 if ( aRowSetColumnNames.getLength() )
 733                     aColumns.push_back( ColumnDescription( aRowSetColumnNames[0] ) );
 734                 else
 735                     aColumns.push_back( ColumnDescription( sColumnName ) );
 736                 bFirstColumnIsCategory = true;
 737             }
 738             aColumns.push_back( ColumnDescription( sColumnName ) );
 739         }
 740     }
 741     if ( aColumns.empty() )
 742     {
 743         aColumns.resize( aRowSetColumnNames.getLength() );
 744         ::std::transform(
 745             aRowSetColumnNames.getConstArray(),
 746             aRowSetColumnNames.getConstArray() + aRowSetColumnNames.getLength(),
 747             aColumns.begin(),
 748             CreateColumnDescription()
 749        );
 750     }
 751
 752     // fill the data
 753     uno::Reference< sdbc::XResultSet> xRes( m_xRowSet, uno::UNO_QUERY_THROW );
 754     uno::Reference< sdbc::XRow> xRow( m_xRowSet,uno::UNO_QUERY_THROW );
 755     uno::Reference< sdbc::XResultSetMetaDataSupplier > xSuppMeta( m_xRowSet,uno::UNO_QUERY_THROW );
 756     uno::Reference< sdbc::XResultSetMetaData > xResultSetMetaData( xSuppMeta->getMetaData(), uno::UNO_SET_THROW );
 757     uno::Reference< sdbc::XColumnLocate > xColumnLocate( m_xRowSet, uno::UNO_QUERY_THROW );
 758
 759     for (   ColumnDescriptions::iterator col = aColumns.begin();
 760             col != aColumns.end();
 761             ++col
 762          )
 763     {
 764         col->nResultSetPosition = xColumnLocate->findColumn( col->sName );
 765
 766         const uno::Reference< beans::XPropertySet > xColumn( xColumns->getByName( col->sName ), uno::UNO_QUERY_THROW );
 767         const uno::Any aNumberFormat( xColumn->getPropertyValue( PROPERTY_NUMBERFORMAT ) );
 768         OSL_VERIFY( xColumn->getPropertyValue( PROPERTY_TYPE ) >>= col->nDataType );
 769
 770         const sal_Int32 columnIndex = col - aColumns.begin();
 771         const ::rtl::OUString sRangeName = ::rtl::OUString::valueOf( columnIndex );
 772         m_aNumberFormats.insert( ::std::map< ::rtl::OUString, uno::Any >::value_type( sRangeName, aNumberFormat ) );
 773     }
 774
 775     ::std::vector< ::rtl::OUString > aRowLabels;
 776     ::std::vector< ::std::vector< double > > aDataValues;
 777     sal_Int32 nRowCount = 0;
 778     ::connectivity::ORowSetValue aValue;
 779     while( xRes->next() && (!m_RowLimit || nRowCount < m_RowLimit) )
 780     {
 781         ++nRowCount;
 782
 783         aValue.fill( aColumns[0].nResultSetPosition, aColumns[0].nDataType, xRow );
 784         aRowLabels.push_back( aValue.getString() );
 785
 786         ::std::vector< double > aRow;
 787         for (   ColumnDescriptions::const_iterator col = aColumns.begin();
 788                 col != aColumns.end();
 789                 ++col
 790             )
 791         {
 792             if ( bFirstColumnIsCategory && ( col == aColumns.begin() )  )
 793                 continue;
 794
 795             aValue.fill( col->nResultSetPosition, col->nDataType, xRow );
 796             if ( aValue.isNull() )
 797             {
 798                 double nValue;
 799                 ::rtl::math::setNan( &nValue );
 800                 aRow.push_back( nValue );
 801             }
 802             else
 803                 aRow.push_back( aValue.getDouble() );
 804         }
 805
 806         aDataValues.push_back( aRow );
 807     }
 808
 809     // insert default data when no rows exist
 810     if ( !nRowCount )
 811     {
 812         nRowCount = 3;
 813         const double fDefaultData[ ] =
 814             { 9.10, 3.20, 4.54,
 815               2.40, 8.80, 9.65,
 816               3.10, 1.50, 3.70,
 817               4.30, 9.02, 6.20 };
 818         for(sal_Int32 h = 0,k = 0; h < nRowCount; ++h,++k )
 819         {
 820             aRowLabels.push_back(::rtl::OUString::valueOf(h+1));
 821             ::std::vector< double > aRow;
 822             const sal_Int32 nSize = sizeof(fDefaultData)/sizeof(fDefaultData[0]);
 823             for (size_t j = 0; j < (aColumns.size()-1); ++j,++k)
 824             {
 825                 if ( k >= nSize )
 826                     k = 0;
 827                 aRow.push_back(fDefaultData[k]);
 828             }
 829             aDataValues.push_back(aRow);
 830         }
 831     }
 832
 833     uno::Reference< chart::XChartDataArray> xData(m_xInternal,uno::UNO_QUERY);
 834     xData->setRowDescriptions(uno::Sequence< ::rtl::OUString >(&(*aRowLabels.begin()),aRowLabels.size()));
 835
 836     const size_t nOffset = bFirstColumnIsCategory ? 1 : 0;
 837     uno::Sequence< ::rtl::OUString > aColumnDescriptions( aColumns.size() - nOffset );
 838     ::std::transform(
 839         aColumns.begin() + nOffset,
 840         aColumns.end(),
 841         aColumnDescriptions.getArray(),
 842         SelectColumnName()
 843     );
 844     xData->setColumnDescriptions( aColumnDescriptions );
 845
 846     uno::Sequence< uno::Sequence< double > > aData(aDataValues.size());
 847     uno::Sequence< double >* pDataIter  = aData.getArray();
 848     uno::Sequence< double >* pDataEnd   = pDataIter + aData.getLength();
 849     for(sal_Int32 i= 0;pDataIter != pDataEnd; ++pDataIter,++i )
 850     {
 851         if ( !aDataValues[i].empty() )
 852             *pDataIter = uno::Sequence< double >(&(*(aDataValues[i]).begin()),(aDataValues[i]).size());
 853     }
 854     xData->setData(aData);
 855 }
 856 // -----------------------------------------------------------------------------
 857 void DatabaseDataProvider::impl_fillRowSet_throw()
 858 {
 859     m_xAggregateSet->setPropertyValue( PROPERTY_FILTER,   uno::makeAny( getFilter() ) );
 860     uno::Reference< sdbc::XParameters> xParam(m_xRowSet,uno::UNO_QUERY_THROW);
 861     xParam->clearParameters( );
 862 }
 863 // -----------------------------------------------------------------------------
 864 bool DatabaseDataProvider::impl_fillParameters_nothrow( ::osl::ResettableMutexGuard& _rClearForNotifies)
 865 {
 866     // do we have to fill the parameters again?
 867     if ( !m_aParameterManager.isUpToDate() )
 868         m_aParameterManager.updateParameterInfo( m_aFilterManager );
 869
 870     if ( m_aParameterManager.isUpToDate() )
 871         return m_aParameterManager.fillParameterValues( m_xHandler, _rClearForNotifies );
 872
 873     return true;
 874 }
 875 // com::sun::star::sdbc::XParameters
 876 //------------------------------------------------------------------------------
 877 void SAL_CALL DatabaseDataProvider::setNull(sal_Int32 parameterIndex, sal_Int32 sqlType) throw( SQLException, RuntimeException )
 878 {
 879     m_aParameterManager.setNull(parameterIndex, sqlType);
 880 }
 881
 882 //------------------------------------------------------------------------------
 883 void SAL_CALL DatabaseDataProvider::setObjectNull(sal_Int32 parameterIndex, sal_Int32 sqlType, const ::rtl::OUString& typeName) throw( SQLException, RuntimeException )
 884 {
 885     m_aParameterManager.setObjectNull(parameterIndex, sqlType, typeName);
 886 }
 887
 888 //------------------------------------------------------------------------------
 889 void SAL_CALL DatabaseDataProvider::setBoolean(sal_Int32 parameterIndex, sal_Bool x) throw( SQLException, RuntimeException )
 890 {
 891     m_aParameterManager.setBoolean(parameterIndex, x);
 892 }
 893
 894 //------------------------------------------------------------------------------
 895 void SAL_CALL DatabaseDataProvider::setByte(sal_Int32 parameterIndex, sal_Int8 x) throw( SQLException, RuntimeException )
 896 {
 897     m_aParameterManager.setByte(parameterIndex, x);
 898 }
 899
 900 //------------------------------------------------------------------------------
 901 void SAL_CALL DatabaseDataProvider::setShort(sal_Int32 parameterIndex, sal_Int16 x) throw( SQLException, RuntimeException )
 902 {
 903     m_aParameterManager.setShort(parameterIndex, x);
 904 }
 905
 906 //------------------------------------------------------------------------------
 907 void SAL_CALL DatabaseDataProvider::setInt(sal_Int32 parameterIndex, sal_Int32 x) throw( SQLException, RuntimeException )
 908 {
 909     m_aParameterManager.setInt(parameterIndex, x);
 910 }
 911
 912 //------------------------------------------------------------------------------
 913 void SAL_CALL DatabaseDataProvider::setLong(sal_Int32 parameterIndex, sal_Int64 x) throw( SQLException, RuntimeException )
 914 {
 915     m_aParameterManager.setLong(parameterIndex, x);
 916 }
 917
 918 //------------------------------------------------------------------------------
 919 void SAL_CALL DatabaseDataProvider::setFloat(sal_Int32 parameterIndex, float x) throw( SQLException, RuntimeException )
 920 {
 921     m_aParameterManager.setFloat(parameterIndex, x);
 922 }
 923
 924 //------------------------------------------------------------------------------
 925 void SAL_CALL DatabaseDataProvider::setDouble(sal_Int32 parameterIndex, double x) throw( SQLException, RuntimeException )
 926 {
 927     m_aParameterManager.setDouble(parameterIndex, x);
 928 }
 929
 930 //------------------------------------------------------------------------------
 931 void SAL_CALL DatabaseDataProvider::setString(sal_Int32 parameterIndex, const ::rtl::OUString& x) throw( SQLException, RuntimeException )
 932 {
 933     m_aParameterManager.setString(parameterIndex, x);
 934 }
 935
 936 //------------------------------------------------------------------------------
 937 void SAL_CALL DatabaseDataProvider::setBytes(sal_Int32 parameterIndex, const uno::Sequence< sal_Int8 >& x) throw( SQLException, RuntimeException )
 938 {
 939     m_aParameterManager.setBytes(parameterIndex, x);
 940 }
 941
 942 //------------------------------------------------------------------------------
 943 void SAL_CALL DatabaseDataProvider::setDate(sal_Int32 parameterIndex, const util::Date& x) throw( SQLException, RuntimeException )
 944 {
 945     m_aParameterManager.setDate(parameterIndex, x);
 946 }
 947
 948 //------------------------------------------------------------------------------
 949 void SAL_CALL DatabaseDataProvider::setTime(sal_Int32 parameterIndex, const util::Time& x) throw( SQLException, RuntimeException )
 950 {
 951     m_aParameterManager.setTime(parameterIndex, x);
 952 }
 953
 954 //------------------------------------------------------------------------------
 955 void SAL_CALL DatabaseDataProvider::setTimestamp(sal_Int32 parameterIndex, const util::DateTime& x) throw( SQLException, RuntimeException )
 956 {
 957     m_aParameterManager.setTimestamp(parameterIndex, x);
 958 }
 959
 960 //------------------------------------------------------------------------------
 961 void SAL_CALL DatabaseDataProvider::setBinaryStream(sal_Int32 parameterIndex, const uno::Reference<io::XInputStream>& x, sal_Int32 length) throw( SQLException, RuntimeException )
 962 {
 963     m_aParameterManager.setBinaryStream(parameterIndex, x, length);
 964 }
 965
 966 //------------------------------------------------------------------------------
 967 void SAL_CALL DatabaseDataProvider::setCharacterStream(sal_Int32 parameterIndex, const uno::Reference<io::XInputStream>& x, sal_Int32 length) throw( SQLException, RuntimeException )
 968 {
 969     m_aParameterManager.setCharacterStream(parameterIndex, x, length);
 970 }
 971
 972 //------------------------------------------------------------------------------
 973 void SAL_CALL DatabaseDataProvider::setObjectWithInfo(sal_Int32 parameterIndex, const uno::Any& x, sal_Int32 targetSqlType, sal_Int32 scale) throw( SQLException, RuntimeException )
 974 {
 975     m_aParameterManager.setObjectWithInfo(parameterIndex, x, targetSqlType, scale);
 976 }
 977
 978 //------------------------------------------------------------------------------
 979 void SAL_CALL DatabaseDataProvider::setObject(sal_Int32 parameterIndex, const uno::Any& x) throw( SQLException, RuntimeException )
 980 {
 981     m_aParameterManager.setObject(parameterIndex, x);
 982 }
 983
 984 //------------------------------------------------------------------------------
 985 void SAL_CALL DatabaseDataProvider::setRef(sal_Int32 parameterIndex, const uno::Reference<sdbc::XRef>& x) throw( SQLException, RuntimeException )
 986 {
 987     m_aParameterManager.setRef(parameterIndex, x);
 988 }
 989
 990 //------------------------------------------------------------------------------
 991 void SAL_CALL DatabaseDataProvider::setBlob(sal_Int32 parameterIndex, const uno::Reference<sdbc::XBlob>& x) throw( SQLException, RuntimeException )
 992 {
 993     m_aParameterManager.setBlob(parameterIndex, x);
 994 }
 995
 996 //------------------------------------------------------------------------------
 997 void SAL_CALL DatabaseDataProvider::setClob(sal_Int32 parameterIndex, const uno::Reference<sdbc::XClob>& x) throw( SQLException, RuntimeException )
 998 {
 999     m_aParameterManager.setClob(parameterIndex, x);
1000 }
1001
1002 //------------------------------------------------------------------------------
1003 void SAL_CALL DatabaseDataProvider::setArray(sal_Int32 parameterIndex, const Reference<sdbc::XArray>& x) throw( SQLException, RuntimeException )
1004 {
1005     m_aParameterManager.setArray(parameterIndex, x);
1006 }
1007
1008 //------------------------------------------------------------------------------
1009 void SAL_CALL DatabaseDataProvider::clearParameters() throw( SQLException, RuntimeException )
1010 {
1011     m_aParameterManager.clearParameters();
1012 }
1013 //==============================================================================
1014 // com::sun::star::sdbc::XRowSet
1015 //------------------------------------------------------------------------------
1016 void SAL_CALL DatabaseDataProvider::execute() throw( SQLException, RuntimeException )
1017 {
1018     uno::Sequence< beans::PropertyValue > aEmpty;
1019     createDataSource(aEmpty);
1020 }
1021 //------------------------------------------------------------------------------
1022 void SAL_CALL DatabaseDataProvider::addRowSetListener(const uno::Reference<sdbc::XRowSetListener>& _rListener) throw( RuntimeException )
1023 {
1024     if (m_xRowSet.is())
1025         m_xRowSet->addRowSetListener(_rListener);
1026 }
1027
1028 //------------------------------------------------------------------------------
1029 void SAL_CALL DatabaseDataProvider::removeRowSetListener(const uno::Reference<sdbc::XRowSetListener>& _rListener) throw( RuntimeException )
1030 {
1031     if (m_xRowSet.is())
1032         m_xRowSet->removeRowSetListener(_rListener);
1033 }
1034 //==============================================================================
1035 // com::sun::star::sdbc::XResultSet
1036 //------------------------------------------------------------------------------
1037 sal_Bool SAL_CALL DatabaseDataProvider::next() throw( SQLException, RuntimeException )
1038 {
1039     return m_xRowSet->next();
1040 }
1041
1042 //------------------------------------------------------------------------------
1043 sal_Bool SAL_CALL DatabaseDataProvider::isBeforeFirst() throw( SQLException, RuntimeException )
1044 {
1045     return m_xRowSet->isBeforeFirst();
1046 }
1047
1048 //------------------------------------------------------------------------------
1049 sal_Bool SAL_CALL DatabaseDataProvider::isAfterLast() throw( SQLException, RuntimeException )
1050 {
1051     return m_xRowSet->isAfterLast();
1052 }
1053
1054 //------------------------------------------------------------------------------
1055 sal_Bool SAL_CALL DatabaseDataProvider::isFirst() throw( SQLException, RuntimeException )
1056 {
1057     return m_xRowSet->isFirst();
1058 }
1059
1060 //------------------------------------------------------------------------------
1061 sal_Bool SAL_CALL DatabaseDataProvider::isLast() throw( SQLException, RuntimeException )
1062 {
1063     return m_xRowSet->isLast();
1064 }
1065
1066 //------------------------------------------------------------------------------
1067 void SAL_CALL DatabaseDataProvider::beforeFirst() throw( SQLException, RuntimeException )
1068 {
1069     m_xRowSet->beforeFirst();
1070 }
1071
1072 //------------------------------------------------------------------------------
1073 void SAL_CALL DatabaseDataProvider::afterLast() throw( SQLException, RuntimeException )
1074 {
1075     m_xRowSet->afterLast();
1076 }
1077
1078 //------------------------------------------------------------------------------
1079 sal_Bool SAL_CALL DatabaseDataProvider::first() throw( SQLException, RuntimeException )
1080 {
1081     return m_xRowSet->first();
1082 }
1083
1084 //------------------------------------------------------------------------------
1085 sal_Bool SAL_CALL DatabaseDataProvider::last() throw( SQLException, RuntimeException )
1086 {
1087     return m_xRowSet->last();
1088 }
1089
1090 //------------------------------------------------------------------------------
1091 sal_Int32 SAL_CALL DatabaseDataProvider::getRow() throw( SQLException, RuntimeException )
1092 {
1093     return m_xRowSet->getRow();
1094 }
1095
1096 //------------------------------------------------------------------------------
1097 sal_Bool SAL_CALL DatabaseDataProvider::absolute(sal_Int32 row) throw( SQLException, RuntimeException )
1098 {
1099     return m_xRowSet->absolute(row);
1100 }
1101
1102 //------------------------------------------------------------------------------
1103 sal_Bool SAL_CALL DatabaseDataProvider::relative(sal_Int32 rows) throw( SQLException, RuntimeException )
1104 {
1105     return m_xRowSet->relative(rows);
1106 }
1107
1108 //------------------------------------------------------------------------------
1109 sal_Bool SAL_CALL DatabaseDataProvider::previous() throw( SQLException, RuntimeException )
1110 {
1111     return m_xRowSet->previous();
1112 }
1113
1114 //------------------------------------------------------------------------------
1115 void SAL_CALL DatabaseDataProvider::refreshRow() throw( SQLException, RuntimeException )
1116 {
1117     m_xRowSet->refreshRow();
1118 }
1119
1120 //------------------------------------------------------------------------------
1121 sal_Bool SAL_CALL DatabaseDataProvider::rowUpdated() throw( SQLException, RuntimeException )
1122 {
1123     return m_xRowSet->rowUpdated();
1124 }
1125
1126 //------------------------------------------------------------------------------
1127 sal_Bool SAL_CALL DatabaseDataProvider::rowInserted() throw( SQLException, RuntimeException )
1128 {
1129     return m_xRowSet->rowInserted();
1130 }
1131
1132 //------------------------------------------------------------------------------
1133 sal_Bool SAL_CALL DatabaseDataProvider::rowDeleted() throw( SQLException, RuntimeException )
1134 {
1135     return m_xRowSet->rowDeleted();
1136 }
1137
1138 //------------------------------------------------------------------------------
1139 uno::Reference< uno::XInterface > SAL_CALL DatabaseDataProvider::getStatement() throw( SQLException, RuntimeException )
1140 {
1141     return m_xRowSet->getStatement();
1142 }
1143 // -----------------------------------------------------------------------------
1144 uno::Reference< uno::XInterface > SAL_CALL DatabaseDataProvider::getParent(  ) throw (uno::RuntimeException)
1145 {
1146     return m_xParent;
1147 }
1148 // -----------------------------------------------------------------------------
1149 void SAL_CALL DatabaseDataProvider::setParent( const uno::Reference< uno::XInterface >& _xParent ) throw (lang::NoSupportException, uno::RuntimeException)
1150 {
1151     osl::MutexGuard g(m_aMutex);
1152     m_xParent = _xParent;
1153 }
1154 // -----------------------------------------------------------------------------
1155 void DatabaseDataProvider::impl_invalidateParameter_nothrow()
1156 {
1157     osl::MutexGuard g(m_aMutex);
1158     m_aParameterManager.clearAllParameterInformation();
1159 }
1160 // -----------------------------------------------------------------------------
1161 } // namespace dbaccess
1162
1163 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */