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