dbaccess/source/core/api/RowSetBase.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 "RowSetBase.hxx"
  21 #include "CRowSetDataColumn.hxx"
  22 #include <connectivity/sdbcx/VCollection.hxx>
  23 #include "RowSetCache.hxx"
  24 #include <stringconstants.hxx>
  25 #include <sal/log.hxx>
  26 #include <core_resource.hxx>
  27 #include <strings.hrc>
  28 #include <strings.hxx>
  29 #include <com/sun/star/beans/PropertyAttribute.hpp>
  30 #include <com/sun/star/sdbcx/CompareBookmark.hpp>
  31 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
  32 #include <com/sun/star/sdbc/ResultSetType.hpp>
  33 #include <comphelper/sequence.hxx>
  34 #include <comphelper/seqstream.hxx>
  35 #include <connectivity/dbexception.hxx>
  36 #include <o3tl/safeint.hxx>
  37 #include <comphelper/diagnose_ex.hxx>
  38
  39 using namespace dbaccess;
  40 using namespace connectivity;
  41 using namespace connectivity::sdbcx;
  42 using namespace comphelper;
  43 using namespace dbtools;
  44 using namespace ::com::sun::star::uno;
  45 using namespace ::com::sun::star::beans;
  46 using namespace ::com::sun::star::sdbc;
  47 using namespace ::com::sun::star::sdb;
  48 using namespace ::com::sun::star::sdbcx;
  49 using namespace ::com::sun::star::container;
  50 using namespace ::com::sun::star::lang;
  51 using namespace ::com::sun::star::util;
  52 using namespace ::cppu;
  53 using namespace ::osl;
  54
  55 namespace dbaccess
  56 {
  57
  58 // OEmptyCollection
  59 class OEmptyCollection : public sdbcx::OCollection
  60 {
  61 protected:
  62     virtual void impl_refresh() override;
  63     virtual connectivity::sdbcx::ObjectType createObject(const OUString& _rName) override;
  64 public:
  65     OEmptyCollection(::cppu::OWeakObject& _rParent,::osl::Mutex& _rMutex) : OCollection(_rParent, true, _rMutex, std::vector< OUString>()){}
  66 };
  67
  68 void OEmptyCollection::impl_refresh()
  69 {
  70 }
  71
  72 connectivity::sdbcx::ObjectType OEmptyCollection::createObject(const OUString& /*_rName*/)
  73 {
  74     return connectivity::sdbcx::ObjectType();
  75 }
  76
  77 // ORowSetBase
  78
  79 ORowSetBase::ORowSetBase( const Reference<XComponentContext>& _rContext, ::cppu::OBroadcastHelper& _rBHelper, ::osl::Mutex* _pMutex )
  80     :OPropertyStateContainer(_rBHelper)
  81     ,m_pMutex(_pMutex)
  82     ,m_pMySelf(nullptr)
  83     ,m_rBHelper(_rBHelper)
  84     ,m_aContext( _rContext )
  85     ,m_nLastColumnIndex(-1)
  86     ,m_nDeletedPosition(-1)
  87     ,m_nResultSetType( ResultSetType::FORWARD_ONLY )
  88     ,m_nResultSetConcurrency( ResultSetConcurrency::READ_ONLY )
  89     ,m_bClone(false)
  90     ,m_bIgnoreResult(false)
  91     ,m_bBeforeFirst(true) // changed from sal_False
  92     ,m_bAfterLast(false)
  93     ,m_bIsInsertRow(false)
  94 {
  95     sal_Int32 nRBT  = PropertyAttribute::READONLY   | PropertyAttribute::BOUND      | PropertyAttribute::TRANSIENT;
  96
  97     registerPropertyNoMember( PROPERTY_ROWCOUNT,        PROPERTY_ID_ROWCOUNT,        nRBT, cppu::UnoType<sal_Int32>::get(), css::uno::Any(sal_Int32(0)) );
  98     registerPropertyNoMember( PROPERTY_ISROWCOUNTFINAL, PROPERTY_ID_ISROWCOUNTFINAL, nRBT, cppu::UnoType<bool>::get(), css::uno::Any(false) );
  99 }
 100
 101 ORowSetBase::~ORowSetBase()
 102 {
 103     if(m_pColumns)
 104     {
 105         TDataColumns().swap(m_aDataColumns);
 106         m_pColumns->acquire();
 107         m_pColumns->disposing();
 108     }
 109 }
 110
 111 // css::lang::XTypeProvider
 112 Sequence< Type > ORowSetBase::getTypes()
 113 {
 114     return ::comphelper::concatSequences(ORowSetBase_BASE::getTypes(),OPropertyStateContainer::getTypes());
 115 }
 116
 117 // css::uno::XInterface
 118 Any ORowSetBase::queryInterface( const Type & rType )
 119 {
 120     Any aRet = ORowSetBase_BASE::queryInterface(rType);
 121     if(!aRet.hasValue())
 122         aRet = OPropertyStateContainer::queryInterface(rType);
 123     return aRet;
 124 }
 125
 126 void SAL_CALL ORowSetBase::getFastPropertyValue(Any& rValue,sal_Int32 nHandle) const
 127 {
 128     if(m_pCache)
 129     {
 130         switch(nHandle)
 131         {
 132         case PROPERTY_ID_ROWCOUNT:
 133             rValue <<= impl_getRowCount();
 134             break;
 135         case PROPERTY_ID_ISROWCOUNTFINAL:
 136             rValue <<= m_pCache->m_bRowCountFinal;
 137             break;
 138         default:
 139             OPropertyStateContainer::getFastPropertyValue(rValue,nHandle);
 140         }
 141     }
 142     else
 143         OPropertyStateContainer::getFastPropertyValue(rValue,nHandle);
 144 }
 145
 146 // OComponentHelper
 147 void SAL_CALL ORowSetBase::disposing()
 148 {
 149     MutexGuard aGuard(*m_pMutex);
 150
 151     if ( m_pColumns )
 152     {
 153         TDataColumns().swap(m_aDataColumns);
 154         m_pColumns->disposing();
 155     }
 156     if ( m_pCache )
 157     {
 158         m_pCache->deregisterOldRow(m_aOldRow);
 159         m_pCache->deleteIterator(this);
 160     }
 161     m_pCache = nullptr;
 162 }
 163
 164 // comphelper::OPropertyArrayUsageHelper
 165 ::cppu::IPropertyArrayHelper* ORowSetBase::createArrayHelper( ) const
 166 {
 167     Sequence< Property > aProps;
 168     describeProperties(aProps);
 169     return new ::cppu::OPropertyArrayHelper(aProps);
 170 }
 171
 172 // cppu::OPropertySetHelper
 173 ::cppu::IPropertyArrayHelper& SAL_CALL ORowSetBase::getInfoHelper()
 174 {
 175     return *getArrayHelper();
 176 }
 177
 178 // XRow
 179 sal_Bool SAL_CALL ORowSetBase::wasNull(  )
 180 {
 181     ::osl::MutexGuard aGuard( *m_pMutex );
 182     checkCache();
 183     return !((m_nLastColumnIndex != -1) && !m_aCurrentRow.isNull() && m_aCurrentRow != m_pCache->getEnd() && m_aCurrentRow->is())
 184            || (**m_aCurrentRow)[m_nLastColumnIndex].isNull();
 185 }
 186
 187 const ORowSetValue& ORowSetBase::getValue(sal_Int32 columnIndex)
 188 {
 189     checkCache();
 190     return impl_getValue(columnIndex);
 191 }
 192
 193 const ORowSetValue& ORowSetBase::impl_getValue(sal_Int32 columnIndex)
 194 {
 195     if ( m_bBeforeFirst || m_bAfterLast )
 196     {
 197         SAL_WARN("dbaccess", "ORowSetBase::getValue: Illegal call here (we're before first or after last)!");
 198         ::dbtools::throwSQLException( DBA_RES( RID_STR_CURSOR_BEFORE_OR_AFTER ), StandardSQLState::INVALID_CURSOR_POSITION, *m_pMySelf );
 199     }
 200
 201     if ( impl_rowDeleted() )
 202     {
 203         return m_aEmptyValue;
 204     }
 205
 206     bool bValidCurrentRow = ( !m_aCurrentRow.isNull() && m_aCurrentRow != m_pCache->getEnd() && m_aCurrentRow->is() );
 207     if ( !bValidCurrentRow )
 208     {
 209         // currentrow is null when the clone moves the window
 210         positionCache( CursorMoveDirection::Current );
 211         m_aCurrentRow   = m_pCache->m_aMatrixIter;
 212         m_bIsInsertRow  = false;
 213         OSL_ENSURE(!m_aCurrentRow.isNull(),"ORowSetBase::getValue: we don't stand on a valid row! Row is null.");
 214
 215         bValidCurrentRow = ( !m_aCurrentRow.isNull() && m_aCurrentRow != m_pCache->getEnd() && m_aCurrentRow->is() );
 216     }
 217
 218     if ( bValidCurrentRow )
 219     {
 220 #if OSL_DEBUG_LEVEL > 0
 221         ORowSetMatrix::const_iterator aCacheEnd;
 222         ORowSetMatrix::iterator aCurrentRow;
 223         aCacheEnd = m_pCache->getEnd();
 224         aCurrentRow = m_aCurrentRow;
 225         ORowSetCacheMap::const_iterator aCacheIter = m_aCurrentRow.getIter();
 226         ORowSetCacheIterator_Helper aHelper = aCacheIter->second;
 227         ORowSetMatrix::const_iterator k = aHelper.aIterator;
 228         for (; k != m_pCache->getEnd(); ++k)
 229         {
 230             ORowSetValueVector* pTemp = k->get();
 231             OSL_ENSURE( pTemp != reinterpret_cast<void*>(sal_uIntPtr(0xfeeefeee)),"HALT!" );
 232         }
 233         OSL_ENSURE(!m_aCurrentRow.isNull() && m_aCurrentRow < m_pCache->getEnd() && aCacheIter != m_pCache->m_aCacheIterators.end(),"Invalid iterator set for currentrow!");
 234 #endif
 235         ORowSetRow rRow = *m_aCurrentRow;
 236         bool bValidPosition = rRow.is() && o3tl::make_unsigned(columnIndex) < rRow->size();
 237         if (!bValidPosition)
 238         {
 239             SAL_WARN("dbaccess", "ORowSetBase::getValue: Invalid size of vector!");
 240             ::dbtools::throwSQLException( DBA_RES( RID_STR_CURSOR_BEFORE_OR_AFTER ), StandardSQLState::INVALID_CURSOR_POSITION, *m_pMySelf );
 241         }
 242         m_nLastColumnIndex = columnIndex;
 243         return (*rRow)[m_nLastColumnIndex];
 244     }
 245
 246     // we should normally never reach this
 247     return m_aEmptyValue;
 248 }
 249
 250 OUString SAL_CALL ORowSetBase::getString( sal_Int32 columnIndex )
 251 {
 252     ::osl::MutexGuard aGuard( *m_pMutex );
 253     return getValue(columnIndex).getString();
 254 }
 255
 256 sal_Bool SAL_CALL ORowSetBase::getBoolean( sal_Int32 columnIndex )
 257 {
 258     ::osl::MutexGuard aGuard( *m_pMutex );
 259     return getValue(columnIndex).getBool();
 260 }
 261
 262 sal_Int8 SAL_CALL ORowSetBase::getByte( sal_Int32 columnIndex )
 263 {
 264     ::osl::MutexGuard aGuard( *m_pMutex );
 265     return getValue(columnIndex).getInt8();
 266 }
 267
 268 sal_Int16 SAL_CALL ORowSetBase::getShort( sal_Int32 columnIndex )
 269 {
 270     ::osl::MutexGuard aGuard( *m_pMutex );
 271     return getValue(columnIndex).getInt16();
 272 }
 273
 274 sal_Int32 SAL_CALL ORowSetBase::getInt( sal_Int32 columnIndex )
 275 {
 276     ::osl::MutexGuard aGuard( *m_pMutex );
 277     return getValue(columnIndex).getInt32();
 278 }
 279
 280 sal_Int64 SAL_CALL ORowSetBase::getLong( sal_Int32 columnIndex )
 281 {
 282     ::osl::MutexGuard aGuard( *m_pMutex );
 283     return getValue(columnIndex).getLong();
 284 }
 285
 286 float SAL_CALL ORowSetBase::getFloat( sal_Int32 columnIndex )
 287 {
 288     ::osl::MutexGuard aGuard( *m_pMutex );
 289     return getValue(columnIndex).getFloat();
 290 }
 291
 292 double SAL_CALL ORowSetBase::getDouble( sal_Int32 columnIndex )
 293 {
 294     ::osl::MutexGuard aGuard( *m_pMutex );
 295     return getValue(columnIndex).getDouble();
 296 }
 297
 298 Sequence< sal_Int8 > SAL_CALL ORowSetBase::getBytes( sal_Int32 columnIndex )
 299 {
 300     ::osl::MutexGuard aGuard( *m_pMutex );
 301     return getValue(columnIndex).getSequence();
 302 }
 303
 304 css::util::Date SAL_CALL ORowSetBase::getDate( sal_Int32 columnIndex )
 305 {
 306     ::osl::MutexGuard aGuard( *m_pMutex );
 307     return getValue(columnIndex).getDate();
 308 }
 309
 310 css::util::Time SAL_CALL ORowSetBase::getTime( sal_Int32 columnIndex )
 311 {
 312     ::osl::MutexGuard aGuard( *m_pMutex );
 313     return getValue(columnIndex).getTime();
 314 }
 315
 316 css::util::DateTime SAL_CALL ORowSetBase::getTimestamp( sal_Int32 columnIndex )
 317 {
 318     ::osl::MutexGuard aGuard( *m_pMutex );
 319     return getValue(columnIndex).getDateTime();
 320 }
 321
 322 Reference< css::io::XInputStream > SAL_CALL ORowSetBase::getBinaryStream( sal_Int32 columnIndex )
 323 {
 324     ::osl::MutexGuard aGuard( *m_pMutex );
 325     checkCache();
 326
 327     if ( m_bBeforeFirst || m_bAfterLast )
 328     {
 329         SAL_WARN("dbaccess", "ORowSetBase::getBinaryStream: Illegal call here (we're before first or after last)!");
 330         ::dbtools::throwSQLException( DBA_RES( RID_STR_CURSOR_BEFORE_OR_AFTER ), StandardSQLState::INVALID_CURSOR_POSITION, *m_pMySelf );
 331     }
 332
 333     if ( impl_rowDeleted() )
 334     {
 335         return nullptr;
 336     }
 337
 338     bool bValidCurrentRow = ( !m_aCurrentRow.isNull() && m_aCurrentRow != m_pCache->getEnd() && m_aCurrentRow->is() );
 339     if ( !bValidCurrentRow )
 340     {
 341         positionCache( CursorMoveDirection::Current );
 342         m_aCurrentRow   = m_pCache->m_aMatrixIter;
 343         m_bIsInsertRow  = false;
 344         OSL_ENSURE(!m_aCurrentRow.isNull(),"ORowSetBase::getBinaryStream: we don't stand on a valid row! Row is null.");
 345
 346         bValidCurrentRow = ( !m_aCurrentRow.isNull() && m_aCurrentRow != m_pCache->getEnd() && m_aCurrentRow->is() );
 347     }
 348
 349     if ( bValidCurrentRow )
 350     {
 351         m_nLastColumnIndex = columnIndex;
 352         return new ::comphelper::SequenceInputStream((**m_aCurrentRow)[m_nLastColumnIndex].getSequence());
 353     }
 354
 355     // we should normally never reach this
 356     return Reference< css::io::XInputStream >();
 357 }
 358
 359 Reference< css::io::XInputStream > SAL_CALL ORowSetBase::getCharacterStream( sal_Int32 columnIndex )
 360 {
 361     return getBinaryStream(columnIndex);
 362 }
 363
 364 Any SAL_CALL ORowSetBase::getObject( sal_Int32 columnIndex, const Reference< XNameAccess >& /*typeMap*/ )
 365 {
 366     ::osl::MutexGuard aGuard( *m_pMutex );
 367     checkCache();
 368
 369     return getValue(columnIndex).makeAny();
 370 }
 371
 372 Reference< XRef > SAL_CALL ORowSetBase::getRef( sal_Int32 /*columnIndex*/ )
 373 {
 374     ::dbtools::throwFeatureNotImplementedSQLException( u"XRow::getRef"_ustr, *m_pMySelf );
 375 }
 376
 377 Reference< XBlob > SAL_CALL ORowSetBase::getBlob( sal_Int32 columnIndex )
 378 {
 379     return Reference< XBlob >(getValue(columnIndex).makeAny(),UNO_QUERY);
 380 }
 381
 382 Reference< XClob > SAL_CALL ORowSetBase::getClob( sal_Int32 columnIndex )
 383 {
 384     return Reference< XClob >(getValue(columnIndex).makeAny(),UNO_QUERY);
 385 }
 386
 387 Reference< XArray > SAL_CALL ORowSetBase::getArray( sal_Int32 /*columnIndex*/ )
 388 {
 389     ::dbtools::throwFeatureNotImplementedSQLException( u"XRow::getArray"_ustr, *m_pMySelf );
 390 }
 391
 392 // css::sdbcx::XRowLocate
 393 Any SAL_CALL ORowSetBase::getBookmark(  )
 394 {
 395     SAL_INFO("dbaccess", "ORowSetBase::getBookmark() Clone = " << m_bClone);
 396     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
 397     ::osl::MutexGuard aGuard( *m_pMutex );
 398     checkCache();
 399
 400     if ( m_bBeforeFirst || m_bAfterLast )
 401         ::dbtools::throwSQLException( DBA_RES( RID_STR_NO_BOOKMARK_BEFORE_OR_AFTER ), StandardSQLState::INVALID_CURSOR_POSITION, *m_pMySelf );
 402
 403     if ( impl_rowDeleted() )
 404         ::dbtools::throwSQLException( DBA_RES( RID_STR_NO_BOOKMARK_DELETED ), StandardSQLState::INVALID_CURSOR_POSITION, *m_pMySelf );
 405
 406     OSL_ENSURE( m_aBookmark.hasValue(), "ORowSetBase::getBookmark: bookmark has no value!" );
 407     return m_aBookmark;
 408 }
 409
 410 sal_Bool SAL_CALL ORowSetBase::moveToBookmark( const Any& bookmark )
 411 {
 412     SAL_INFO("dbaccess", "ORowSetBase::moveToBookmark(Any) Clone = " << m_bClone);
 413     OSL_ENSURE(bookmark.hasValue(),"ORowSetBase::moveToBookmark bookmark has no value!");
 414     ::osl::ResettableMutexGuard aGuard( *m_pMutex );
 415
 416     if(!bookmark.hasValue() || m_nResultSetType == ResultSetType::FORWARD_ONLY)
 417     {
 418         if(bookmark.hasValue())
 419             SAL_WARN("dbaccess", "MoveToBookmark is not possible when we are only forward");
 420         else
 421             SAL_WARN("dbaccess", "Bookmark is not valid");
 422         throwFunctionSequenceException(*m_pMySelf);
 423     }
 424
 425     checkCache();
 426
 427     bool bRet( notifyAllListenersCursorBeforeMove( aGuard ) );
 428     if ( bRet )
 429     {
 430         // check if we are inserting a row
 431         bool bWasNew = m_pCache->m_bNew || impl_rowDeleted();
 432
 433         ORowSetNotifier aNotifier( this );
 434             // this will call cancelRowModification on the cache if necessary
 435
 436         ORowSetRow aOldValues = getOldRow(bWasNew);
 437
 438         bRet = m_pCache->moveToBookmark(bookmark);
 439         doCancelModification( );
 440         if(bRet)
 441         {
 442             // notification order
 443             // - column values
 444             // - cursorMoved
 445             setCurrentRow( true, true, aOldValues, aGuard );
 446         }
 447         else
 448         {
 449             movementFailed();
 450         }
 451
 452         // - IsModified
 453         // - IsNew
 454         aNotifier.fire( );
 455     }
 456     SAL_INFO("dbaccess", "ORowSetBase::moveToBookmark(Any) = " << bRet << " Clone = " << m_bClone);
 457     return bRet;
 458 }
 459
 460 sal_Bool SAL_CALL ORowSetBase::moveRelativeToBookmark( const Any& bookmark, sal_Int32 rows )
 461 {
 462     SAL_INFO("dbaccess", "ORowSetBase::moveRelativeToBookmark(Any," << rows << ") Clone = " << m_bClone);
 463     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
 464
 465     ::osl::ResettableMutexGuard aGuard( *m_pMutex );
 466
 467     checkPositioningAllowed();
 468
 469     bool bRet( notifyAllListenersCursorBeforeMove( aGuard ) );
 470     if ( bRet )
 471     {
 472         // check if we are inserting a row
 473         bool bWasNew = m_pCache->m_bNew || rowDeleted();
 474
 475         ORowSetNotifier aNotifier( this );
 476             // this will call cancelRowModification on the cache if necessary
 477
 478         ORowSetRow aOldValues = getOldRow(bWasNew);
 479
 480         bRet = m_pCache->moveRelativeToBookmark(bookmark,rows);
 481         doCancelModification( );
 482         if(bRet)
 483         {
 484             // notification order
 485             // - column values
 486             // - cursorMoved
 487             setCurrentRow( true, true, aOldValues, aGuard );
 488         }
 489         else
 490             movementFailed();
 491
 492         // - IsModified
 493         // - IsNew
 494         aNotifier.fire( );
 495
 496         // RowCount/IsRowCountFinal
 497         fireRowcount();
 498     }
 499     SAL_INFO("dbaccess", "ORowSetBase::moveRelativeToBookmark(Any," << rows << ") = " << bRet << " Clone = " << m_bClone);
 500     return bRet;
 501 }
 502
 503 sal_Int32 SAL_CALL ORowSetBase::compareBookmarks( const Any& _first, const Any& _second )
 504 {
 505     ::osl::MutexGuard aGuard( *m_pMutex );
 506     checkCache();
 507     return m_pCache->compareBookmarks(_first,_second);
 508 }
 509
 510 sal_Bool SAL_CALL ORowSetBase::hasOrderedBookmarks(  )
 511 {
 512     ::osl::MutexGuard aGuard( *m_pMutex );
 513     checkCache();
 514     return m_pCache->hasOrderedBookmarks();
 515 }
 516
 517 sal_Int32 SAL_CALL ORowSetBase::hashBookmark( const Any& bookmark )
 518 {
 519     ::osl::MutexGuard aGuard( *m_pMutex );
 520     checkCache();
 521     return m_pCache->hashBookmark(bookmark);
 522 }
 523
 524 // XResultSetMetaDataSupplier
 525 Reference< XResultSetMetaData > SAL_CALL ORowSetBase::getMetaData(  )
 526 {
 527     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
 528
 529     Reference< XResultSetMetaData > xMeta;
 530     if(m_pCache)
 531         xMeta = m_pCache->getMetaData();
 532
 533     return xMeta;
 534 }
 535
 536 // XColumnLocate
 537 sal_Int32 SAL_CALL ORowSetBase::findColumn( const OUString& columnName )
 538 {
 539     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
 540
 541     ::osl::MutexGuard aGuard( m_aColumnsMutex );
 542     // it is possible to save some time here when we remember the names - position relation in a map
 543     return m_pColumns ? m_pColumns->findColumn(columnName) : sal_Int32(0);
 544 }
 545
 546 // css::sdbcx::XColumnsSupplier
 547 Reference< XNameAccess > SAL_CALL ORowSetBase::getColumns(  )
 548 {
 549     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
 550
 551     ::osl::MutexGuard aGuard( m_aColumnsMutex );
 552     if(!m_pColumns)
 553     {
 554         if (!m_pEmptyCollection)
 555             m_pEmptyCollection.reset( new OEmptyCollection(*m_pMySelf,m_aColumnsMutex) );
 556         return m_pEmptyCollection.get();
 557     }
 558
 559     return m_pColumns.get();
 560 }
 561
 562 // XResultSet
 563 sal_Bool SAL_CALL ORowSetBase::next(  )
 564 {
 565     SAL_INFO("dbaccess", "ORowSetBase::next() Clone = " << m_bClone);
 566     ::osl::ResettableMutexGuard aGuard( *m_pMutex );
 567     checkCache();
 568
 569     bool bRet( notifyAllListenersCursorBeforeMove( aGuard ) );
 570     if ( bRet )
 571     {
 572         // check if we are inserting a row
 573         bool bWasNew = m_pCache->m_bNew || impl_rowDeleted();
 574
 575         ORowSetNotifier aNotifier( this );
 576             // this will call cancelRowModification on the cache if necessary
 577
 578         ORowSetRow aOldValues = getOldRow(bWasNew);
 579
 580         positionCache( CursorMoveDirection::Forward );
 581         bool bAfterLast = m_pCache->isAfterLast();
 582         bRet = m_pCache->next();
 583         doCancelModification( );
 584
 585         // if we were afterLast before next() then we still are,
 586         // i.e. bAfterLast implies m_pCache->isAfterLast()
 587         if (bAfterLast)
 588             assert(m_pCache->isAfterLast());
 589         // so the only way bAfterLast != m_pCache->isAfterLast()
 590         // would be that we just arrived there,
 591         if (bAfterLast != m_pCache->isAfterLast())
 592         {
 593             assert(!bAfterLast);
 594             assert(m_pCache->isAfterLast());
 595         }
 596         // in which case we *did* move the cursor
 597         if ( bRet || bAfterLast != m_pCache->isAfterLast() )
 598         {
 599             // notification order
 600             // - column values
 601             // - cursorMoved
 602             setCurrentRow( true, true, aOldValues, aGuard );
 603             OSL_ENSURE(!m_bBeforeFirst,"BeforeFirst is true. I don't know why?");
 604         }
 605         else
 606         {
 607             // moved after the last row
 608             movementFailed();
 609             OSL_ENSURE(m_bAfterLast,"AfterLast is false. I don't know why?");
 610         }
 611
 612         // - IsModified
 613         // - IsNew
 614         aNotifier.fire();
 615
 616         // - RowCount/IsRowCountFinal
 617         fireRowcount();
 618     }
 619     SAL_INFO("dbaccess", "ORowSetBase::next() = " << bRet << " Clone = " << m_bClone);
 620     return bRet;
 621 }
 622
 623 sal_Bool SAL_CALL ORowSetBase::isBeforeFirst(  )
 624 {
 625     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
 626     ::osl::MutexGuard aGuard( *m_pMutex );
 627     checkCache();
 628
 629     SAL_INFO("dbaccess", "ORowSetBase::isBeforeFirst() = " << m_bBeforeFirst << " Clone = " << m_bClone);
 630
 631     return m_bBeforeFirst;
 632 }
 633
 634 sal_Bool SAL_CALL ORowSetBase::isAfterLast(  )
 635 {
 636     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
 637     ::osl::MutexGuard aGuard( *m_pMutex );
 638     checkCache();
 639     SAL_INFO("dbaccess", "ORowSetBase::isAfterLast() = " << m_bAfterLast << " Clone = " << m_bClone);
 640
 641     return m_bAfterLast;
 642 }
 643
 644 bool ORowSetBase::isOnFirst()
 645 {
 646     return isFirst();
 647 }
 648
 649 sal_Bool SAL_CALL ORowSetBase::isFirst(  )
 650 {
 651     SAL_INFO("dbaccess", "ORowSetBase::isFirst() Clone = " << m_bClone);
 652
 653     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
 654     ::osl::MutexGuard aGuard( *m_pMutex );
 655     checkCache();
 656
 657     if ( m_bBeforeFirst || m_bAfterLast )
 658         return false;
 659
 660     if ( impl_rowDeleted() )
 661         return ( m_nDeletedPosition == 1 );
 662
 663     positionCache( CursorMoveDirection::Current );
 664     bool bIsFirst = m_pCache->isFirst();
 665
 666     SAL_INFO("dbaccess", "ORowSetBase::isFirst() = " << bIsFirst << " Clone = " << m_bClone);
 667     return bIsFirst;
 668 }
 669
 670 bool ORowSetBase::isOnLast()
 671 {
 672     return isLast();
 673 }
 674
 675 sal_Bool SAL_CALL ORowSetBase::isLast(  )
 676 {
 677     SAL_INFO("dbaccess", "ORowSetBase::isLast() Clone = " << m_bClone);
 678     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
 679     ::osl::MutexGuard aGuard( *m_pMutex );
 680     checkCache();
 681
 682     if ( m_bBeforeFirst || m_bAfterLast )
 683         return false;
 684
 685     if ( impl_rowDeleted() )
 686     {
 687         if ( !m_pCache->m_bRowCountFinal )
 688             return false;
 689         else
 690             return ( m_nDeletedPosition == impl_getRowCount() );
 691     }
 692
 693     positionCache( CursorMoveDirection::Current );
 694     bool bIsLast = m_pCache->isLast();
 695
 696     SAL_INFO("dbaccess", "ORowSetBase::isLast() = " << bIsLast << " Clone = " << m_bClone);
 697     return bIsLast;
 698 }
 699
 700 void SAL_CALL ORowSetBase::beforeFirst(  )
 701 {
 702     SAL_INFO("dbaccess", "ORowSetBase::beforeFirst() Clone = " << m_bClone);
 703     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
 704     ::osl::ResettableMutexGuard aGuard( *m_pMutex );
 705
 706     checkPositioningAllowed();
 707
 708     // check if we are inserting a row
 709     bool bWasNew = m_pCache->m_bNew || impl_rowDeleted();
 710
 711     if((bWasNew || !m_bBeforeFirst) && notifyAllListenersCursorBeforeMove(aGuard) )
 712     {
 713         ORowSetNotifier aNotifier( this );
 714             // this will call cancelRowModification on the cache if necessary
 715
 716         if ( !m_bBeforeFirst )
 717         {
 718             ORowSetRow aOldValues = getOldRow(bWasNew);
 719             m_pCache->beforeFirst();
 720             doCancelModification( );
 721
 722             // notification order
 723             // - column values
 724             // - cursorMoved
 725             setCurrentRow( true, true, aOldValues, aGuard );
 726
 727             // - IsModified
 728             // - Isnew
 729             aNotifier.fire();
 730
 731             // - RowCount/IsRowCountFinal
 732             fireRowcount();
 733         }
 734
 735         // to be done _after_ the notifications!
 736         m_aOldRow->clearRow();
 737     }
 738     SAL_INFO("dbaccess", "ORowSetBase::beforeFirst() Clone = " << m_bClone);
 739 }
 740
 741 void SAL_CALL ORowSetBase::afterLast(  )
 742 {
 743     SAL_INFO("dbaccess", "ORowSetBase::afterLast() Clone = " << m_bClone);
 744     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
 745
 746     ::osl::ResettableMutexGuard aGuard( *m_pMutex );
 747     checkPositioningAllowed();
 748
 749     bool bWasNew = m_pCache->m_bNew || impl_rowDeleted();
 750
 751     if((bWasNew || !m_bAfterLast) && notifyAllListenersCursorBeforeMove(aGuard) )
 752     {
 753         // check if we are inserting a row
 754         ORowSetNotifier aNotifier( this );
 755             // this will call cancelRowModification on the cache if necessary
 756
 757         if(!m_bAfterLast)
 758         {
 759             ORowSetRow aOldValues = getOldRow(bWasNew);
 760
 761             m_pCache->afterLast();
 762             doCancelModification( );
 763
 764             // notification order
 765             // - column values
 766             // - cursorMoved
 767             setCurrentRow( true, true, aOldValues, aGuard );
 768
 769             // - IsModified
 770             // - Isnew
 771             aNotifier.fire();
 772
 773             // - RowCount/IsRowCountFinal
 774             fireRowcount();
 775         }
 776     }
 777     SAL_INFO("dbaccess", "ORowSetBase::afterLast() Clone = " << m_bClone);
 778 }
 779
 780 bool SAL_CALL ORowSetBase::move(std::function<bool(ORowSetBase *)> const & _aCheckFunctor,
 781                                 std::function<bool(ORowSetCache *)> const & _aMovementFunctor)
 782 {
 783     SAL_INFO("dbaccess", "ORowSetBase::move() Clone = " << m_bClone);
 784     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
 785     ::osl::ResettableMutexGuard aGuard( *m_pMutex );
 786     checkPositioningAllowed();
 787
 788     bool bRet( notifyAllListenersCursorBeforeMove( aGuard ) );
 789     if( bRet )
 790     {
 791         // check if we are inserting a row
 792         bool bWasNew = m_pCache->m_bNew || rowDeleted();
 793
 794         ORowSetNotifier aNotifier( this );
 795             // this will call cancelRowModification on the cache if necessary
 796
 797         ORowSetRow aOldValues = getOldRow(bWasNew);
 798
 799         bool bMoved = ( bWasNew || !_aCheckFunctor(this) );
 800
 801         bRet = _aMovementFunctor(m_pCache.get());
 802         doCancelModification( );
 803
 804         if ( bRet )
 805         {
 806             // notification order
 807             // - column values
 808             // - cursorMoved
 809             setCurrentRow( bMoved, true, aOldValues, aGuard );
 810         }
 811         else
 812         {   // first goes wrong so there is no row
 813             movementFailed();
 814         }
 815
 816         // - IsModified
 817         // - IsNew
 818         aNotifier.fire();
 819
 820         // - RowCount/IsRowCountFinal
 821         fireRowcount();
 822     }
 823     SAL_INFO("dbaccess", "ORowSetBase::move() = " << bRet << " Clone = " << m_bClone);
 824     return bRet;
 825 }
 826
 827 sal_Bool SAL_CALL ORowSetBase::first(  )
 828 {
 829     SAL_INFO("dbaccess", "ORowSetBase::first() Clone = " << m_bClone);
 830     auto ioF_tmp = std::mem_fn(&ORowSetBase::isOnFirst);
 831     auto F_tmp = std::mem_fn(&ORowSetCache::first);
 832     return move(ioF_tmp,F_tmp);
 833 }
 834
 835 sal_Bool SAL_CALL ORowSetBase::last(  )
 836 {
 837     SAL_INFO("dbaccess", "ORowSetBase::last() Clone = " << m_bClone);
 838     auto ioL_tmp = std::mem_fn(&ORowSetBase::isOnLast);
 839     auto L_tmp = std::mem_fn(&ORowSetCache::last);
 840     return move(ioL_tmp,L_tmp);
 841 }
 842
 843 sal_Int32 SAL_CALL ORowSetBase::getRow(  )
 844 {
 845     SAL_INFO("dbaccess", "ORowSetBase::getRow() Clone = " << m_bClone);
 846     ::osl::MutexGuard aGuard( *m_pMutex );
 847
 848     checkCache();
 849     return impl_getRow();
 850 }
 851
 852 sal_Int32 ORowSetBase::impl_getRow()
 853 {
 854     sal_Int32  nPos = 0;
 855     if ( m_bBeforeFirst )
 856         nPos = 0;
 857     else if ( m_bAfterLast )
 858         nPos = impl_getRowCount() + 1;
 859     else if ( impl_rowDeleted() )
 860         nPos = m_nDeletedPosition;
 861     else if ( !m_bClone && m_pCache->m_bNew )
 862         nPos = 0;
 863     else
 864     {
 865         positionCache( CursorMoveDirection::Current );
 866         nPos = m_pCache->getRow();
 867     }
 868     SAL_INFO("dbaccess", "ORowSetBase::impl_getRow() = " << nPos << " Clone = " << m_bClone);
 869     return nPos;
 870 }
 871
 872 sal_Bool SAL_CALL ORowSetBase::absolute( sal_Int32 row )
 873 {
 874     SAL_INFO("dbaccess", "ORowSetBase::absolute(" << row << ") Clone = " << m_bClone);
 875     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
 876     ::osl::ResettableMutexGuard aGuard( *m_pMutex );
 877     checkPositioningAllowed();
 878
 879     bool bRet = ( row > 0 )
 880                 &&  notifyAllListenersCursorBeforeMove( aGuard );
 881     if ( bRet )
 882     {
 883         // check if we are inserting a row
 884         bool bWasNew = m_pCache->m_bNew || rowDeleted();
 885
 886         ORowSetNotifier aNotifier( this );
 887             // this will call cancelRowModification on the cache if necessary
 888
 889         ORowSetRow aOldValues = getOldRow(bWasNew);
 890
 891         bRet = m_pCache->absolute(row);
 892         doCancelModification( );
 893
 894         if(bRet)
 895         {
 896             // notification order
 897             // - column values
 898             // - cursorMoved
 899             setCurrentRow( true, true, aOldValues, aGuard );
 900         }
 901         else
 902         { // absolute movement goes wrong we stand left or right side of the rows
 903             movementFailed();
 904         }
 905
 906         // - IsModified
 907         // - IsNew
 908         aNotifier.fire();
 909
 910         // - RowCount/IsRowCountFinal
 911         fireRowcount();
 912     }
 913     SAL_INFO("dbaccess", "ORowSetBase::absolute(" << row << ") = " << bRet << " Clone = " << m_bClone);
 914     return bRet;
 915 }
 916
 917 sal_Bool SAL_CALL ORowSetBase::relative( sal_Int32 rows )
 918 {
 919     SAL_INFO("dbaccess", "ORowSetBase::relative(" << rows << ") Clone = " << m_bClone);
 920     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
 921
 922     ::osl::ResettableMutexGuard aGuard( *m_pMutex );
 923
 924     if(!rows)
 925         return true; // in this case do nothing
 926
 927     checkPositioningAllowed();
 928
 929     bool bRet =
 930             (  ( !m_bAfterLast || rows <= 0 )
 931             && ( !m_bBeforeFirst || rows >= 0 )
 932             && notifyAllListenersCursorBeforeMove( aGuard )
 933             );
 934
 935     if ( bRet )
 936     {
 937         // check if we are inserting a row
 938         bool bWasNew = m_pCache->m_bNew || rowDeleted();
 939
 940         ORowSetNotifier aNotifier( this );
 941             // this will call cancelRowModification on the cache if necessary
 942
 943         ORowSetRow aOldValues = getOldRow(bWasNew);
 944
 945         positionCache( rows > 0 ? CursorMoveDirection::Forward : CursorMoveDirection::Backward );
 946         bRet = m_pCache->relative(rows);
 947         doCancelModification( );
 948
 949         if(bRet)
 950         {
 951             // notification order
 952             // - column values
 953             // - cursorMoved
 954             setCurrentRow( true, true, aOldValues, aGuard );
 955         }
 956         else
 957         {
 958             movementFailed();
 959         }
 960
 961         // - IsModified
 962         // - IsNew
 963         aNotifier.fire();
 964
 965         // - RowCount/IsRowCountFinal
 966         fireRowcount();
 967     }
 968     SAL_INFO("dbaccess", "ORowSetBase::relative(" << rows << ") = " << bRet << " Clone = " << m_bClone);
 969     return bRet;
 970 }
 971
 972 sal_Bool SAL_CALL ORowSetBase::previous(  )
 973 {
 974     SAL_INFO("dbaccess", "ORowSetBase::previous() Clone = " << m_bClone);
 975     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
 976     ::osl::ResettableMutexGuard aGuard( *m_pMutex );
 977
 978     checkPositioningAllowed();
 979
 980     bool bRet = !m_bBeforeFirst
 981                 &&  notifyAllListenersCursorBeforeMove(aGuard);
 982
 983     if ( bRet )
 984     {
 985         // check if we are inserting a row
 986         bool bWasNew = m_pCache->m_bNew || rowDeleted();
 987
 988         ORowSetNotifier aNotifier( this );
 989             // this will call cancelRowModification on the cache if necessary
 990
 991         ORowSetRow aOldValues = getOldRow(bWasNew);
 992
 993         positionCache( CursorMoveDirection::Backward );
 994         bRet = m_pCache->previous();
 995         doCancelModification( );
 996
 997         // if m_bBeforeFirst is false and bRet is false then we stood on the first row
 998         if(!m_bBeforeFirst || bRet)
 999         {
1000             // notification order
1001             // - column values
1002             // - cursorMoved
1003             setCurrentRow( true, true, aOldValues, aGuard );
1004         }
1005         else
1006         {
1007             SAL_WARN("dbaccess", "ORowSetBase::previous: inconsistency!" );
1008                 // we should never reach this place, as we should not get into this whole branch if m_bBeforeFirst
1009                 // was |true| from the beginning
1010             movementFailed();
1011         }
1012
1013         // - IsModified
1014         // - IsNew
1015         aNotifier.fire();
1016
1017         // - RowCount/IsRowCountFinal
1018         fireRowcount();
1019     }
1020     SAL_INFO("dbaccess", "ORowSetBase::previous() = " << bRet << " Clone = " << m_bClone);
1021     return bRet;
1022 }
1023
1024 void ORowSetBase::setCurrentRow( bool _bMoved, bool _bDoNotify, const ORowSetRow& _rOldValues, ::osl::ResettableMutexGuard& _rGuard )
1025 {
1026     SAL_INFO("dbaccess", "ORowSetBase::setCurrentRow() Clone = " << m_bClone);
1027     m_bBeforeFirst  = m_pCache->isBeforeFirst();
1028     m_bAfterLast    = m_pCache->isAfterLast();
1029
1030     if(!(m_bBeforeFirst || m_bAfterLast))
1031     {
1032         m_aBookmark     = m_pCache->getBookmark();
1033         OSL_ENSURE(m_aBookmark.hasValue(),"Bookmark has no value!");
1034         m_aCurrentRow   = m_pCache->m_aMatrixIter;
1035         m_bIsInsertRow  = false;
1036         OSL_ENSURE(!m_aCurrentRow.isNull(),"CurrentRow is null!");
1037         OSL_ENSURE(!m_aCurrentRow.isNull() && m_aCurrentRow != m_pCache->getEnd(),"Position of matrix iterator isn't valid!");
1038         OSL_ENSURE(m_aCurrentRow->is(),"Currentrow isn't valid");
1039         OSL_ENSURE(m_aBookmark.hasValue(),"Bookmark has no value!");
1040
1041         m_aCurrentRow   = m_pCache->m_aMatrixIter;
1042         m_bIsInsertRow  = false;
1043         OSL_ENSURE(!m_aCurrentRow.isNull(),"CurrentRow is nul after positionCache!");
1044 #if OSL_DEBUG_LEVEL > 0
1045         ORowSetRow rRow = *m_aCurrentRow;
1046         OSL_ENSURE(rRow.is() ,"Invalid size of vector!");
1047 #endif
1048
1049         // notification order
1050         // - column values
1051         if ( _bDoNotify )
1052             firePropertyChange(_rOldValues);
1053
1054     }
1055     else
1056     {
1057         m_aOldRow->clearRow();
1058         m_aCurrentRow   = m_pCache->getEnd();
1059         m_aBookmark     = Any();
1060     }
1061
1062     // TODO: can this be done before the notifications?
1063     if(!(m_bBeforeFirst || m_bAfterLast) && !m_aCurrentRow.isNull() && m_aCurrentRow->is() && m_aCurrentRow != m_pCache->getEnd())
1064         m_aOldRow->setRow(new ORowSetValueVector( *(*m_aCurrentRow) ));
1065
1066     if ( _bMoved && _bDoNotify )
1067         // - cursorMoved
1068         notifyAllListenersCursorMoved( _rGuard );
1069
1070     SAL_INFO("dbaccess", "ORowSetBase::setCurrentRow() Clone = " << m_bClone);
1071 }
1072
1073 void ORowSetBase::checkPositioningAllowed()
1074 {
1075     if(!m_pCache || m_nResultSetType == ResultSetType::FORWARD_ONLY)
1076         throwFunctionSequenceException(*m_pMySelf);
1077 }
1078
1079 Reference< XInterface >  ORowSetBase::getStatement()
1080 {
1081     return nullptr;
1082 }
1083
1084 void SAL_CALL ORowSetBase::refreshRow(  )
1085 {
1086     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
1087     ::osl::MutexGuard aGuard( *m_pMutex );
1088     checkCache();
1089     if ( impl_rowDeleted() )
1090         throwSQLException( u"The current row is deleted"_ustr, StandardSQLState::INVALID_CURSOR_STATE, Reference< XRowSet >( this ) );
1091
1092     if(!(m_bBeforeFirst || m_bAfterLast))
1093     {
1094         bool bWasNew = m_pCache->m_bNew || impl_rowDeleted();
1095         ORowSetRow aOldValues = getOldRow(bWasNew);
1096         positionCache( CursorMoveDirection::Current );
1097         m_pCache->refreshRow();
1098         firePropertyChange(aOldValues);
1099     }
1100 }
1101
1102 sal_Bool SAL_CALL ORowSetBase::rowUpdated(  )
1103 {
1104     ::osl::MutexGuard aGuard( *m_pMutex );
1105     checkCache();
1106
1107     if ( impl_rowDeleted() )
1108         return false;
1109
1110     return m_pCache->rowUpdated();
1111 }
1112
1113 sal_Bool SAL_CALL ORowSetBase::rowInserted(  )
1114 {
1115     ::osl::MutexGuard aGuard( *m_pMutex );
1116
1117     checkCache();
1118
1119     if ( impl_rowDeleted() )
1120         return false;
1121
1122     return m_pCache->rowInserted();
1123 }
1124
1125 sal_Bool SAL_CALL ORowSetBase::rowDeleted(  )
1126 {
1127     ::osl::MutexGuard aGuard( *m_pMutex );
1128     checkCache();
1129     return impl_rowDeleted();
1130 }
1131
1132 bool ORowSetBase::impl_rowDeleted(  )
1133 {
1134     return !m_aBookmark.hasValue() && !m_bBeforeFirst && !m_bAfterLast;
1135 }
1136
1137 // XWarningsSupplier
1138 Any SAL_CALL ORowSetBase::getWarnings(  )
1139 {
1140     ::osl::MutexGuard aGuard( *m_pMutex );
1141
1142     if ( m_pCache )
1143     {
1144         Reference< XWarningsSupplier > xWarnings( m_pCache->m_xSet.get(), UNO_QUERY );
1145         if ( xWarnings.is() )
1146             return xWarnings->getWarnings();
1147     }
1148
1149     return Any();
1150 }
1151
1152 void SAL_CALL ORowSetBase::clearWarnings(  )
1153 {
1154     ::osl::MutexGuard aGuard( *m_pMutex );
1155
1156     if ( m_pCache )
1157     {
1158         Reference< XWarningsSupplier > xWarnings( m_pCache->m_xSet.get(), UNO_QUERY );
1159         if ( xWarnings.is() )
1160             xWarnings->clearWarnings();
1161     }
1162 }
1163
1164 void ORowSetBase::firePropertyChange(const ORowSetRow& _rOldRow)
1165 {
1166     if (!isPropertyChangeNotificationEnabled())
1167         return;
1168
1169     SAL_INFO("dbaccess", "ORowSetBase::firePropertyChange" );
1170     SAL_INFO("dbaccess", "ORowSetBase::firePropertyChange() Clone = " << m_bClone);
1171     OSL_ENSURE(m_pColumns,"Columns can not be NULL here!");
1172     sal_Int32 i=0;
1173     for (auto const& dataColumn : m_aDataColumns)
1174     {
1175         try
1176         {
1177             dataColumn->fireValueChange(_rOldRow.is() ? (*_rOldRow)[i+1] : ::connectivity::ORowSetValue());
1178         }
1179         catch (const Exception&)
1180         {
1181             TOOLS_WARN_EXCEPTION("dbaccess", "firePropertyChange: Exception on column " << i);
1182         }
1183         ++i;
1184     }
1185     SAL_INFO("dbaccess", "ORowSetBase::firePropertyChange() Clone = " << m_bClone);
1186 }
1187
1188 void ORowSetBase::firePropertyChange(sal_Int32 _nPos,const ::connectivity::ORowSetValue& _rOldValue)
1189 {
1190     OSL_ENSURE(_nPos < static_cast<sal_Int32>(m_aDataColumns.size()),"nPos is invalid!");
1191     m_aDataColumns[_nPos]->fireValueChange(_rOldValue);
1192 }
1193
1194 void ORowSetBase::fireRowcount()
1195 {
1196 }
1197
1198 bool ORowSetBase::notifyAllListenersCursorBeforeMove(::osl::ResettableMutexGuard& /*_rGuard*/)
1199 {
1200     return true;
1201 }
1202
1203 void ORowSetBase::notifyAllListenersCursorMoved(::osl::ResettableMutexGuard& /*_rGuard*/)
1204 {
1205 }
1206
1207 bool ORowSetBase::isPropertyChangeNotificationEnabled() const
1208 {
1209     return true;
1210 }
1211
1212 void ORowSetBase::fireProperty( sal_Int32 _nProperty, bool _bNew, bool _bOld )
1213 {
1214     Any aNew( _bNew );
1215     Any aOld( _bOld );
1216     fire( &_nProperty, &aNew, &aOld, 1, false );
1217 }
1218
1219 void ORowSetBase::positionCache( CursorMoveDirection _ePrepareForDirection )
1220 {
1221     SAL_INFO("dbaccess", "ORowSetBase::positionCache() Clone = " << m_bClone);
1222
1223     bool bSuccess = false;
1224     if ( m_aBookmark.hasValue() )
1225     {
1226         if (_ePrepareForDirection == CursorMoveDirection::CurrentRefresh ||
1227             (m_pCache->isAfterLast() != bool(isAfterLast())) || ( m_pCache->isBeforeFirst() != bool(isBeforeFirst()) ) ||
1228              m_pCache->compareBookmarks( m_aBookmark, m_pCache->getBookmark() ) != CompareBookmark::EQUAL )
1229             bSuccess = m_pCache->moveToBookmark( m_aBookmark );
1230         else
1231             bSuccess = true;
1232     }
1233     else
1234     {
1235         if ( m_bBeforeFirst )
1236         {
1237             m_pCache->beforeFirst();
1238             bSuccess = true;
1239         }
1240         else if ( m_bAfterLast )
1241         {
1242             m_pCache->afterLast();
1243             bSuccess = true;
1244         }
1245         else
1246         {
1247             OSL_ENSURE( m_nDeletedPosition >= 1, "ORowSetBase::positionCache: no bookmark, and no valid 'deleted position'!" );
1248             switch ( _ePrepareForDirection )
1249             {
1250             case CursorMoveDirection::Forward:
1251                 if ( m_nDeletedPosition > 1 )
1252                     bSuccess = m_pCache->absolute( m_nDeletedPosition - 1 );
1253                 else
1254                 {
1255                     m_pCache->beforeFirst();
1256                     bSuccess = true;
1257                 }
1258                 break;
1259
1260             case CursorMoveDirection::Backward:
1261                 if ( m_pCache->m_bRowCountFinal && ( m_nDeletedPosition == impl_getRowCount() ) )
1262                 {
1263                     m_pCache->afterLast();
1264                     bSuccess = true;
1265                 }
1266                 else
1267                     bSuccess = m_pCache->absolute( m_nDeletedPosition );
1268                 break;
1269
1270             case CursorMoveDirection::Current:
1271             case CursorMoveDirection::CurrentRefresh:
1272                 bSuccess = false;   // will be asserted below
1273                 break;
1274             }
1275         }
1276     }
1277     OSL_ENSURE( bSuccess, "ORowSetBase::positionCache: failed!" );
1278
1279     SAL_INFO("dbaccess", "ORowSetBase::positionCache() Clone = " << m_bClone);
1280 }
1281
1282 void ORowSetBase::checkCache()
1283 {
1284     ::connectivity::checkDisposed(m_rBHelper.bDisposed);
1285     if(!m_pCache)
1286         throwFunctionSequenceException(*m_pMySelf);
1287 }
1288
1289 void ORowSetBase::movementFailed()
1290 {
1291     SAL_INFO("dbaccess", "ORowSetBase::movementFailed() Clone = " << m_bClone);
1292     m_aOldRow->clearRow();
1293     m_aCurrentRow   = m_pCache->getEnd();
1294     m_bBeforeFirst  = m_pCache->isBeforeFirst();
1295     m_bAfterLast    = m_pCache->isAfterLast();
1296     m_aBookmark     = Any();
1297     OSL_ENSURE(m_bBeforeFirst || m_bAfterLast,"BeforeFirst or AfterLast is wrong!");
1298     SAL_INFO("dbaccess", "ORowSetBase::movementFailed() Clone = " << m_bClone);
1299 }
1300
1301 ORowSetRow ORowSetBase::getOldRow(bool _bWasNew)
1302 {
1303     OSL_ENSURE(m_aOldRow.is(),"RowSetRowHElper isn't valid!");
1304     ORowSetRow aOldValues;
1305     if ( !_bWasNew && m_aOldRow->getRow().is() )
1306         aOldValues = new ORowSetValueVector( *(m_aOldRow->getRow()));    // remember the old values
1307     return aOldValues;
1308 }
1309
1310 void ORowSetBase::getPropertyDefaultByHandle( sal_Int32 /*_nHandle*/, Any& _rDefault ) const
1311 {
1312     _rDefault.clear();
1313 }
1314
1315 void ORowSetBase::onDeleteRow( const Any& _rBookmark )
1316 {
1317     if ( rowDeleted() )
1318         // not interested in
1319         return;
1320
1321     ::osl::MutexGuard aGuard( *m_pMutex );
1322     //OSL_ENSURE( m_aBookmark.hasValue(), "ORowSetBase::onDeleteRow: Bookmark isn't valid!" );
1323     if ( compareBookmarks( _rBookmark, m_aBookmark ) == CompareBookmark::EQUAL )
1324     {
1325         positionCache( CursorMoveDirection::Current );
1326         m_nDeletedPosition = m_pCache->getRow();
1327     }
1328 }
1329
1330 void ORowSetBase::onDeletedRow( const Any& _rBookmark, sal_Int32 _nPos )
1331 {
1332     if ( rowDeleted() )
1333     {
1334         // if we're a clone, and on a deleted row, and the main RowSet deleted another
1335         // row (only the main RowSet can, clones can't), which is *before* our
1336         // deleted position, then we have to adjust this position
1337         if ( m_bClone && ( _nPos < m_nDeletedPosition ) )
1338             --m_nDeletedPosition;
1339         return;
1340     }
1341
1342     ::osl::MutexGuard aGuard( *m_pMutex );
1343     if ( compareBookmarks( _rBookmark, m_aBookmark ) == CompareBookmark::EQUAL )
1344     {
1345         m_aOldRow->clearRow();
1346         m_aCurrentRow   = m_pCache->getEnd();
1347         m_aBookmark     = Any();
1348     }
1349 }
1350
1351 sal_Int32 ORowSetBase::impl_getRowCount() const
1352 {
1353     sal_Int32 nRowCount( m_pCache->m_nRowCount );
1354     if ( const_cast< ORowSetBase* >( this )->rowDeleted() && !m_pCache->m_bNew )
1355         ++nRowCount;
1356     return nRowCount;
1357 }
1358
1359
1360 ORowSetNotifier::ORowSetNotifier( ORowSetBase* _pRowSet )
1361     :m_pRowSet( _pRowSet )
1362     ,m_bWasNew( false )
1363     ,m_bWasModified( false )
1364 {
1365
1366     OSL_ENSURE( m_pRowSet, "ORowSetNotifier::ORowSetNotifier: invalid row set. This will crash." );
1367
1368     // remember the "inserted" and "modified" state for later firing
1369     m_bWasNew       = m_pRowSet->isNew( ORowSetBase::GrantNotifierAccess() );
1370     m_bWasModified  = m_pRowSet->isModified( ORowSetBase::GrantNotifierAccess() );
1371
1372     // if the row set is on the insert row, then we need to cancel this
1373     if ( m_pRowSet->isModification( ORowSetBase::GrantNotifierAccess() ) )
1374         m_pRowSet->doCancelModification( ORowSetBase::GrantNotifierAccess() );
1375 }
1376
1377 ORowSetNotifier::ORowSetNotifier( ORowSetBase* _pRowSet, ORowSetValueVector::Vector&& i_aRow )
1378     :m_pRowSet( _pRowSet )
1379     ,m_bWasNew( false )
1380     ,m_bWasModified( false )
1381 {
1382     OSL_ENSURE( m_pRowSet, "ORowSetNotifier::ORowSetNotifier: invalid row set. This will crash." );
1383     aRow = std::move(i_aRow); // yes, create a copy to store the old values
1384 }
1385
1386 ORowSetNotifier::~ORowSetNotifier( )
1387 {
1388 }
1389
1390 void ORowSetNotifier::fire()
1391 {
1392     // we're not interested in firing changes FALSE->TRUE, only TRUE->FALSE.
1393     // (the former would be quite pathological, e.g. after a failed movement)
1394
1395     if  (   m_bWasModified
1396         &&  ( m_bWasModified != m_pRowSet->isModified( ORowSetBase::GrantNotifierAccess() ) )
1397         )
1398         m_pRowSet->fireProperty( PROPERTY_ID_ISMODIFIED, false, true, ORowSetBase::GrantNotifierAccess() );
1399
1400     if  (   m_bWasNew
1401         &&  ( m_bWasNew != m_pRowSet->isNew( ORowSetBase::GrantNotifierAccess() ) )
1402         )
1403         m_pRowSet->fireProperty( PROPERTY_ID_ISNEW, false, true, ORowSetBase::GrantNotifierAccess() );
1404 }
1405
1406 std::vector<sal_Int32>& ORowSetNotifier::getChangedColumns()
1407 {
1408     return aChangedColumns;
1409 }
1410
1411 void ORowSetNotifier::firePropertyChange()
1412 {
1413     for (auto const& changedColumn : aChangedColumns)
1414     {
1415         m_pRowSet->firePropertyChange(changedColumn-1, aRow[changedColumn-1], ORowSetBase::GrantNotifierAccess());
1416     }
1417     if ( !aChangedColumns.empty() )
1418         m_pRowSet->fireProperty(PROPERTY_ID_ISMODIFIED,true,false, ORowSetBase::GrantNotifierAccess());
1419 }
1420
1421 }   // namespace dbaccess
1422
1423 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */