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