dbaccess/source/core/api/resultset.cxx

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