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