LCOV - code coverage report
Current view: top level - dbaccess/source/core/api - resultset.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 482 0.0 %
Date: 2014-04-14 Functions: 0 94 0.0 %
Legend: Lines: hit not hit

          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           0 : 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           0 :            ,m_bIsBookmarkable(sal_False)
      62             : {
      63             :     SAL_INFO("dbaccess", "OResultSet::OResultSet" );
      64             : 
      65           0 :     m_pColumns = new OColumns(*this, m_aMutex, _bCaseSensitive, ::std::vector< OUString>(), NULL,NULL);
      66             : 
      67             :     try
      68             :     {
      69           0 :         m_aStatement = _xStatement;
      70           0 :         m_xDelegatorResultSetUpdate = m_xDelegatorResultSetUpdate.query( m_xDelegatorResultSet );
      71           0 :         m_xDelegatorRow = m_xDelegatorRow.query( m_xDelegatorResultSet );
      72           0 :         m_xDelegatorRowUpdate = m_xDelegatorRowUpdate.query( m_xDelegatorResultSet );
      73             : 
      74           0 :         Reference< XPropertySet > xSet(m_xDelegatorResultSet, UNO_QUERY);
      75           0 :         xSet->getPropertyValue(PROPERTY_RESULTSETTYPE) >>= m_nResultSetType;
      76           0 :         xSet->getPropertyValue(PROPERTY_RESULTSETCONCURRENCY) >>= m_nResultSetConcurrency;
      77             : 
      78             :         // test for Bookmarks
      79           0 :         if (ResultSetType::FORWARD_ONLY != m_nResultSetType)
      80             :         {
      81           0 :             Reference <XPropertySetInfo > xInfo(xSet->getPropertySetInfo());
      82           0 :             if (xInfo->hasPropertyByName(PROPERTY_ISBOOKMARKABLE))
      83             :             {
      84           0 :                 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           0 :                 m_bIsBookmarkable = m_bIsBookmarkable && Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY).is();
      88           0 :             }
      89           0 :         }
      90             :     }
      91           0 :     catch (const Exception&)
      92             :     {
      93             :     }
      94           0 : }
      95             : 
      96           0 : OResultSet::~OResultSet()
      97             : {
      98           0 :     m_pColumns->acquire();
      99           0 :     m_pColumns->disposing();
     100           0 :     delete m_pColumns;
     101             : 
     102           0 : }
     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           0 : Any OResultSet::queryInterface( const Type & rType ) throw (RuntimeException, std::exception)
     121             : {
     122           0 :     Any aIface = OResultSetBase::queryInterface( rType );
     123           0 :     if (!aIface.hasValue())
     124           0 :         aIface = ::cppu::queryInterface(
     125             :                     rType,
     126           0 :                     static_cast< XPropertySet * >( this ));
     127             : 
     128           0 :     return aIface;
     129             : }
     130             : 
     131           0 : void OResultSet::acquire() throw ()
     132             : {
     133           0 :     OResultSetBase::acquire();
     134           0 : }
     135             : 
     136           0 : void OResultSet::release() throw ()
     137             : {
     138           0 :     OResultSetBase::release();
     139           0 : }
     140             : 
     141             : 
     142             : // OResultSetBase
     143           0 : void OResultSet::disposing()
     144             : {
     145             :     SAL_INFO("dbaccess", "OResultSet::disposing" );
     146           0 :     OPropertySetHelper::disposing();
     147             : 
     148           0 :     MutexGuard aGuard(m_aMutex);
     149             : 
     150             :     // free the columns
     151           0 :     m_pColumns->disposing();
     152             : 
     153             :     // close the pending result set
     154           0 :     Reference< XCloseable > (m_xDelegatorResultSet, UNO_QUERY)->close();
     155             : 
     156           0 :     m_xDelegatorResultSet = NULL;
     157           0 :     m_xDelegatorRow = NULL;
     158           0 :     m_xDelegatorRowUpdate = NULL;
     159             : 
     160           0 :     m_aStatement.clear();
     161           0 : }
     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           0 : Reference< XPropertySetInfo > OResultSet::getPropertySetInfo() throw (RuntimeException, std::exception)
     197             : {
     198             :     //SAL_INFO("dbaccess", "OResultSet::getPropertySetInfo" );
     199           0 :     return createPropertySetInfo( getInfoHelper() ) ;
     200             : }
     201             : 
     202             : // comphelper::OPropertyArrayUsageHelper
     203           0 : ::cppu::IPropertyArrayHelper* OResultSet::createArrayHelper( ) const
     204             : {
     205             :     //SAL_INFO("dbaccess", "OResultSet::createArrayHelper" );
     206           0 :     BEGIN_PROPERTY_HELPER(6)
     207           0 :         DECL_PROP1(CURSORNAME,              OUString,    READONLY);
     208           0 :         DECL_PROP0(FETCHDIRECTION,          sal_Int32);
     209           0 :         DECL_PROP0(FETCHSIZE,               sal_Int32);
     210           0 :         DECL_PROP1_BOOL(ISBOOKMARKABLE,         READONLY);
     211           0 :         DECL_PROP1(RESULTSETCONCURRENCY,    sal_Int32,      READONLY);
     212           0 :         DECL_PROP1(RESULTSETTYPE,           sal_Int32,      READONLY);
     213           0 :     END_PROPERTY_HELPER();
     214             : }
     215             : 
     216             : // cppu::OPropertySetHelper
     217           0 : ::cppu::IPropertyArrayHelper& OResultSet::getInfoHelper()
     218             : {
     219             :     //SAL_INFO("dbaccess", "OResultSet::getInfoHelper" );
     220           0 :     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           0 : void OResultSet::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
     251             : {
     252             :     //SAL_INFO("dbaccess", "OResultSet::getFastPropertyValue" );
     253           0 :     switch (nHandle)
     254             :     {
     255             :         case PROPERTY_ID_ISBOOKMARKABLE:
     256             :         {
     257           0 :             sal_Bool bVal = m_bIsBookmarkable;
     258           0 :             rValue.setValue(&bVal, getBooleanCppuType());
     259           0 :         }   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           0 : }
     274             : 
     275             : // XWarningsSupplier
     276           0 : Any OResultSet::getWarnings(void) throw( SQLException, RuntimeException, std::exception )
     277             : {
     278             :     SAL_INFO("dbaccess", "OResultSet::getWarnings" );
     279           0 :     MutexGuard aGuard(m_aMutex);
     280           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     281           0 :     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           0 : Reference< XResultSetMetaData > OResultSet::getMetaData(void) throw( SQLException, RuntimeException, std::exception )
     294             : {
     295             :     SAL_INFO("dbaccess", "OResultSet::getMetaData" );
     296           0 :     MutexGuard aGuard(m_aMutex);
     297           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     298             : 
     299           0 :     return Reference< XResultSetMetaDataSupplier >(m_xDelegatorResultSet, UNO_QUERY)->getMetaData();
     300             : }
     301             : 
     302             : // ::com::sun::star::sdbc::XColumnLocate
     303           0 : sal_Int32 OResultSet::findColumn(const OUString& columnName) throw( SQLException, RuntimeException, std::exception )
     304             : {
     305             :     SAL_INFO("dbaccess", "OResultSet::findColumn" );
     306           0 :     MutexGuard aGuard(m_aMutex);
     307           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     308             : 
     309           0 :     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           0 : sal_Bool OResultSet::wasNull(void) throw( SQLException, RuntimeException, std::exception )
     410             : {
     411             :     SAL_INFO("dbaccess", "OResultSet::wasNull" );
     412           0 :     MutexGuard aGuard(m_aMutex);
     413           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     414             : 
     415           0 :     return m_xDelegatorRow->wasNull();
     416             : }
     417             : 
     418           0 : OUString OResultSet::getString(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
     419             : {
     420             :     //SAL_INFO("dbaccess", "OResultSet::getString" );
     421           0 :     MutexGuard aGuard(m_aMutex);
     422           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     423             : 
     424           0 :     return m_xDelegatorRow->getString(columnIndex);
     425             : }
     426             : 
     427           0 : sal_Bool OResultSet::getBoolean(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
     428             : {
     429             :     //SAL_INFO("dbaccess", "OResultSet::getBoolean" );
     430           0 :     MutexGuard aGuard(m_aMutex);
     431           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     432             : 
     433           0 :     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           0 : sal_Int16 OResultSet::getShort(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
     446             : {
     447             :     SAL_INFO("dbaccess", "OResultSet::getShort" );
     448           0 :     MutexGuard aGuard(m_aMutex);
     449           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     450             : 
     451           0 :     return m_xDelegatorRow->getShort(columnIndex);
     452             : }
     453             : 
     454           0 : sal_Int32 OResultSet::getInt(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
     455             : {
     456             :     SAL_INFO("dbaccess", "OResultSet::getInt" );
     457           0 :     MutexGuard aGuard(m_aMutex);
     458           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     459             : 
     460           0 :     return m_xDelegatorRow->getInt(columnIndex);
     461             : }
     462             : 
     463           0 : sal_Int64 OResultSet::getLong(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
     464             : {
     465             :     SAL_INFO("dbaccess", "OResultSet::getLong" );
     466           0 :     MutexGuard aGuard(m_aMutex);
     467           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     468             : 
     469           0 :     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           0 : ::com::sun::star::util::Date OResultSet::getDate(sal_Int32 columnIndex) throw( SQLException, RuntimeException, std::exception )
     500             : {
     501             :     SAL_INFO("dbaccess", "OResultSet::getDate" );
     502           0 :     MutexGuard aGuard(m_aMutex);
     503           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     504             : 
     505           0 :     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           0 : void OResultSet::updateString(sal_Int32 columnIndex, const OUString& x) throw( SQLException, RuntimeException, std::exception )
     679             : {
     680             :     SAL_INFO("dbaccess", "OResultSet::updateString" );
     681           0 :     MutexGuard aGuard(m_aMutex);
     682           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     683             : 
     684           0 :     checkReadOnly();
     685             : 
     686           0 :     m_xDelegatorRowUpdate->updateString(columnIndex, x);
     687           0 : }
     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           0 : sal_Bool OResultSet::next(void) throw( SQLException, RuntimeException, std::exception )
     779             : {
     780             :     SAL_INFO("dbaccess", "OResultSet::next" );
     781           0 :     MutexGuard aGuard(m_aMutex);
     782           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     783             : 
     784           0 :     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           0 : void OResultSet::beforeFirst(void) throw( SQLException, RuntimeException, std::exception )
     824             : {
     825             :     SAL_INFO("dbaccess", "OResultSet::beforeFirst" );
     826           0 :     MutexGuard aGuard(m_aMutex);
     827           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     828             : 
     829           0 :     m_xDelegatorResultSet->beforeFirst();
     830           0 : }
     831             : 
     832           0 : void OResultSet::afterLast(void) throw( SQLException, RuntimeException, std::exception )
     833             : {
     834             :     SAL_INFO("dbaccess", "OResultSet::afterLast" );
     835           0 :     MutexGuard aGuard(m_aMutex);
     836           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     837             : 
     838           0 :     m_xDelegatorResultSet->afterLast();
     839           0 : }
     840             : 
     841           0 : sal_Bool OResultSet::first(void) throw( SQLException, RuntimeException, std::exception )
     842             : {
     843             :     SAL_INFO("dbaccess", "OResultSet::first" );
     844           0 :     MutexGuard aGuard(m_aMutex);
     845           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     846             : 
     847           0 :     return m_xDelegatorResultSet->first();
     848             : }
     849             : 
     850           0 : sal_Bool OResultSet::last(void) throw( SQLException, RuntimeException, std::exception )
     851             : {
     852             :     SAL_INFO("dbaccess", "OResultSet::last" );
     853           0 :     MutexGuard aGuard(m_aMutex);
     854           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     855             : 
     856           0 :     return m_xDelegatorResultSet->last();
     857             : }
     858             : 
     859           0 : sal_Int32 OResultSet::getRow(void) throw( SQLException, RuntimeException, std::exception )
     860             : {
     861             :     SAL_INFO("dbaccess", "OResultSet::getRow" );
     862           0 :     MutexGuard aGuard(m_aMutex);
     863           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     864             : 
     865           0 :     return m_xDelegatorResultSet->getRow();
     866             : }
     867             : 
     868           0 : sal_Bool OResultSet::absolute(sal_Int32 row) throw( SQLException, RuntimeException, std::exception )
     869             : {
     870             :     SAL_INFO("dbaccess", "OResultSet::absolute" );
     871           0 :     MutexGuard aGuard(m_aMutex);
     872           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     873             : 
     874           0 :     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           0 : sal_Bool OResultSet::previous(void) throw( SQLException, RuntimeException, std::exception )
     887             : {
     888             :     SAL_INFO("dbaccess", "OResultSet::previous" );
     889           0 :     MutexGuard aGuard(m_aMutex);
     890           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     891             : 
     892           0 :     return m_xDelegatorResultSet->previous();
     893             : }
     894             : 
     895           0 : void OResultSet::refreshRow(void) throw( SQLException, RuntimeException, std::exception )
     896             : {
     897             :     SAL_INFO("dbaccess", "OResultSet::refreshRow" );
     898           0 :     MutexGuard aGuard(m_aMutex);
     899           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     900             : 
     901           0 :     m_xDelegatorResultSet->refreshRow();
     902           0 : }
     903             : 
     904           0 : sal_Bool OResultSet::rowUpdated(void) throw( SQLException, RuntimeException, std::exception )
     905             : {
     906             :     SAL_INFO("dbaccess", "OResultSet::rowUpdated" );
     907           0 :     MutexGuard aGuard(m_aMutex);
     908           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     909             : 
     910           0 :     return m_xDelegatorResultSet->rowUpdated();
     911             : }
     912             : 
     913           0 : sal_Bool OResultSet::rowInserted(void) throw( SQLException, RuntimeException, std::exception )
     914             : {
     915             :     SAL_INFO("dbaccess", "OResultSet::rowInserted" );
     916           0 :     MutexGuard aGuard(m_aMutex);
     917           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     918             : 
     919           0 :     return m_xDelegatorResultSet->rowInserted();
     920             : }
     921             : 
     922           0 : sal_Bool OResultSet::rowDeleted(void) throw( SQLException, RuntimeException, std::exception )
     923             : {
     924             :     SAL_INFO("dbaccess", "OResultSet::rowDeleted" );
     925           0 :     MutexGuard aGuard(m_aMutex);
     926           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     927             : 
     928           0 :     return m_xDelegatorResultSet->rowDeleted();
     929             : }
     930             : 
     931           0 : Reference< XInterface > OResultSet::getStatement(void) throw( SQLException, RuntimeException, std::exception )
     932             : {
     933             :     SAL_INFO("dbaccess", "OResultSet::getStatement" );
     934           0 :     MutexGuard aGuard(m_aMutex);
     935           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     936             : 
     937           0 :     return m_aStatement;
     938             : }
     939             : 
     940             : // ::com::sun::star::sdbcx::XRowLocate
     941           0 : Any OResultSet::getBookmark(void) throw( SQLException, RuntimeException, std::exception )
     942             : {
     943             :     SAL_INFO("dbaccess", "OResultSet::getBookmark" );
     944           0 :     MutexGuard aGuard(m_aMutex);
     945           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     946             : 
     947           0 :     checkBookmarkable();
     948             : 
     949           0 :     return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->getBookmark();
     950             : }
     951             : 
     952           0 : sal_Bool OResultSet::moveToBookmark(const Any& bookmark) throw( SQLException, RuntimeException, std::exception )
     953             : {
     954             :     SAL_INFO("dbaccess", "OResultSet::moveToBookmark" );
     955           0 :     MutexGuard aGuard(m_aMutex);
     956           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     957             : 
     958           0 :     checkBookmarkable();
     959             : 
     960           0 :     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           0 : sal_Int32 OResultSet::compareBookmarks(const Any& _first, const Any& _second) throw( SQLException, RuntimeException, std::exception )
     975             : {
     976             :     SAL_INFO("dbaccess", "OResultSet::compareBookmarks" );
     977           0 :     MutexGuard aGuard(m_aMutex);
     978           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     979             : 
     980           0 :     checkBookmarkable();
     981             : 
     982           0 :     return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->compareBookmarks(_first, _second);
     983             : }
     984             : 
     985           0 : sal_Bool OResultSet::hasOrderedBookmarks(void) throw( SQLException, RuntimeException, std::exception )
     986             : {
     987             :     SAL_INFO("dbaccess", "OResultSet::hasOrderedBookmarks" );
     988           0 :     MutexGuard aGuard(m_aMutex);
     989           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
     990             : 
     991           0 :     checkBookmarkable();
     992             : 
     993           0 :     return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->hasOrderedBookmarks();
     994             : }
     995             : 
     996           0 : sal_Int32 OResultSet::hashBookmark(const Any& bookmark) throw( SQLException, RuntimeException, std::exception )
     997             : {
     998             :     SAL_INFO("dbaccess", "OResultSet::hashBookmark" );
     999           0 :     MutexGuard aGuard(m_aMutex);
    1000           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
    1001             : 
    1002           0 :     checkBookmarkable();
    1003             : 
    1004           0 :     return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->hashBookmark(bookmark);
    1005             : }
    1006             : 
    1007             : // ::com::sun::star::sdbc::XResultSetUpdate
    1008           0 : void OResultSet::insertRow(void) throw( SQLException, RuntimeException, std::exception )
    1009             : {
    1010             :     SAL_INFO("dbaccess", "OResultSet::insertRow" );
    1011           0 :     MutexGuard aGuard(m_aMutex);
    1012           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
    1013             : 
    1014           0 :     checkReadOnly();
    1015             : 
    1016           0 :     m_xDelegatorResultSetUpdate->insertRow();
    1017           0 : }
    1018             : 
    1019           0 : void OResultSet::updateRow(void) throw( SQLException, RuntimeException, std::exception )
    1020             : {
    1021             :     SAL_INFO("dbaccess", "OResultSet::updateRow" );
    1022           0 :     MutexGuard aGuard(m_aMutex);
    1023           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
    1024             : 
    1025           0 :     checkReadOnly();
    1026             : 
    1027           0 :     m_xDelegatorResultSetUpdate->updateRow();
    1028           0 : }
    1029             : 
    1030           0 : void OResultSet::deleteRow(void) throw( SQLException, RuntimeException, std::exception )
    1031             : {
    1032             :     SAL_INFO("dbaccess", "OResultSet::deleteRow" );
    1033           0 :     MutexGuard aGuard(m_aMutex);
    1034           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
    1035             : 
    1036           0 :     checkReadOnly();
    1037             : 
    1038           0 :     m_xDelegatorResultSetUpdate->deleteRow();
    1039           0 : }
    1040             : 
    1041           0 : void OResultSet::cancelRowUpdates(void) throw( SQLException, RuntimeException, std::exception )
    1042             : {
    1043             :     SAL_INFO("dbaccess", "OResultSet::cancelRowUpdates" );
    1044           0 :     MutexGuard aGuard(m_aMutex);
    1045           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
    1046             : 
    1047           0 :     checkReadOnly();
    1048             : 
    1049           0 :     m_xDelegatorResultSetUpdate->cancelRowUpdates();
    1050           0 : }
    1051             : 
    1052           0 : void OResultSet::moveToInsertRow(void) throw( SQLException, RuntimeException, std::exception )
    1053             : {
    1054             :     SAL_INFO("dbaccess", "OResultSet::moveToInsertRow" );
    1055           0 :     MutexGuard aGuard(m_aMutex);
    1056           0 :     ::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
    1057             : 
    1058           0 :     checkReadOnly();
    1059             : 
    1060           0 :     m_xDelegatorResultSetUpdate->moveToInsertRow();
    1061           0 : }
    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           0 : void OResultSet::checkReadOnly() const
    1075             : {
    1076             :     //SAL_INFO("dbaccess", "OResultSet::checkReadOnly" );
    1077           0 :     if  (   ( m_nResultSetConcurrency == ResultSetConcurrency::READ_ONLY )
    1078           0 :         ||  !m_xDelegatorResultSetUpdate.is()
    1079             :         )
    1080           0 :         throwSQLException( "The result set is read-only.", SQL_GENERAL_ERROR, *const_cast< OResultSet* >( this ) );
    1081           0 : }
    1082             : 
    1083           0 : void OResultSet::checkBookmarkable() const
    1084             : {
    1085             :     //SAL_INFO("dbaccess", "OResultSet::checkBookmarkable" );
    1086           0 :     if ( !m_bIsBookmarkable )
    1087           0 :         throwSQLException( "The result set does not have bookmark support.", SQL_GENERAL_ERROR, *const_cast< OResultSet* >( this ) );
    1088           0 : }
    1089             : 
    1090             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10