Line data Source code
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 <resultset.hxx>
21 : #include "dbastrings.hrc"
22 : #include "apitools.hxx"
23 : #include <com/sun/star/lang/DisposedException.hpp>
24 : #include <com/sun/star/sdbc/ResultSetType.hpp>
25 : #include <cppuhelper/supportsservice.hxx>
26 : #include <cppuhelper/typeprovider.hxx>
27 : #include <comphelper/property.hxx>
28 : #include <comphelper/sequence.hxx>
29 : #include <comphelper/types.hxx>
30 : #include <tools/debug.hxx>
31 : #include <tools/diagnose_ex.h>
32 : #include <datacolumn.hxx>
33 : #include <com/sun/star/beans/PropertyAttribute.hpp>
34 : #include <connectivity/dbexception.hxx>
35 : #include <connectivity/dbtools.hxx>
36 : #include <cppuhelper/exc_hlp.hxx>
37 : #include <osl/thread.h>
38 :
39 :
40 : using namespace ::com::sun::star::sdbc;
41 : using namespace ::com::sun::star::sdbcx;
42 : using namespace ::com::sun::star::beans;
43 : using namespace ::com::sun::star::uno;
44 : using namespace ::com::sun::star::lang;
45 : using namespace ::com::sun::star::container;
46 : using namespace ::cppu;
47 : using namespace ::osl;
48 : using namespace dbaccess;
49 : using namespace dbtools;
50 :
51 :
52 22 : OResultSet::OResultSet(const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XResultSet >& _xResultSet,
53 : const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& _xStatement,
54 : sal_Bool _bCaseSensitive)
55 : :OResultSetBase(m_aMutex)
56 : ,OPropertySetHelper(OResultSetBase::rBHelper)
57 : ,m_xDelegatorResultSet(_xResultSet)
58 : ,m_aWarnings( Reference< XWarningsSupplier >( _xResultSet, UNO_QUERY ) )
59 : ,m_nResultSetType(0)
60 : ,m_nResultSetConcurrency(0)
61 22 : ,m_bIsBookmarkable(sal_False)
62 : {
63 : SAL_INFO("dbaccess", "OResultSet::OResultSet" );
64 :
65 22 : m_pColumns = new OColumns(*this, m_aMutex, _bCaseSensitive, ::std::vector< OUString>(), NULL,NULL);
66 :
67 : try
68 : {
69 22 : m_aStatement = _xStatement;
70 22 : m_xDelegatorResultSetUpdate = m_xDelegatorResultSetUpdate.query( m_xDelegatorResultSet );
71 22 : m_xDelegatorRow = m_xDelegatorRow.query( m_xDelegatorResultSet );
72 22 : m_xDelegatorRowUpdate = m_xDelegatorRowUpdate.query( m_xDelegatorResultSet );
73 :
74 22 : Reference< XPropertySet > xSet(m_xDelegatorResultSet, UNO_QUERY);
75 22 : xSet->getPropertyValue(PROPERTY_RESULTSETTYPE) >>= m_nResultSetType;
76 22 : xSet->getPropertyValue(PROPERTY_RESULTSETCONCURRENCY) >>= m_nResultSetConcurrency;
77 :
78 : // test for Bookmarks
79 22 : if (ResultSetType::FORWARD_ONLY != m_nResultSetType)
80 : {
81 21 : Reference <XPropertySetInfo > xInfo(xSet->getPropertySetInfo());
82 21 : if (xInfo->hasPropertyByName(PROPERTY_ISBOOKMARKABLE))
83 : {
84 21 : m_bIsBookmarkable = ::comphelper::getBOOL(xSet->getPropertyValue(PROPERTY_ISBOOKMARKABLE));
85 : OSL_ENSURE( !m_bIsBookmarkable || Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY).is(),
86 : "OResultSet::OResultSet: aggregate is inconsistent in it's bookmarkable attribute!" );
87 21 : m_bIsBookmarkable = m_bIsBookmarkable && Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY).is();
88 21 : }
89 22 : }
90 : }
91 0 : catch (const Exception&)
92 : {
93 : }
94 22 : }
95 :
96 60 : OResultSet::~OResultSet()
97 : {
98 20 : m_pColumns->acquire();
99 20 : m_pColumns->disposing();
100 20 : delete m_pColumns;
101 :
102 40 : }
103 :
104 : // com::sun::star::lang::XTypeProvider
105 0 : Sequence< Type > OResultSet::getTypes() throw (RuntimeException, std::exception)
106 : {
107 : SAL_INFO("dbaccess", "OResultSet::getTypes" );
108 0 : OTypeCollection aTypes(::getCppuType( (const Reference< XPropertySet > *)0 ),
109 0 : OResultSetBase::getTypes());
110 :
111 0 : return aTypes.getTypes();
112 : }
113 :
114 0 : Sequence< sal_Int8 > OResultSet::getImplementationId() throw (RuntimeException, std::exception)
115 : {
116 0 : return css::uno::Sequence<sal_Int8>();
117 : }
118 :
119 : // com::sun::star::uno::XInterface
120 277 : Any OResultSet::queryInterface( const Type & rType ) throw (RuntimeException, std::exception)
121 : {
122 277 : Any aIface = OResultSetBase::queryInterface( rType );
123 277 : if (!aIface.hasValue())
124 84 : aIface = ::cppu::queryInterface(
125 : rType,
126 42 : static_cast< XPropertySet * >( this ));
127 :
128 277 : return aIface;
129 : }
130 :
131 701 : void OResultSet::acquire() throw ()
132 : {
133 701 : OResultSetBase::acquire();
134 701 : }
135 :
136 671 : void OResultSet::release() throw ()
137 : {
138 671 : OResultSetBase::release();
139 671 : }
140 :
141 :
142 : // OResultSetBase
143 22 : void OResultSet::disposing()
144 : {
145 : SAL_INFO("dbaccess", "OResultSet::disposing" );
146 22 : OPropertySetHelper::disposing();
147 :
148 22 : MutexGuard aGuard(m_aMutex);
149 :
150 : // free the columns
151 22 : m_pColumns->disposing();
152 :
153 : // close the pending result set
154 22 : Reference< XCloseable > (m_xDelegatorResultSet, UNO_QUERY)->close();
155 :
156 22 : m_xDelegatorResultSet = NULL;
157 22 : m_xDelegatorRow = NULL;
158 22 : m_xDelegatorRowUpdate = NULL;
159 :
160 22 : m_aStatement.clear();
161 22 : }
162 :
163 : // XCloseable
164 0 : void OResultSet::close(void) throw( SQLException, RuntimeException, std::exception )
165 : {
166 : SAL_INFO("dbaccess", "OResultSet::close" );
167 : {
168 0 : MutexGuard aGuard( m_aMutex );
169 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
170 : }
171 0 : dispose();
172 0 : }
173 :
174 : // XServiceInfo
175 0 : OUString OResultSet::getImplementationName( ) throw(RuntimeException, std::exception)
176 : {
177 : //SAL_INFO("dbaccess", "OResultSet::getImplementationName" );
178 0 : return OUString("com.sun.star.sdb.OResultSet");
179 : }
180 :
181 0 : sal_Bool OResultSet::supportsService( const OUString& _rServiceName ) throw (RuntimeException, std::exception)
182 : {
183 0 : return cppu::supportsService(this, _rServiceName);
184 : }
185 :
186 0 : Sequence< OUString > OResultSet::getSupportedServiceNames( ) throw (RuntimeException, std::exception)
187 : {
188 : //SAL_INFO("dbaccess", "OResultSet::getSupportedServiceNames" );
189 0 : Sequence< OUString > aSNS( 2 );
190 0 : aSNS[0] = SERVICE_SDBC_RESULTSET;
191 0 : aSNS[1] = SERVICE_SDB_RESULTSET;
192 0 : return aSNS;
193 : }
194 :
195 : // com::sun::star::beans::XPropertySet
196 20 : Reference< XPropertySetInfo > OResultSet::getPropertySetInfo() throw (RuntimeException, std::exception)
197 : {
198 : //SAL_INFO("dbaccess", "OResultSet::getPropertySetInfo" );
199 20 : return createPropertySetInfo( getInfoHelper() ) ;
200 : }
201 :
202 : // comphelper::OPropertyArrayUsageHelper
203 9 : ::cppu::IPropertyArrayHelper* OResultSet::createArrayHelper( ) const
204 : {
205 : //SAL_INFO("dbaccess", "OResultSet::createArrayHelper" );
206 9 : BEGIN_PROPERTY_HELPER(6)
207 9 : DECL_PROP1(CURSORNAME, OUString, READONLY);
208 9 : DECL_PROP0(FETCHDIRECTION, sal_Int32);
209 9 : DECL_PROP0(FETCHSIZE, sal_Int32);
210 9 : DECL_PROP1_BOOL(ISBOOKMARKABLE, READONLY);
211 9 : DECL_PROP1(RESULTSETCONCURRENCY, sal_Int32, READONLY);
212 9 : DECL_PROP1(RESULTSETTYPE, sal_Int32, READONLY);
213 9 : END_PROPERTY_HELPER();
214 : }
215 :
216 : // cppu::OPropertySetHelper
217 60 : ::cppu::IPropertyArrayHelper& OResultSet::getInfoHelper()
218 : {
219 : //SAL_INFO("dbaccess", "OResultSet::getInfoHelper" );
220 60 : return *getArrayHelper();
221 : }
222 :
223 0 : sal_Bool OResultSet::convertFastPropertyValue(Any & rConvertedValue, Any & rOldValue, sal_Int32 nHandle, const Any& rValue ) throw( IllegalArgumentException )
224 : {
225 : //SAL_INFO("dbaccess", "OResultSet::convertFastPropertyValue" );
226 : // be lazy ...
227 0 : rConvertedValue = rValue;
228 0 : getFastPropertyValue( rOldValue, nHandle );
229 0 : return sal_True;
230 : }
231 :
232 0 : void OResultSet::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const Any& rValue ) throw (Exception, std::exception)
233 : {
234 : //SAL_INFO("dbaccess", "OResultSet::setFastPropertyValue_NoBroadcast" );
235 : // set it for the driver result set
236 0 : Reference< XPropertySet > xSet(m_xDelegatorResultSet, UNO_QUERY);
237 0 : switch (nHandle)
238 : {
239 : case PROPERTY_ID_FETCHDIRECTION:
240 0 : xSet->setPropertyValue(PROPERTY_FETCHDIRECTION, rValue);
241 0 : break;
242 : case PROPERTY_ID_FETCHSIZE:
243 0 : xSet->setPropertyValue(PROPERTY_FETCHSIZE, rValue);
244 0 : break;
245 : default:
246 : SAL_WARN("dbaccess", "unknown Property");
247 0 : }
248 0 : }
249 :
250 20 : void OResultSet::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
251 : {
252 : //SAL_INFO("dbaccess", "OResultSet::getFastPropertyValue" );
253 20 : switch (nHandle)
254 : {
255 : case PROPERTY_ID_ISBOOKMARKABLE:
256 : {
257 20 : sal_Bool bVal = m_bIsBookmarkable;
258 20 : rValue.setValue(&bVal, getBooleanCppuType());
259 20 : } break;
260 : default:
261 : {
262 : // get the property name
263 0 : OUString aPropName;
264 : sal_Int16 nAttributes;
265 0 : const_cast<OResultSet*>(this)->getInfoHelper().
266 0 : fillPropertyMembersByHandle(&aPropName, &nAttributes, nHandle);
267 : OSL_ENSURE(!aPropName.isEmpty(), "property not found?");
268 :
269 : // now read the value
270 0 : rValue = Reference< XPropertySet >(m_xDelegatorResultSet, UNO_QUERY)->getPropertyValue(aPropName);
271 : }
272 : }
273 20 : }
274 :
275 : // XWarningsSupplier
276 1 : Any OResultSet::getWarnings(void) throw( SQLException, RuntimeException, std::exception )
277 : {
278 : SAL_INFO("dbaccess", "OResultSet::getWarnings" );
279 1 : MutexGuard aGuard(m_aMutex);
280 1 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
281 1 : return m_aWarnings.getWarnings();
282 : }
283 :
284 0 : void OResultSet::clearWarnings(void) throw( SQLException, RuntimeException, std::exception )
285 : {
286 : SAL_INFO("dbaccess", "OResultSet::clearWarnings" );
287 0 : MutexGuard aGuard(m_aMutex);
288 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
289 0 : m_aWarnings.clearWarnings();
290 0 : }
291 :
292 : // ::com::sun::star::sdbc::XResultSetMetaDataSupplier
293 42 : Reference< XResultSetMetaData > OResultSet::getMetaData(void) throw( SQLException, RuntimeException, std::exception )
294 : {
295 : SAL_INFO("dbaccess", "OResultSet::getMetaData" );
296 42 : MutexGuard aGuard(m_aMutex);
297 42 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
298 :
299 42 : return Reference< XResultSetMetaDataSupplier >(m_xDelegatorResultSet, UNO_QUERY)->getMetaData();
300 : }
301 :
302 : // ::com::sun::star::sdbc::XColumnLocate
303 5 : sal_Int32 OResultSet::findColumn(const OUString& columnName) throw( SQLException, RuntimeException, std::exception )
304 : {
305 : SAL_INFO("dbaccess", "OResultSet::findColumn" );
306 5 : MutexGuard aGuard(m_aMutex);
307 5 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
308 :
309 5 : return Reference< XColumnLocate >(m_xDelegatorResultSet, UNO_QUERY)->findColumn(columnName);
310 : }
311 :
312 : namespace
313 : {
314 0 : static Reference< XDatabaseMetaData > lcl_getDBMetaDataFromStatement_nothrow( const Reference< XInterface >& _rxStatement )
315 : {
316 0 : Reference< XDatabaseMetaData > xDBMetaData;
317 : try
318 : {
319 0 : Reference< XStatement > xStatement( _rxStatement, UNO_QUERY );
320 0 : Reference< XPreparedStatement > xPreparedStatement( _rxStatement, UNO_QUERY );
321 0 : Reference< XConnection > xConn;
322 0 : if ( xStatement.is() )
323 0 : xConn = xStatement->getConnection();
324 0 : else if ( xPreparedStatement.is() )
325 0 : xConn = xPreparedStatement->getConnection();
326 0 : if ( xConn.is() )
327 0 : xDBMetaData = xConn->getMetaData();
328 : }
329 0 : catch( const Exception& )
330 : {
331 : DBG_UNHANDLED_EXCEPTION();
332 : }
333 0 : return xDBMetaData;
334 : }
335 : }
336 :
337 : // ::com::sun::star::sdbcx::XColumnsSupplier
338 0 : Reference< ::com::sun::star::container::XNameAccess > OResultSet::getColumns(void) throw( RuntimeException, std::exception )
339 : {
340 : SAL_INFO("dbaccess", "OResultSet::getColumns" );
341 0 : MutexGuard aGuard(m_aMutex);
342 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
343 :
344 : // do we have to populate the columns
345 0 : if (!m_pColumns->isInitialized())
346 : {
347 : // get the metadata
348 0 : Reference< XResultSetMetaData > xMetaData = Reference< XResultSetMetaDataSupplier >(m_xDelegatorResultSet, UNO_QUERY)->getMetaData();
349 :
350 0 : sal_Int32 nColCount = 0;
351 : // do we have columns
352 : try
353 : {
354 0 : Reference< XDatabaseMetaData > xDBMetaData( lcl_getDBMetaDataFromStatement_nothrow( getStatement() ) );
355 0 : nColCount = xMetaData->getColumnCount();
356 :
357 0 : for ( sal_Int32 i = 0; i < nColCount; ++i)
358 : {
359 : // retrieve the name of the column
360 0 : OUString sName = xMetaData->getColumnName(i + 1);
361 0 : ODataColumn* pColumn = new ODataColumn(xMetaData, m_xDelegatorRow, m_xDelegatorRowUpdate, i + 1, xDBMetaData);
362 :
363 : // don't silently assume that the name is unique - result set implementations
364 : // are allowed to return duplicate names, but we are required to have
365 : // unique column names
366 0 : if ( m_pColumns->hasByName( sName ) )
367 0 : sName = ::dbtools::createUniqueName( m_pColumns, sName );
368 :
369 0 : m_pColumns->append( sName, pColumn );
370 0 : }
371 : }
372 0 : catch ( const SQLException& )
373 : {
374 : DBG_UNHANDLED_EXCEPTION();
375 : }
376 0 : m_pColumns->setInitialized();
377 :
378 : #if OSL_DEBUG_LEVEL > 0
379 : // some sanity checks. Especially in case we auto-adjusted the column names above,
380 : // this might be reasonable
381 : try
382 : {
383 : const Reference< XNameAccess > xColNames( static_cast< XNameAccess* >( m_pColumns ), UNO_SET_THROW );
384 : const Sequence< OUString > aNames( xColNames->getElementNames() );
385 : OSL_POSTCOND( aNames.getLength() == nColCount,
386 : "OResultSet::getColumns: invalid column count!" );
387 : for ( const OUString* pName = aNames.getConstArray();
388 : pName != aNames.getConstArray() + aNames.getLength();
389 : ++pName
390 : )
391 : {
392 : Reference< XPropertySet > xColProps( xColNames->getByName( *pName ), UNO_QUERY_THROW );
393 : OUString sName;
394 : OSL_VERIFY( xColProps->getPropertyValue( PROPERTY_NAME ) >>= sName );
395 : OSL_POSTCOND( sName == *pName, "OResultSet::getColumns: invalid column name!" );
396 : }
397 :
398 : }
399 : catch( const Exception& )
400 : {
401 : DBG_UNHANDLED_EXCEPTION();
402 : }
403 : #endif
404 : }
405 0 : return m_pColumns;
406 : }
407 :
408 : // ::com::sun::star::sdbc::XRow
409 2884 : sal_Bool OResultSet::wasNull(void) throw( SQLException, RuntimeException, std::exception )
410 : {
411 : SAL_INFO("dbaccess", "OResultSet::wasNull" );
412 2884 : MutexGuard aGuard(m_aMutex);
413 2884 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
414 :
415 2884 : return m_xDelegatorRow->wasNull();
416 : }
417 :
418 2802 : OUString OResultSet::getString(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
419 : {
420 : //SAL_INFO("dbaccess", "OResultSet::getString" );
421 2802 : MutexGuard aGuard(m_aMutex);
422 2802 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
423 :
424 2802 : return m_xDelegatorRow->getString(columnIndex);
425 : }
426 :
427 28 : sal_Bool OResultSet::getBoolean(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
428 : {
429 : //SAL_INFO("dbaccess", "OResultSet::getBoolean" );
430 28 : MutexGuard aGuard(m_aMutex);
431 28 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
432 :
433 28 : return m_xDelegatorRow->getBoolean(columnIndex);
434 : }
435 :
436 0 : sal_Int8 OResultSet::getByte(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
437 : {
438 : SAL_INFO("dbaccess", "OResultSet::getByte" );
439 0 : MutexGuard aGuard(m_aMutex);
440 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
441 :
442 0 : return m_xDelegatorRow->getByte(columnIndex);
443 : }
444 :
445 1 : sal_Int16 OResultSet::getShort(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
446 : {
447 : SAL_INFO("dbaccess", "OResultSet::getShort" );
448 1 : MutexGuard aGuard(m_aMutex);
449 1 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
450 :
451 1 : return m_xDelegatorRow->getShort(columnIndex);
452 : }
453 :
454 1 : sal_Int32 OResultSet::getInt(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
455 : {
456 : SAL_INFO("dbaccess", "OResultSet::getInt" );
457 1 : MutexGuard aGuard(m_aMutex);
458 1 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
459 :
460 1 : return m_xDelegatorRow->getInt(columnIndex);
461 : }
462 :
463 1 : sal_Int64 OResultSet::getLong(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
464 : {
465 : SAL_INFO("dbaccess", "OResultSet::getLong" );
466 1 : MutexGuard aGuard(m_aMutex);
467 1 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
468 :
469 1 : return m_xDelegatorRow->getLong(columnIndex);
470 : }
471 :
472 0 : float OResultSet::getFloat(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
473 : {
474 : SAL_INFO("dbaccess", "OResultSet::getFloat" );
475 0 : MutexGuard aGuard(m_aMutex);
476 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
477 :
478 0 : return m_xDelegatorRow->getFloat(columnIndex);
479 : }
480 :
481 0 : double OResultSet::getDouble(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
482 : {
483 : SAL_INFO("dbaccess", "OResultSet::getDouble" );
484 0 : MutexGuard aGuard(m_aMutex);
485 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
486 :
487 0 : return m_xDelegatorRow->getDouble(columnIndex);
488 : }
489 :
490 0 : Sequence< sal_Int8 > OResultSet::getBytes(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
491 : {
492 : SAL_INFO("dbaccess", "OResultSet::getBytes" );
493 0 : MutexGuard aGuard(m_aMutex);
494 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
495 :
496 0 : return m_xDelegatorRow->getBytes(columnIndex);
497 : }
498 :
499 56 : ::com::sun::star::util::Date OResultSet::getDate(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
500 : {
501 : SAL_INFO("dbaccess", "OResultSet::getDate" );
502 56 : MutexGuard aGuard(m_aMutex);
503 56 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
504 :
505 56 : return m_xDelegatorRow->getDate(columnIndex);
506 : }
507 :
508 0 : ::com::sun::star::util::Time OResultSet::getTime(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
509 : {
510 : SAL_INFO("dbaccess", "OResultSet::getTime" );
511 0 : MutexGuard aGuard(m_aMutex);
512 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
513 :
514 0 : return m_xDelegatorRow->getTime(columnIndex);
515 : }
516 :
517 0 : ::com::sun::star::util::DateTime OResultSet::getTimestamp(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
518 : {
519 : SAL_INFO("dbaccess", "OResultSet::getTimestamp" );
520 0 : MutexGuard aGuard(m_aMutex);
521 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
522 :
523 0 : return m_xDelegatorRow->getTimestamp(columnIndex);
524 : }
525 :
526 0 : Reference< ::com::sun::star::io::XInputStream > OResultSet::getBinaryStream(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
527 : {
528 : SAL_INFO("dbaccess", "OResultSet::getBinaryStream" );
529 0 : MutexGuard aGuard(m_aMutex);
530 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
531 :
532 0 : return m_xDelegatorRow->getBinaryStream(columnIndex);
533 : }
534 :
535 0 : Reference< ::com::sun::star::io::XInputStream > OResultSet::getCharacterStream(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
536 : {
537 : SAL_INFO("dbaccess", "OResultSet::getCharacterStream" );
538 0 : MutexGuard aGuard(m_aMutex);
539 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
540 :
541 0 : return m_xDelegatorRow->getCharacterStream(columnIndex);
542 : }
543 :
544 0 : Any OResultSet::getObject(sal_Int32 columnIndex, const Reference< ::com::sun::star::container::XNameAccess > & typeMap) throw( SQLException, RuntimeException, std::exception )
545 : {
546 : SAL_INFO("dbaccess", "OResultSet::getObject" );
547 0 : MutexGuard aGuard(m_aMutex);
548 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
549 :
550 0 : return m_xDelegatorRow->getObject(columnIndex, typeMap);
551 : }
552 :
553 0 : Reference< XRef > OResultSet::getRef(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
554 : {
555 : SAL_INFO("dbaccess", "OResultSet::getRef" );
556 0 : MutexGuard aGuard(m_aMutex);
557 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
558 :
559 0 : return m_xDelegatorRow->getRef(columnIndex);
560 : }
561 :
562 0 : Reference< XBlob > OResultSet::getBlob(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
563 : {
564 : SAL_INFO("dbaccess", "OResultSet::getBlob" );
565 0 : MutexGuard aGuard(m_aMutex);
566 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
567 :
568 0 : return m_xDelegatorRow->getBlob(columnIndex);
569 : }
570 :
571 0 : Reference< XClob > OResultSet::getClob(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
572 : {
573 : SAL_INFO("dbaccess", "OResultSet::getClob" );
574 0 : MutexGuard aGuard(m_aMutex);
575 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
576 :
577 0 : return m_xDelegatorRow->getClob(columnIndex);
578 : }
579 :
580 0 : Reference< XArray > OResultSet::getArray(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
581 : {
582 : SAL_INFO("dbaccess", "OResultSet::getArray" );
583 0 : MutexGuard aGuard(m_aMutex);
584 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
585 :
586 0 : return m_xDelegatorRow->getArray(columnIndex);
587 : }
588 :
589 : // ::com::sun::star::sdbc::XRowUpdate
590 0 : void OResultSet::updateNull(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
591 : {
592 : SAL_INFO("dbaccess", "OResultSet::updateNull" );
593 0 : MutexGuard aGuard(m_aMutex);
594 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
595 :
596 0 : checkReadOnly();
597 :
598 0 : m_xDelegatorRowUpdate->updateNull(columnIndex);
599 0 : }
600 :
601 0 : void OResultSet::updateBoolean(sal_Int32 columnIndex, sal_Bool x) throw( SQLException, RuntimeException, std::exception )
602 : {
603 : SAL_INFO("dbaccess", "OResultSet::updateBoolean" );
604 0 : MutexGuard aGuard(m_aMutex);
605 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
606 :
607 0 : checkReadOnly();
608 :
609 0 : m_xDelegatorRowUpdate->updateBoolean(columnIndex, x);
610 0 : }
611 :
612 0 : void OResultSet::updateByte(sal_Int32 columnIndex, sal_Int8 x) throw( SQLException, RuntimeException, std::exception )
613 : {
614 : SAL_INFO("dbaccess", "OResultSet::updateByte" );
615 0 : MutexGuard aGuard(m_aMutex);
616 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
617 :
618 0 : checkReadOnly();
619 :
620 0 : m_xDelegatorRowUpdate->updateByte(columnIndex, x);
621 0 : }
622 :
623 0 : void OResultSet::updateShort(sal_Int32 columnIndex, sal_Int16 x) throw( SQLException, RuntimeException, std::exception )
624 : {
625 : SAL_INFO("dbaccess", "OResultSet::updateShort" );
626 0 : MutexGuard aGuard(m_aMutex);
627 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
628 :
629 0 : checkReadOnly();
630 :
631 0 : m_xDelegatorRowUpdate->updateShort(columnIndex, x);
632 0 : }
633 :
634 0 : void OResultSet::updateInt(sal_Int32 columnIndex, sal_Int32 x) throw( SQLException, RuntimeException, std::exception )
635 : {
636 : SAL_INFO("dbaccess", "OResultSet::updateInt" );
637 0 : MutexGuard aGuard(m_aMutex);
638 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
639 :
640 0 : checkReadOnly();
641 :
642 0 : m_xDelegatorRowUpdate->updateInt(columnIndex, x);
643 0 : }
644 :
645 0 : void OResultSet::updateLong(sal_Int32 columnIndex, sal_Int64 x) throw( SQLException, RuntimeException, std::exception )
646 : {
647 : SAL_INFO("dbaccess", "OResultSet::updateLong" );
648 0 : MutexGuard aGuard(m_aMutex);
649 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
650 :
651 0 : checkReadOnly();
652 :
653 0 : m_xDelegatorRowUpdate->updateLong(columnIndex, x);
654 0 : }
655 :
656 0 : void OResultSet::updateFloat(sal_Int32 columnIndex, float x) throw( SQLException, RuntimeException, std::exception )
657 : {
658 : SAL_INFO("dbaccess", "OResultSet::updateFloat" );
659 0 : MutexGuard aGuard(m_aMutex);
660 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
661 :
662 0 : checkReadOnly();
663 :
664 0 : m_xDelegatorRowUpdate->updateFloat(columnIndex, x);
665 0 : }
666 :
667 0 : void OResultSet::updateDouble(sal_Int32 columnIndex, double x) throw( SQLException, RuntimeException, std::exception )
668 : {
669 : SAL_INFO("dbaccess", "OResultSet::updateDouble" );
670 0 : MutexGuard aGuard(m_aMutex);
671 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
672 :
673 0 : checkReadOnly();
674 :
675 0 : m_xDelegatorRowUpdate->updateDouble(columnIndex, x);
676 0 : }
677 :
678 5 : void OResultSet::updateString(sal_Int32 columnIndex, const OUString& x) throw( SQLException, RuntimeException, std::exception )
679 : {
680 : SAL_INFO("dbaccess", "OResultSet::updateString" );
681 5 : MutexGuard aGuard(m_aMutex);
682 5 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
683 :
684 5 : checkReadOnly();
685 :
686 5 : m_xDelegatorRowUpdate->updateString(columnIndex, x);
687 5 : }
688 :
689 0 : void OResultSet::updateBytes(sal_Int32 columnIndex, const Sequence< sal_Int8 >& x) throw( SQLException, RuntimeException, std::exception )
690 : {
691 : SAL_INFO("dbaccess", "OResultSet::updateBytes" );
692 0 : MutexGuard aGuard(m_aMutex);
693 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
694 :
695 0 : checkReadOnly();
696 :
697 0 : m_xDelegatorRowUpdate->updateBytes(columnIndex, x);
698 0 : }
699 :
700 0 : void OResultSet::updateDate(sal_Int32 columnIndex, const ::com::sun::star::util::Date& x) throw( SQLException, RuntimeException, std::exception )
701 : {
702 : SAL_INFO("dbaccess", "OResultSet::updateDate" );
703 0 : MutexGuard aGuard(m_aMutex);
704 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
705 :
706 0 : checkReadOnly();
707 :
708 0 : m_xDelegatorRowUpdate->updateDate(columnIndex, x);
709 0 : }
710 :
711 0 : void OResultSet::updateTime(sal_Int32 columnIndex, const ::com::sun::star::util::Time& x) throw( SQLException, RuntimeException, std::exception )
712 : {
713 : SAL_INFO("dbaccess", "OResultSet::updateTime" );
714 0 : MutexGuard aGuard(m_aMutex);
715 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
716 :
717 0 : checkReadOnly();
718 :
719 0 : m_xDelegatorRowUpdate->updateTime(columnIndex, x);
720 0 : }
721 :
722 0 : void OResultSet::updateTimestamp(sal_Int32 columnIndex, const ::com::sun::star::util::DateTime& x) throw( SQLException, RuntimeException, std::exception )
723 : {
724 : SAL_INFO("dbaccess", "OResultSet::updateTimestamp" );
725 0 : MutexGuard aGuard(m_aMutex);
726 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
727 :
728 0 : checkReadOnly();
729 :
730 0 : m_xDelegatorRowUpdate->updateTimestamp(columnIndex, x);
731 0 : }
732 :
733 0 : void OResultSet::updateBinaryStream(sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream > & x, sal_Int32 length) throw( SQLException, RuntimeException, std::exception )
734 : {
735 : SAL_INFO("dbaccess", "OResultSet::updateBinaryStream" );
736 0 : MutexGuard aGuard(m_aMutex);
737 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
738 :
739 0 : checkReadOnly();
740 :
741 0 : m_xDelegatorRowUpdate->updateBinaryStream(columnIndex, x, length);
742 0 : }
743 :
744 0 : void OResultSet::updateCharacterStream(sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream > & x, sal_Int32 length) throw( SQLException, RuntimeException, std::exception )
745 : {
746 : SAL_INFO("dbaccess", "OResultSet::updateCharacterStream" );
747 0 : MutexGuard aGuard(m_aMutex);
748 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
749 :
750 0 : checkReadOnly();
751 :
752 0 : m_xDelegatorRowUpdate->updateCharacterStream(columnIndex, x, length);
753 0 : }
754 :
755 0 : void OResultSet::updateNumericObject(sal_Int32 columnIndex, const Any& x, sal_Int32 scale) throw( SQLException, RuntimeException, std::exception )
756 : {
757 : SAL_INFO("dbaccess", "OResultSet::updateNumericObject" );
758 0 : MutexGuard aGuard(m_aMutex);
759 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
760 :
761 0 : checkReadOnly();
762 :
763 0 : m_xDelegatorRowUpdate->updateNumericObject(columnIndex, x, scale);
764 0 : }
765 :
766 0 : void OResultSet::updateObject(sal_Int32 columnIndex, const Any& x) throw( SQLException, RuntimeException, std::exception )
767 : {
768 : SAL_INFO("dbaccess", "OResultSet::updateObject" );
769 0 : MutexGuard aGuard(m_aMutex);
770 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
771 :
772 0 : checkReadOnly();
773 :
774 0 : m_xDelegatorRowUpdate->updateObject(columnIndex, x);
775 0 : }
776 :
777 : // ::com::sun::star::sdbc::XResultSet
778 171 : sal_Bool OResultSet::next(void) throw( SQLException, RuntimeException, std::exception )
779 : {
780 : SAL_INFO("dbaccess", "OResultSet::next" );
781 171 : MutexGuard aGuard(m_aMutex);
782 171 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
783 :
784 171 : return m_xDelegatorResultSet->next();
785 : }
786 :
787 0 : sal_Bool OResultSet::isBeforeFirst(void) throw( SQLException, RuntimeException, std::exception )
788 : {
789 : SAL_INFO("dbaccess", "OResultSet::isBeforeFirst" );
790 0 : MutexGuard aGuard(m_aMutex);
791 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
792 :
793 0 : return m_xDelegatorResultSet->isBeforeFirst();
794 : }
795 :
796 0 : sal_Bool OResultSet::isAfterLast(void) throw( SQLException, RuntimeException, std::exception )
797 : {
798 : SAL_INFO("dbaccess", "OResultSet::isAfterLast" );
799 0 : MutexGuard aGuard(m_aMutex);
800 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
801 :
802 0 : return m_xDelegatorResultSet->isAfterLast();
803 : }
804 :
805 0 : sal_Bool OResultSet::isFirst(void) throw( SQLException, RuntimeException, std::exception )
806 : {
807 : SAL_INFO("dbaccess", "OResultSet::isFirst" );
808 0 : MutexGuard aGuard(m_aMutex);
809 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
810 :
811 0 : return m_xDelegatorResultSet->isFirst();
812 : }
813 :
814 0 : sal_Bool OResultSet::isLast(void) throw( SQLException, RuntimeException, std::exception )
815 : {
816 : SAL_INFO("dbaccess", "OResultSet::isLast" );
817 0 : MutexGuard aGuard(m_aMutex);
818 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
819 :
820 0 : return m_xDelegatorResultSet->isLast();
821 : }
822 :
823 25 : void OResultSet::beforeFirst(void) throw( SQLException, RuntimeException, std::exception )
824 : {
825 : SAL_INFO("dbaccess", "OResultSet::beforeFirst" );
826 25 : MutexGuard aGuard(m_aMutex);
827 25 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
828 :
829 25 : m_xDelegatorResultSet->beforeFirst();
830 25 : }
831 :
832 5 : void OResultSet::afterLast(void) throw( SQLException, RuntimeException, std::exception )
833 : {
834 : SAL_INFO("dbaccess", "OResultSet::afterLast" );
835 5 : MutexGuard aGuard(m_aMutex);
836 5 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
837 :
838 5 : m_xDelegatorResultSet->afterLast();
839 5 : }
840 :
841 25 : sal_Bool OResultSet::first(void) throw( SQLException, RuntimeException, std::exception )
842 : {
843 : SAL_INFO("dbaccess", "OResultSet::first" );
844 25 : MutexGuard aGuard(m_aMutex);
845 25 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
846 :
847 25 : return m_xDelegatorResultSet->first();
848 : }
849 :
850 4 : sal_Bool OResultSet::last(void) throw( SQLException, RuntimeException, std::exception )
851 : {
852 : SAL_INFO("dbaccess", "OResultSet::last" );
853 4 : MutexGuard aGuard(m_aMutex);
854 4 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
855 :
856 4 : return m_xDelegatorResultSet->last();
857 : }
858 :
859 37 : sal_Int32 OResultSet::getRow(void) throw( SQLException, RuntimeException, std::exception )
860 : {
861 : SAL_INFO("dbaccess", "OResultSet::getRow" );
862 37 : MutexGuard aGuard(m_aMutex);
863 37 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
864 :
865 37 : return m_xDelegatorResultSet->getRow();
866 : }
867 :
868 64 : sal_Bool OResultSet::absolute(sal_Int32 row) throw( SQLException, RuntimeException, std::exception )
869 : {
870 : SAL_INFO("dbaccess", "OResultSet::absolute" );
871 64 : MutexGuard aGuard(m_aMutex);
872 64 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
873 :
874 64 : return m_xDelegatorResultSet->absolute(row);
875 : }
876 :
877 0 : sal_Bool OResultSet::relative(sal_Int32 rows) throw( SQLException, RuntimeException, std::exception )
878 : {
879 : SAL_INFO("dbaccess", "OResultSet::relative" );
880 0 : MutexGuard aGuard(m_aMutex);
881 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
882 :
883 0 : return m_xDelegatorResultSet->relative(rows);
884 : }
885 :
886 21 : sal_Bool OResultSet::previous(void) throw( SQLException, RuntimeException, std::exception )
887 : {
888 : SAL_INFO("dbaccess", "OResultSet::previous" );
889 21 : MutexGuard aGuard(m_aMutex);
890 21 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
891 :
892 21 : return m_xDelegatorResultSet->previous();
893 : }
894 :
895 1 : void OResultSet::refreshRow(void) throw( SQLException, RuntimeException, std::exception )
896 : {
897 : SAL_INFO("dbaccess", "OResultSet::refreshRow" );
898 1 : MutexGuard aGuard(m_aMutex);
899 1 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
900 :
901 1 : m_xDelegatorResultSet->refreshRow();
902 1 : }
903 :
904 1 : sal_Bool OResultSet::rowUpdated(void) throw( SQLException, RuntimeException, std::exception )
905 : {
906 : SAL_INFO("dbaccess", "OResultSet::rowUpdated" );
907 1 : MutexGuard aGuard(m_aMutex);
908 1 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
909 :
910 1 : return m_xDelegatorResultSet->rowUpdated();
911 : }
912 :
913 2 : sal_Bool OResultSet::rowInserted(void) throw( SQLException, RuntimeException, std::exception )
914 : {
915 : SAL_INFO("dbaccess", "OResultSet::rowInserted" );
916 2 : MutexGuard aGuard(m_aMutex);
917 2 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
918 :
919 2 : return m_xDelegatorResultSet->rowInserted();
920 : }
921 :
922 1 : sal_Bool OResultSet::rowDeleted(void) throw( SQLException, RuntimeException, std::exception )
923 : {
924 : SAL_INFO("dbaccess", "OResultSet::rowDeleted" );
925 1 : MutexGuard aGuard(m_aMutex);
926 1 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
927 :
928 1 : return m_xDelegatorResultSet->rowDeleted();
929 : }
930 :
931 42 : Reference< XInterface > OResultSet::getStatement(void) throw( SQLException, RuntimeException, std::exception )
932 : {
933 : SAL_INFO("dbaccess", "OResultSet::getStatement" );
934 42 : MutexGuard aGuard(m_aMutex);
935 42 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
936 :
937 42 : return m_aStatement;
938 : }
939 :
940 : // ::com::sun::star::sdbcx::XRowLocate
941 175 : Any OResultSet::getBookmark(void) throw( SQLException, RuntimeException, std::exception )
942 : {
943 : SAL_INFO("dbaccess", "OResultSet::getBookmark" );
944 175 : MutexGuard aGuard(m_aMutex);
945 175 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
946 :
947 175 : checkBookmarkable();
948 :
949 175 : return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->getBookmark();
950 : }
951 :
952 16 : sal_Bool OResultSet::moveToBookmark(const Any& bookmark) throw( SQLException, RuntimeException, std::exception )
953 : {
954 : SAL_INFO("dbaccess", "OResultSet::moveToBookmark" );
955 16 : MutexGuard aGuard(m_aMutex);
956 16 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
957 :
958 16 : checkBookmarkable();
959 :
960 16 : return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->moveToBookmark(bookmark);
961 : }
962 :
963 0 : sal_Bool OResultSet::moveRelativeToBookmark(const Any& bookmark, sal_Int32 rows) throw( SQLException, RuntimeException, std::exception )
964 : {
965 : SAL_INFO("dbaccess", "OResultSet::moveRelativeToBookmark" );
966 0 : MutexGuard aGuard(m_aMutex);
967 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
968 :
969 0 : checkBookmarkable();
970 :
971 0 : return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->moveRelativeToBookmark(bookmark, rows);
972 : }
973 :
974 148 : sal_Int32 OResultSet::compareBookmarks(const Any& _first, const Any& _second) throw( SQLException, RuntimeException, std::exception )
975 : {
976 : SAL_INFO("dbaccess", "OResultSet::compareBookmarks" );
977 148 : MutexGuard aGuard(m_aMutex);
978 148 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
979 :
980 148 : checkBookmarkable();
981 :
982 148 : return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->compareBookmarks(_first, _second);
983 : }
984 :
985 1 : sal_Bool OResultSet::hasOrderedBookmarks(void) throw( SQLException, RuntimeException, std::exception )
986 : {
987 : SAL_INFO("dbaccess", "OResultSet::hasOrderedBookmarks" );
988 1 : MutexGuard aGuard(m_aMutex);
989 1 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
990 :
991 1 : checkBookmarkable();
992 :
993 1 : return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->hasOrderedBookmarks();
994 : }
995 :
996 2 : sal_Int32 OResultSet::hashBookmark(const Any& bookmark) throw( SQLException, RuntimeException, std::exception )
997 : {
998 : SAL_INFO("dbaccess", "OResultSet::hashBookmark" );
999 2 : MutexGuard aGuard(m_aMutex);
1000 2 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
1001 :
1002 2 : checkBookmarkable();
1003 :
1004 2 : return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->hashBookmark(bookmark);
1005 : }
1006 :
1007 : // ::com::sun::star::sdbc::XResultSetUpdate
1008 1 : void OResultSet::insertRow(void) throw( SQLException, RuntimeException, std::exception )
1009 : {
1010 : SAL_INFO("dbaccess", "OResultSet::insertRow" );
1011 1 : MutexGuard aGuard(m_aMutex);
1012 1 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
1013 :
1014 1 : checkReadOnly();
1015 :
1016 1 : m_xDelegatorResultSetUpdate->insertRow();
1017 1 : }
1018 :
1019 4 : void OResultSet::updateRow(void) throw( SQLException, RuntimeException, std::exception )
1020 : {
1021 : SAL_INFO("dbaccess", "OResultSet::updateRow" );
1022 4 : MutexGuard aGuard(m_aMutex);
1023 4 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
1024 :
1025 4 : checkReadOnly();
1026 :
1027 4 : m_xDelegatorResultSetUpdate->updateRow();
1028 4 : }
1029 :
1030 1 : void OResultSet::deleteRow(void) throw( SQLException, RuntimeException, std::exception )
1031 : {
1032 : SAL_INFO("dbaccess", "OResultSet::deleteRow" );
1033 1 : MutexGuard aGuard(m_aMutex);
1034 1 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
1035 :
1036 1 : checkReadOnly();
1037 :
1038 1 : m_xDelegatorResultSetUpdate->deleteRow();
1039 1 : }
1040 :
1041 20 : void OResultSet::cancelRowUpdates(void) throw( SQLException, RuntimeException, std::exception )
1042 : {
1043 : SAL_INFO("dbaccess", "OResultSet::cancelRowUpdates" );
1044 20 : MutexGuard aGuard(m_aMutex);
1045 20 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
1046 :
1047 20 : checkReadOnly();
1048 :
1049 20 : m_xDelegatorResultSetUpdate->cancelRowUpdates();
1050 20 : }
1051 :
1052 21 : void OResultSet::moveToInsertRow(void) throw( SQLException, RuntimeException, std::exception )
1053 : {
1054 : SAL_INFO("dbaccess", "OResultSet::moveToInsertRow" );
1055 21 : MutexGuard aGuard(m_aMutex);
1056 21 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
1057 :
1058 21 : checkReadOnly();
1059 :
1060 21 : m_xDelegatorResultSetUpdate->moveToInsertRow();
1061 21 : }
1062 :
1063 0 : void OResultSet::moveToCurrentRow(void) throw( SQLException, RuntimeException, std::exception )
1064 : {
1065 : SAL_INFO("dbaccess", "OResultSet::moveToCurrentRow" );
1066 0 : MutexGuard aGuard(m_aMutex);
1067 0 : ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
1068 :
1069 0 : checkReadOnly();
1070 :
1071 0 : m_xDelegatorResultSetUpdate->moveToCurrentRow();
1072 0 : }
1073 :
1074 52 : void OResultSet::checkReadOnly() const
1075 : {
1076 : //SAL_INFO("dbaccess", "OResultSet::checkReadOnly" );
1077 104 : if ( ( m_nResultSetConcurrency == ResultSetConcurrency::READ_ONLY )
1078 52 : || !m_xDelegatorResultSetUpdate.is()
1079 : )
1080 0 : throwSQLException( "The result set is read-only.", SQL_GENERAL_ERROR, *const_cast< OResultSet* >( this ) );
1081 52 : }
1082 :
1083 342 : void OResultSet::checkBookmarkable() const
1084 : {
1085 : //SAL_INFO("dbaccess", "OResultSet::checkBookmarkable" );
1086 342 : if ( !m_bIsBookmarkable )
1087 0 : throwSQLException( "The result set does not have bookmark support.", SQL_GENERAL_ERROR, *const_cast< OResultSet* >( this ) );
1088 342 : }
1089 :
1090 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
