| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_dbaccess.hxx" |
| |
| #include "RowSetBase.hxx" |
| #include "CRowSetDataColumn.hxx" |
| #include <connectivity/sdbcx/VCollection.hxx> |
| #include "RowSetCache.hxx" |
| #include "dbastrings.hrc" |
| #include "core_resource.hrc" |
| #include <com/sun/star/lang/DisposedException.hpp> |
| #include <com/sun/star/beans/PropertyAttribute.hpp> |
| #include <com/sun/star/sdbcx/CompareBookmark.hpp> |
| #include <com/sun/star/sdbc/ResultSetConcurrency.hpp> |
| #include <com/sun/star/lang/Locale.hpp> |
| #include <com/sun/star/util/NumberFormat.hpp> |
| #include <comphelper/sequence.hxx> |
| #include <comphelper/extract.hxx> |
| #include <comphelper/seqstream.hxx> |
| #include <connectivity/dbexception.hxx> |
| #include <osl/thread.h> |
| #include <tools/debug.hxx> |
| #include <rtl/logfile.hxx> |
| |
| using namespace dbaccess; |
| using namespace connectivity; |
| using namespace connectivity::sdbcx; |
| using namespace comphelper; |
| using namespace dbtools; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::sdbc; |
| using namespace ::com::sun::star::sdb; |
| using namespace ::com::sun::star::sdbcx; |
| using namespace ::com::sun::star::container; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::util; |
| using namespace ::cppu; |
| using namespace ::osl; |
| |
| namespace dbaccess |
| { |
| |
| // ========================================================================= |
| // = OEmptyCollection |
| // ========================================================================= |
| // ------------------------------------------------------------------------- |
| class OEmptyCollection : public sdbcx::OCollection |
| { |
| protected: |
| virtual void impl_refresh() throw(RuntimeException); |
| virtual connectivity::sdbcx::ObjectType createObject(const ::rtl::OUString& _rName); |
| public: |
| OEmptyCollection(::cppu::OWeakObject& _rParent,::osl::Mutex& _rMutex) : OCollection(_rParent,sal_True,_rMutex,::std::vector< ::rtl::OUString>()){} |
| }; |
| // ----------------------------------------------------------------------------- |
| void OEmptyCollection::impl_refresh() throw(RuntimeException) |
| { |
| } |
| // ----------------------------------------------------------------------------- |
| connectivity::sdbcx::ObjectType OEmptyCollection::createObject(const ::rtl::OUString& /*_rName*/) |
| { |
| return connectivity::sdbcx::ObjectType(); |
| } |
| // ----------------------------------------------------------------------------- |
| |
| // ========================================================================= |
| // = ORowSetBase |
| // ========================================================================= |
| DBG_NAME(ORowSetBase) |
| // ------------------------------------------------------------------------- |
| ORowSetBase::ORowSetBase( const ::comphelper::ComponentContext& _rContext, ::cppu::OBroadcastHelper& _rBHelper, ::osl::Mutex* _pMutex ) |
| :OPropertyStateContainer(_rBHelper) |
| ,m_pMutex(_pMutex) |
| ,m_pCache(NULL) |
| ,m_pColumns(NULL) |
| ,m_rBHelper(_rBHelper) |
| ,m_pEmptyCollection( NULL ) |
| ,m_aContext( _rContext ) |
| ,m_aErrors( _rContext ) |
| ,m_nLastColumnIndex(-1) |
| ,m_nDeletedPosition(-1) |
| ,m_nResultSetType( ResultSetType::FORWARD_ONLY ) |
| ,m_nResultSetConcurrency( ResultSetConcurrency::READ_ONLY ) |
| ,m_bClone(sal_False) |
| ,m_bIgnoreResult(sal_False) |
| ,m_bBeforeFirst(sal_True) // changed from sal_False |
| ,m_bAfterLast(sal_False) |
| ,m_bIsInsertRow(sal_False) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::ORowSetBase" ); |
| DBG_CTOR(ORowSetBase,NULL); |
| |
| sal_Int32 nRBT = PropertyAttribute::READONLY | PropertyAttribute::BOUND | PropertyAttribute::TRANSIENT; |
| |
| sal_Int32 nInitialRowCountValue = 0; |
| sal_Bool bInitialRowCountFinalValue( sal_False ); |
| registerPropertyNoMember( PROPERTY_ROWCOUNT, PROPERTY_ID_ROWCOUNT, nRBT, ::getCppuType( &nInitialRowCountValue ), &nInitialRowCountValue ); |
| registerPropertyNoMember( PROPERTY_ISROWCOUNTFINAL, PROPERTY_ID_ISROWCOUNTFINAL, nRBT, ::getBooleanCppuType(), &bInitialRowCountFinalValue ); |
| } |
| // ----------------------------------------------------------------------------- |
| ORowSetBase::~ORowSetBase() |
| { |
| if(m_pColumns) |
| { |
| TDataColumns().swap(m_aDataColumns); |
| m_pColumns->acquire(); |
| m_pColumns->disposing(); |
| delete m_pColumns; |
| m_pColumns = NULL; |
| } |
| |
| if ( m_pEmptyCollection ) |
| delete m_pEmptyCollection; |
| |
| DBG_DTOR(ORowSetBase,NULL); |
| } |
| // com::sun::star::lang::XTypeProvider |
| //-------------------------------------------------------------------------- |
| Sequence< Type > ORowSetBase::getTypes() throw (RuntimeException) |
| { |
| //RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getTypes" ); |
| return ::comphelper::concatSequences(ORowSetBase_BASE::getTypes(),OPropertyStateContainer::getTypes()); |
| } |
| // com::sun::star::uno::XInterface |
| //-------------------------------------------------------------------------- |
| Any ORowSetBase::queryInterface( const Type & rType ) throw (RuntimeException) |
| { |
| //RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::queryInterface" ); |
| Any aRet = ORowSetBase_BASE::queryInterface(rType); |
| if(!aRet.hasValue()) |
| aRet = OPropertyStateContainer::queryInterface(rType); |
| return aRet; |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSetBase::getFastPropertyValue(Any& rValue,sal_Int32 nHandle) const |
| { |
| //RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getFastPropertyValue" ); |
| if(m_pCache) |
| { |
| switch(nHandle) |
| { |
| case PROPERTY_ID_ROWCOUNT: |
| rValue <<= impl_getRowCount(); |
| break; |
| case PROPERTY_ID_ISROWCOUNTFINAL: |
| rValue.setValue(&m_pCache->m_bRowCountFinal,::getCppuBooleanType()); |
| break; |
| default: |
| OPropertyStateContainer::getFastPropertyValue(rValue,nHandle); |
| }; |
| } |
| else |
| OPropertyStateContainer::getFastPropertyValue(rValue,nHandle); |
| } |
| // ------------------------------------------------------------------------- |
| // OComponentHelper |
| void SAL_CALL ORowSetBase::disposing(void) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::disposing" ); |
| MutexGuard aGuard(*m_pMutex); |
| |
| if ( m_pColumns ) |
| { |
| TDataColumns().swap(m_aDataColumns); |
| m_pColumns->disposing(); |
| } |
| if ( m_pCache ) |
| { |
| m_pCache->deregisterOldRow(m_aOldRow); |
| m_pCache->deleteIterator(this); |
| } |
| m_pCache = NULL; |
| } |
| // ------------------------------------------------------------------------- |
| // comphelper::OPropertyArrayUsageHelper |
| ::cppu::IPropertyArrayHelper* ORowSetBase::createArrayHelper( ) const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::createArrayHelper" ); |
| Sequence< Property > aProps; |
| describeProperties(aProps); |
| return new ::cppu::OPropertyArrayHelper(aProps); |
| } |
| // ------------------------------------------------------------------------- |
| // cppu::OPropertySetHelper |
| ::cppu::IPropertyArrayHelper& SAL_CALL ORowSetBase::getInfoHelper() |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getInfoHelper" ); |
| return *const_cast<ORowSetBase*>(this)->getArrayHelper(); |
| } |
| // ------------------------------------------------------------------------- |
| // XRow |
| sal_Bool SAL_CALL ORowSetBase::wasNull( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::wasNull" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| return impl_wasNull(); |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool ORowSetBase::impl_wasNull() |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::impl_wasNull" ); |
| return ((m_nLastColumnIndex != -1) && !m_aCurrentRow.isNull() && m_aCurrentRow != m_pCache->getEnd() && m_aCurrentRow->isValid()) ? ((*m_aCurrentRow)->get())[m_nLastColumnIndex].isNull() : sal_True; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| const ORowSetValue& ORowSetBase::getValue(sal_Int32 columnIndex) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getValue" ); |
| checkCache(); |
| return impl_getValue(columnIndex); |
| } |
| // ----------------------------------------------------------------------------- |
| const ORowSetValue& ORowSetBase::impl_getValue(sal_Int32 columnIndex) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::impl_getValue" ); |
| if ( m_bBeforeFirst || m_bAfterLast ) |
| { |
| OSL_ENSURE(0,"ORowSetBase::getValue: Illegal call here (we're before first or after last)!"); |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_CURSOR_BEFORE_OR_AFTER ), SQL_INVALID_CURSOR_POSITION, *m_pMySelf ); |
| } |
| |
| if ( impl_rowDeleted() ) |
| { |
| return m_aEmptyValue; |
| } |
| |
| bool bValidCurrentRow = ( !m_aCurrentRow.isNull() && m_aCurrentRow != m_pCache->getEnd() && m_aCurrentRow->isValid() ); |
| if ( !bValidCurrentRow ) |
| { |
| // currentrow is null when the clone moves the window |
| positionCache( MOVE_NONE_REFRESH_ONLY ); |
| m_aCurrentRow = m_pCache->m_aMatrixIter; |
| m_bIsInsertRow = sal_False; |
| OSL_ENSURE(!m_aCurrentRow.isNull(),"ORowSetBase::getValue: we don't stand on a valid row! Row is null."); |
| |
| bValidCurrentRow = ( !m_aCurrentRow.isNull() && m_aCurrentRow != m_pCache->getEnd() && m_aCurrentRow->isValid() ); |
| } |
| |
| if ( bValidCurrentRow ) |
| { |
| #if OSL_DEBUG_LEVEL > 0 |
| ORowSetMatrix::iterator aCacheEnd; |
| ORowSetMatrix::iterator aCurrentRow; |
| aCacheEnd = m_pCache->getEnd(); |
| aCurrentRow = m_aCurrentRow; |
| ORowSetCacheMap::iterator aCacheIter = m_aCurrentRow.getIter(); |
| sal_Int32 n = aCacheIter->first; |
| n = n; |
| ORowSetCacheIterator_Helper aHelper = aCacheIter->second; |
| ORowSetMatrix::iterator k = aHelper.aIterator; |
| for (; k != m_pCache->getEnd(); ++k) |
| { |
| ORowSetValueVector* pTemp = k->getBodyPtr(); |
| OSL_ENSURE( pTemp != (void*)0xfeeefeee,"HALT!" ); |
| } |
| #endif |
| OSL_ENSURE(!m_aCurrentRow.isNull() && m_aCurrentRow < m_pCache->getEnd() && aCacheIter != m_pCache->m_aCacheIterators.end(),"Invalid iterator set for currentrow!"); |
| #if OSL_DEBUG_LEVEL > 0 |
| ORowSetRow rRow = (*m_aCurrentRow); |
| OSL_ENSURE(rRow.isValid() && static_cast<sal_uInt16>(columnIndex) < (rRow->get()).size(),"Invalid size of vector!"); |
| #endif |
| return ((*m_aCurrentRow)->get())[m_nLastColumnIndex = columnIndex]; |
| } |
| |
| // we should normally never reach this |
| return m_aEmptyValue; |
| } |
| // ------------------------------------------------------------------------- |
| ::rtl::OUString SAL_CALL ORowSetBase::getString( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getString" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::getBoolean( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getBoolean" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int8 SAL_CALL ORowSetBase::getByte( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getByte" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int16 SAL_CALL ORowSetBase::getShort( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getShort" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int32 SAL_CALL ORowSetBase::getInt( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getInt" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int64 SAL_CALL ORowSetBase::getLong( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getLong" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| float SAL_CALL ORowSetBase::getFloat( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getFloat" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| double SAL_CALL ORowSetBase::getDouble( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getDouble" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| Sequence< sal_Int8 > SAL_CALL ORowSetBase::getBytes( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getBytes" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| ::com::sun::star::util::Date SAL_CALL ORowSetBase::getDate( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getDate" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| ::com::sun::star::util::Time SAL_CALL ORowSetBase::getTime( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getTime" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| ::com::sun::star::util::DateTime SAL_CALL ORowSetBase::getTimestamp( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getTimestamp" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| Reference< ::com::sun::star::io::XInputStream > SAL_CALL ORowSetBase::getBinaryStream( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getBinaryStream" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| |
| if ( m_bBeforeFirst || m_bAfterLast ) |
| { |
| OSL_ENSURE(0,"ORowSetBase::getBinaryStream: Illegal call here (we're before first or after last)!"); |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_CURSOR_BEFORE_OR_AFTER ), SQL_INVALID_CURSOR_POSITION, *m_pMySelf ); |
| } |
| |
| if ( impl_rowDeleted() ) |
| { |
| return NULL; |
| } |
| |
| bool bValidCurrentRow = ( !m_aCurrentRow.isNull() && m_aCurrentRow != m_pCache->getEnd() && m_aCurrentRow->isValid() ); |
| if ( !bValidCurrentRow ) |
| { |
| positionCache( MOVE_NONE_REFRESH_ONLY ); |
| m_aCurrentRow = m_pCache->m_aMatrixIter; |
| m_bIsInsertRow = sal_False; |
| OSL_ENSURE(!m_aCurrentRow.isNull(),"ORowSetBase::getBinaryStream: we don't stand on a valid row! Row is null."); |
| |
| bValidCurrentRow = ( !m_aCurrentRow.isNull() && m_aCurrentRow != m_pCache->getEnd() && m_aCurrentRow->isValid() ); |
| } |
| |
| if ( bValidCurrentRow ) |
| return new ::comphelper::SequenceInputStream(((*m_aCurrentRow)->get())[m_nLastColumnIndex = columnIndex].getSequence()); |
| |
| // we should normally never reach this |
| return Reference< ::com::sun::star::io::XInputStream >(); |
| } |
| // ------------------------------------------------------------------------- |
| Reference< ::com::sun::star::io::XInputStream > SAL_CALL ORowSetBase::getCharacterStream( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getCharacterStream" ); |
| return getBinaryStream(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| Any SAL_CALL ORowSetBase::getObject( sal_Int32 columnIndex, const Reference< XNameAccess >& /*typeMap*/ ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getObject" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| |
| return getValue(columnIndex).makeAny(); |
| } |
| // ------------------------------------------------------------------------- |
| Reference< XRef > SAL_CALL ORowSetBase::getRef( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getRef" ); |
| ::dbtools::throwFeatureNotImplementedException( "XRow::getRef", *m_pMySelf ); |
| return NULL; |
| } |
| // ------------------------------------------------------------------------- |
| Reference< XBlob > SAL_CALL ORowSetBase::getBlob( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getBlob" ); |
| return Reference< XBlob >(getValue(columnIndex).makeAny(),UNO_QUERY); |
| } |
| // ------------------------------------------------------------------------- |
| Reference< XClob > SAL_CALL ORowSetBase::getClob( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getClob" ); |
| return Reference< XClob >(getValue(columnIndex).makeAny(),UNO_QUERY); |
| } |
| // ------------------------------------------------------------------------- |
| Reference< XArray > SAL_CALL ORowSetBase::getArray( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getArray" ); |
| ::dbtools::throwFeatureNotImplementedException( "XRow::getArray", *m_pMySelf ); |
| return NULL; |
| } |
| // ------------------------------------------------------------------------- |
| // ::com::sun::star::sdbcx::XRowLocate |
| Any SAL_CALL ORowSetBase::getBookmark( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getBookmark" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::getBookmark() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| |
| if ( m_bBeforeFirst || m_bAfterLast ) |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_NO_BOOKMARK_BEFORE_OR_AFTER ), SQL_INVALID_CURSOR_POSITION, *m_pMySelf ); |
| |
| if ( impl_rowDeleted() ) |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_NO_BOOKMARK_DELETED ), SQL_INVALID_CURSOR_POSITION, *m_pMySelf ); |
| |
| OSL_ENSURE( m_aBookmark.hasValue(), "ORowSetBase::getBookmark: bookmark has no value!" ); |
| return m_aBookmark; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::moveToBookmark( const Any& bookmark ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::moveToBookmark" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::moveToBookmark(Any) Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| OSL_ENSURE(bookmark.hasValue(),"ORowSetBase::moveToBookmark bookmark has no value!"); |
| ::osl::ResettableMutexGuard aGuard( *m_pMutex ); |
| |
| if(!bookmark.hasValue() || m_nResultSetType == ResultSetType::FORWARD_ONLY) |
| { |
| if(bookmark.hasValue()) |
| OSL_ENSURE(0,"MoveToBookmark is not possible when we are only forward"); |
| else |
| OSL_ENSURE(0,"Bookmark is not valid"); |
| throwFunctionSequenceException(*m_pMySelf); |
| } |
| |
| |
| checkCache(); |
| |
| sal_Bool bRet( notifyAllListenersCursorBeforeMove( aGuard ) ); |
| if ( bRet ) |
| { |
| // check if we are inserting a row |
| sal_Bool bWasNew = m_pCache->m_bNew || impl_rowDeleted(); |
| |
| ORowSetNotifier aNotifier( this ); |
| // this will call cancelRowModification on the cache if necessary |
| |
| ORowSetRow aOldValues = getOldRow(bWasNew); |
| |
| bRet = m_pCache->moveToBookmark(bookmark); |
| doCancelModification( ); |
| if(bRet) |
| { |
| // notification order |
| // - column values |
| // - cursorMoved |
| setCurrentRow( sal_True, sal_True, aOldValues, aGuard ); |
| } |
| else |
| { |
| movementFailed(); |
| } |
| |
| // - IsModified |
| // - IsNew |
| aNotifier.fire( ); |
| } |
| DBG_TRACE2("DBACCESS ORowSetBase::moveToBookmark(Any) = %i Clone = %i\n",bRet,m_bClone); |
| return bRet; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::moveRelativeToBookmark( const Any& bookmark, sal_Int32 rows ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::moveRelativeToBookmark" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::moveRelativeToBookmark(Any,%i) Clone = %i\n",rows,m_bClone); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| |
| ::osl::ResettableMutexGuard aGuard( *m_pMutex ); |
| |
| checkPositioningAllowed(); |
| |
| sal_Bool bRet( notifyAllListenersCursorBeforeMove( aGuard ) ); |
| if ( bRet ) |
| { |
| // check if we are inserting a row |
| sal_Bool bWasNew = m_pCache->m_bNew || rowDeleted(); |
| |
| ORowSetNotifier aNotifier( this ); |
| // this will call cancelRowModification on the cache if necessary |
| |
| ORowSetRow aOldValues = getOldRow(bWasNew); |
| |
| bRet = m_pCache->moveRelativeToBookmark(bookmark,rows); |
| doCancelModification( ); |
| if(bRet) |
| { |
| // notification order |
| // - column values |
| // - cursorMoved |
| setCurrentRow( sal_True, sal_True, aOldValues, aGuard ); |
| } |
| else |
| movementFailed(); |
| |
| // - IsModified |
| // - IsNew |
| aNotifier.fire( ); |
| |
| // RowCount/IsRowCountFinal |
| fireRowcount(); |
| } |
| DBG_TRACE3("DBACCESS ORowSetBase::moveRelativeToBookmark(Any,%i) = %i Clone = %i\n",rows,bRet,m_bClone); |
| return bRet; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int32 SAL_CALL ORowSetBase::compareBookmarks( const Any& _first, const Any& _second ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::compareBookmarks" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| return m_pCache->compareBookmarks(_first,_second); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::hasOrderedBookmarks( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::hasOrderedBookmarks" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| return m_pCache->hasOrderedBookmarks(); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int32 SAL_CALL ORowSetBase::hashBookmark( const Any& bookmark ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::hashBookmark" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| return m_pCache->hashBookmark(bookmark); |
| } |
| // ------------------------------------------------------------------------- |
| // ------------------------------------------------------------------------- |
| // XResultSetMetaDataSupplier |
| Reference< XResultSetMetaData > SAL_CALL ORowSetBase::getMetaData( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getMetaData" ); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| |
| Reference< XResultSetMetaData > xMeta; |
| if(m_pCache) |
| xMeta = m_pCache->getMetaData(); |
| |
| return xMeta; |
| } |
| // ------------------------------------------------------------------------- |
| |
| // XColumnLocate |
| sal_Int32 SAL_CALL ORowSetBase::findColumn( const ::rtl::OUString& columnName ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::findColumn" ); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| |
| ::osl::MutexGuard aGuard( m_aColumnsMutex ); |
| // it is possible to save some time her when we remember the names - position relation in a map |
| return m_pColumns ? m_pColumns->findColumn(columnName) : sal_Int32(0); |
| } |
| // ------------------------------------------------------------------------- |
| |
| // ::com::sun::star::sdbcx::XColumnsSupplier |
| Reference< XNameAccess > SAL_CALL ORowSetBase::getColumns( ) throw(RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getColumns" ); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| |
| ::osl::MutexGuard aGuard( m_aColumnsMutex ); |
| if(!m_pColumns) |
| { |
| if (!m_pEmptyCollection) |
| m_pEmptyCollection = new OEmptyCollection(*m_pMySelf,m_aColumnsMutex); |
| return m_pEmptyCollection; |
| } |
| |
| return m_pColumns; |
| } |
| // ------------------------------------------------------------------------- |
| // XResultSet |
| sal_Bool SAL_CALL ORowSetBase::next( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::next" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::next() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| ::osl::ResettableMutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| |
| sal_Bool bRet( notifyAllListenersCursorBeforeMove( aGuard ) ); |
| if ( bRet ) |
| { |
| // check if we are inserting a row |
| sal_Bool bWasNew = m_pCache->m_bNew || impl_rowDeleted(); |
| |
| ORowSetNotifier aNotifier( this ); |
| // this will call cancelRowModification on the cache if necessary |
| |
| ORowSetRow aOldValues = getOldRow(bWasNew); |
| |
| positionCache( MOVE_FORWARD ); |
| sal_Bool bAfterLast = m_pCache->isAfterLast(); |
| bRet = m_pCache->next(); |
| doCancelModification( ); |
| |
| |
| if ( bRet || bAfterLast != m_pCache->isAfterLast() ) |
| { |
| // notification order |
| // - column values |
| // - cursorMoved |
| setCurrentRow( bRet, sal_True, aOldValues, aGuard ); |
| OSL_ENSURE(!m_bBeforeFirst,"BeforeFirst is true. I don't know why?"); |
| } |
| else |
| { |
| // moved after the last row |
| movementFailed(); |
| OSL_ENSURE(m_bAfterLast,"AfterLast is false. I don't know why?"); |
| } |
| |
| // - IsModified |
| // - IsNew |
| aNotifier.fire(); |
| |
| // - RowCount/IsRowCountFinal |
| fireRowcount(); |
| } |
| DBG_TRACE3("DBACCESS ORowSetBase::next() = %i Clone = %i ID = %i\n",bRet,m_bClone,osl_getThreadIdentifier(NULL)); |
| return bRet; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::isBeforeFirst( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::isBeforeFirst" ); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| |
| DBG_TRACE2("DBACCESS ORowSetBase::isBeforeFirst() = %i Clone = %i\n",m_bBeforeFirst,m_bClone); |
| |
| return m_bBeforeFirst; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::isAfterLast( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::isAfterLast" ); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| DBG_TRACE2("DBACCESS ORowSetBase::isAfterLast() = %i Clone = %i\n",m_bAfterLast,m_bClone); |
| |
| return m_bAfterLast; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool ORowSetBase::isOnFirst() |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::isOnFirst" ); |
| return isFirst(); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::isFirst( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::isFirst" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::isFirst() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| |
| if ( m_bBeforeFirst || m_bAfterLast ) |
| return sal_False; |
| |
| if ( impl_rowDeleted() ) |
| return ( m_nDeletedPosition == 1 ); |
| |
| positionCache( MOVE_NONE_REFRESH_ONLY ); |
| sal_Bool bIsFirst = m_pCache->isFirst(); |
| |
| DBG_TRACE2("DBACCESS ORowSetBase::isFirst() = %i Clone = %i\n",bIsFirst,m_bClone); |
| return bIsFirst; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool ORowSetBase::isOnLast() |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::isOnLast" ); |
| return isLast(); |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::isLast( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::isLast" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::isLast() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| |
| if ( m_bBeforeFirst || m_bAfterLast ) |
| return sal_False; |
| |
| if ( impl_rowDeleted() ) |
| { |
| if ( !m_pCache->m_bRowCountFinal ) |
| return sal_False; |
| else |
| return ( m_nDeletedPosition == impl_getRowCount() ); |
| } |
| |
| positionCache( MOVE_NONE_REFRESH_ONLY ); |
| sal_Bool bIsLast = m_pCache->isLast(); |
| |
| DBG_TRACE2("DBACCESS ORowSetBase::isLast() = %i Clone = %i\n",bIsLast,m_bClone); |
| return bIsLast; |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSetBase::beforeFirst( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::beforeFirst" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::beforeFirst() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| ::osl::ResettableMutexGuard aGuard( *m_pMutex ); |
| |
| checkPositioningAllowed(); |
| |
| // check if we are inserting a row |
| sal_Bool bWasNew = m_pCache->m_bNew || impl_rowDeleted(); |
| |
| if((bWasNew || !m_bBeforeFirst) && notifyAllListenersCursorBeforeMove(aGuard) ) |
| { |
| ORowSetNotifier aNotifier( this ); |
| // this will call cancelRowModification on the cache if necessary |
| |
| if ( !m_bBeforeFirst ) |
| { |
| ORowSetRow aOldValues = getOldRow(bWasNew); |
| m_pCache->beforeFirst(); |
| doCancelModification( ); |
| |
| // notification order |
| // - column values |
| // - cursorMoved |
| setCurrentRow( sal_True, sal_True, aOldValues, aGuard ); |
| |
| // - IsModified |
| // - Isnew |
| aNotifier.fire(); |
| |
| // - RowCount/IsRowCountFinal |
| fireRowcount(); |
| } |
| |
| // to be done _after_ the notifications! |
| m_aOldRow->clearRow(); |
| } |
| DBG_TRACE2("DBACCESS ORowSetBase::beforeFirst() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSetBase::afterLast( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::afterLast" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::afterLast() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| |
| ::osl::ResettableMutexGuard aGuard( *m_pMutex ); |
| checkPositioningAllowed(); |
| |
| sal_Bool bWasNew = m_pCache->m_bNew || impl_rowDeleted(); |
| |
| if((bWasNew || !m_bAfterLast) && notifyAllListenersCursorBeforeMove(aGuard) ) |
| { |
| // check if we are inserting a row |
| ORowSetNotifier aNotifier( this ); |
| // this will call cancelRowModification on the cache if necessary |
| |
| if(!m_bAfterLast) |
| { |
| ORowSetRow aOldValues = getOldRow(bWasNew); |
| |
| m_pCache->afterLast(); |
| doCancelModification( ); |
| |
| // notification order |
| // - column values |
| // - cursorMoved |
| setCurrentRow( sal_True, sal_True, aOldValues, aGuard ); |
| |
| // - IsModified |
| // - Isnew |
| aNotifier.fire(); |
| |
| // - RowCount/IsRowCountFinal |
| fireRowcount(); |
| } |
| } |
| DBG_TRACE2("DBACCESS ORowSetBase::afterLast() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::move( ::std::mem_fun_t<sal_Bool,ORowSetBase>& _aCheckFunctor, |
| ::std::mem_fun_t<sal_Bool,ORowSetCache>& _aMovementFunctor) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::move" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::move() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| ::osl::ResettableMutexGuard aGuard( *m_pMutex ); |
| checkPositioningAllowed(); |
| |
| sal_Bool bRet( notifyAllListenersCursorBeforeMove( aGuard ) ); |
| if( bRet ) |
| { |
| // check if we are inserting a row |
| sal_Bool bWasNew = m_pCache->m_bNew || rowDeleted(); |
| |
| ORowSetNotifier aNotifier( this ); |
| // this will call cancelRowModification on the cache if necessary |
| |
| ORowSetRow aOldValues = getOldRow(bWasNew); |
| |
| sal_Bool bMoved = ( bWasNew || !_aCheckFunctor(this) ); |
| |
| bRet = _aMovementFunctor(m_pCache); |
| doCancelModification( ); |
| |
| if ( bRet ) |
| { |
| // notification order |
| // - column values |
| // - cursorMoved |
| setCurrentRow( bMoved, sal_True, aOldValues, aGuard ); |
| } |
| else |
| { // first goes wrong so there is no row |
| movementFailed(); |
| } |
| |
| // - IsModified |
| // - IsNew |
| aNotifier.fire(); |
| |
| // - RowCount/IsRowCountFinal |
| fireRowcount(); |
| } |
| DBG_TRACE2("DBACCESS ORowSetBase::move() = %i Clone = %i\n",bRet,m_bClone); |
| return bRet; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::first( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::first" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::first() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| ::std::mem_fun_t<sal_Bool,ORowSetBase> ioF_tmp(&ORowSetBase::isOnFirst); |
| ::std::mem_fun_t<sal_Bool,ORowSetCache> F_tmp(&ORowSetCache::first); |
| return move(ioF_tmp,F_tmp); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::last( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::last" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::last() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| ::std::mem_fun_t<sal_Bool,ORowSetBase> ioL_tmp(&ORowSetBase::isOnLast); |
| ::std::mem_fun_t<sal_Bool,ORowSetCache> L_tmp(&ORowSetCache::last); |
| return move(ioL_tmp,L_tmp); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int32 SAL_CALL ORowSetBase::getRow( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getRow" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::getRow() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| |
| checkCache(); |
| return impl_getRow(); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int32 ORowSetBase::impl_getRow() |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::impl_getRow" ); |
| sal_Int32 nPos = 0; |
| if ( m_bBeforeFirst ) |
| nPos = 0; |
| else if ( m_bAfterLast ) |
| nPos = impl_getRowCount() + 1; |
| else if ( impl_rowDeleted() ) |
| nPos = m_nDeletedPosition; |
| else if ( !m_bClone && m_pCache->m_bNew ) |
| nPos = 0; |
| else |
| { |
| if ( m_pCache->isAfterLast() |
| || m_pCache->isBeforeFirst() |
| || ( m_pCache->compareBookmarks( m_aBookmark, m_pCache->getBookmark() ) != CompareBookmark::EQUAL ) |
| ) |
| { |
| positionCache( MOVE_NONE_REFRESH_ONLY ); |
| } |
| nPos = m_pCache->getRow(); |
| } |
| DBG_TRACE3("DBACCESS ORowSetBase::impl_getRow() = %i Clone = %i ID = %i\n",nPos,m_bClone,osl_getThreadIdentifier(NULL)); |
| return nPos; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::absolute( sal_Int32 row ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::absolute" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::absolute(%i) Clone = %i\n",row,m_bClone); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| ::osl::ResettableMutexGuard aGuard( *m_pMutex ); |
| checkPositioningAllowed(); |
| |
| sal_Bool bRet = ( row > 0 ) |
| && notifyAllListenersCursorBeforeMove( aGuard ); |
| if ( bRet ) |
| { |
| // check if we are inserting a row |
| sal_Bool bWasNew = m_pCache->m_bNew || rowDeleted(); |
| |
| ORowSetNotifier aNotifier( this ); |
| // this will call cancelRowModification on the cache if necessary |
| |
| ORowSetRow aOldValues = getOldRow(bWasNew); |
| |
| bRet = m_pCache->absolute(row); |
| doCancelModification( ); |
| |
| if(bRet) |
| { |
| // notification order |
| // - column values |
| // - cursorMoved |
| setCurrentRow( sal_True, sal_True, aOldValues, aGuard ); |
| } |
| else |
| { // absolute movement goes wrong we stand left or right side of the rows |
| movementFailed(); |
| } |
| |
| // - IsModified |
| // - IsNew |
| aNotifier.fire(); |
| |
| // - RowCount/IsRowCountFinal |
| fireRowcount(); |
| } |
| DBG_TRACE3("DBACCESS ORowSetBase::absolute(%i) = %i Clone = %i\n",row,bRet,m_bClone); |
| return bRet; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::relative( sal_Int32 rows ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::relative" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::relative(%i) Clone = %i\n",rows,m_bClone); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| |
| ::osl::ResettableMutexGuard aGuard( *m_pMutex ); |
| |
| if(!rows) |
| return sal_True; // in this case do nothing |
| |
| checkPositioningAllowed(); |
| |
| sal_Bool bRet = |
| ( ( !m_bAfterLast || rows <= 0 ) |
| && ( !m_bBeforeFirst || rows >= 0 ) |
| && notifyAllListenersCursorBeforeMove( aGuard ) |
| ); |
| |
| if ( bRet ) |
| { |
| // check if we are inserting a row |
| sal_Bool bWasNew = m_pCache->m_bNew || rowDeleted(); |
| |
| ORowSetNotifier aNotifier( this ); |
| // this will call cancelRowModification on the cache if necessary |
| |
| ORowSetRow aOldValues = getOldRow(bWasNew); |
| |
| positionCache( rows > 0 ? MOVE_FORWARD : MOVE_BACKWARD ); |
| bRet = m_pCache->relative(rows); |
| doCancelModification( ); |
| |
| if(bRet) |
| { |
| // notification order |
| // - column values |
| // - cursorMoved |
| setCurrentRow( sal_True, sal_True, aOldValues, aGuard ); |
| } |
| else |
| { |
| movementFailed(); |
| } |
| |
| // - IsModified |
| // - IsNew |
| aNotifier.fire(); |
| |
| // - RowCount/IsRowCountFinal |
| fireRowcount(); |
| } |
| DBG_TRACE3("DBACCESS ORowSetBase::relative(%i) = %i Clone = %i\n",rows,bRet,m_bClone); |
| return bRet; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::previous( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::previous" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::previous() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| ::osl::ResettableMutexGuard aGuard( *m_pMutex ); |
| |
| checkPositioningAllowed(); |
| |
| sal_Bool bRet = !m_bBeforeFirst |
| && notifyAllListenersCursorBeforeMove(aGuard); |
| |
| if ( bRet ) |
| { |
| // check if we are inserting a row |
| sal_Bool bWasNew = m_pCache->m_bNew || rowDeleted(); |
| |
| ORowSetNotifier aNotifier( this ); |
| // this will call cancelRowModification on the cache if necessary |
| |
| ORowSetRow aOldValues = getOldRow(bWasNew); |
| |
| positionCache( MOVE_BACKWARD ); |
| bRet = m_pCache->previous(); |
| doCancelModification( ); |
| |
| // if m_bBeforeFirst is false and bRet is false than we stood on the first row |
| if(!m_bBeforeFirst || bRet) |
| { |
| // notification order |
| // - column values |
| // - cursorMoved |
| setCurrentRow( sal_True, sal_True, aOldValues, aGuard ); |
| } |
| else |
| { |
| DBG_ERROR( "ORowSetBase::previous: inconsistency!" ); |
| // we should never reach this place, as we should not get into this whole branch if m_bBeforeFirst |
| // was |true| from the beginning |
| movementFailed(); |
| } |
| |
| // - IsModified |
| // - IsNew |
| aNotifier.fire(); |
| |
| // - RowCount/IsRowCountFinal |
| fireRowcount(); |
| } |
| DBG_TRACE2("DBACCESS ORowSetBase::previous() = %i Clone = %i\n",bRet,m_bClone); |
| return bRet; |
| } |
| // ----------------------------------------------------------------------------- |
| void ORowSetBase::setCurrentRow( sal_Bool _bMoved, sal_Bool _bDoNotify, const ORowSetRow& _rOldValues, ::osl::ResettableMutexGuard& _rGuard ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::setCurrentRow" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::setCurrentRow() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| m_bBeforeFirst = m_pCache->isBeforeFirst(); |
| m_bAfterLast = m_pCache->isAfterLast(); |
| //m_pCache->resetInsertRow(sal_True); |
| |
| if(!(m_bBeforeFirst || m_bAfterLast)) |
| { |
| m_aBookmark = m_pCache->getBookmark(); |
| OSL_ENSURE(m_aBookmark.hasValue(),"Bookmark has no value!"); |
| m_aCurrentRow = m_pCache->m_aMatrixIter; |
| m_bIsInsertRow = sal_False; |
| OSL_ENSURE(!m_aCurrentRow.isNull(),"CurrentRow is null!"); |
| m_aCurrentRow.setBookmark(m_aBookmark); |
| OSL_ENSURE(!m_aCurrentRow.isNull() && m_aCurrentRow != m_pCache->getEnd(),"Position of matrix iterator isn't valid!"); |
| OSL_ENSURE(m_aCurrentRow->isValid(),"Currentrow isn't valid"); |
| OSL_ENSURE(m_aBookmark.hasValue(),"Bookmark has no value!"); |
| |
| #if OSL_DEBUG_LEVEL > 0 |
| sal_Int32 nOldRow = m_pCache->getRow(); |
| #endif |
| positionCache( MOVE_NONE_REFRESH_ONLY ); |
| #if OSL_DEBUG_LEVEL > 0 |
| sal_Int32 nNewRow = m_pCache->getRow(); |
| #endif |
| OSL_ENSURE(nOldRow == nNewRow,"Old position is not equal to new postion"); |
| m_aCurrentRow = m_pCache->m_aMatrixIter; |
| m_bIsInsertRow = sal_False; |
| OSL_ENSURE(!m_aCurrentRow.isNull(),"CurrentRow is nul after positionCache!"); |
| #if OSL_DEBUG_LEVEL > 0 |
| ORowSetRow rRow = (*m_aCurrentRow); |
| OSL_ENSURE(rRow.isValid() ,"Invalid size of vector!"); |
| #endif |
| // the cache could repositioned so we need to adjust the cache |
| // #104144# OJ |
| if ( _bMoved && m_aCurrentRow.isNull() ) |
| { |
| positionCache( MOVE_NONE_REFRESH_ONLY ); |
| m_aCurrentRow = m_pCache->m_aMatrixIter; |
| m_bIsInsertRow = sal_False; |
| OSL_ENSURE(!m_aCurrentRow.isNull(),"CurrentRow is nul after positionCache!"); |
| } |
| } |
| else |
| { |
| m_aOldRow->clearRow(); |
| m_aCurrentRow = m_pCache->getEnd(); |
| m_aBookmark = Any(); |
| m_aCurrentRow.setBookmark(m_aBookmark); |
| } |
| |
| // notification order |
| // - column values |
| if ( _bDoNotify ) |
| firePropertyChange(_rOldValues); |
| |
| // TODO: can this be done before the notifications? |
| if(!(m_bBeforeFirst || m_bAfterLast) && !m_aCurrentRow.isNull() && m_aCurrentRow->isValid() && m_aCurrentRow != m_pCache->getEnd()) |
| m_aOldRow->setRow(new ORowSetValueVector(m_aCurrentRow->getBody())); |
| |
| if ( _bMoved && _bDoNotify ) |
| // - cursorMoved |
| notifyAllListenersCursorMoved( _rGuard ); |
| |
| DBG_TRACE2("DBACCESS ORowSetBase::setCurrentRow() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| } |
| // ----------------------------------------------------------------------------- |
| void ORowSetBase::checkPositioningAllowed() throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::checkPositioningAllowed" ); |
| if(!m_pCache || m_nResultSetType == ResultSetType::FORWARD_ONLY) |
| throwFunctionSequenceException(*m_pMySelf); |
| } |
| //------------------------------------------------------------------------------ |
| Reference< XInterface > ORowSetBase::getStatement(void) throw( SQLException, RuntimeException ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getStatement" ); |
| return NULL; |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSetBase::refreshRow( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::refreshRow" ); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| if ( impl_rowDeleted() ) |
| throwSQLException( "The current row is deleted", SQL_INVALID_CURSOR_STATE, Reference< XRowSet >( this ) ); |
| |
| if(!(m_bBeforeFirst || m_bAfterLast)) |
| { |
| sal_Bool bWasNew = m_pCache->m_bNew || impl_rowDeleted(); |
| ORowSetRow aOldValues = getOldRow(bWasNew); |
| positionCache( MOVE_NONE_REFRESH_ONLY ); |
| m_pCache->refreshRow(); |
| firePropertyChange(aOldValues); |
| } |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::rowUpdated( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::rowUpdated" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| |
| if ( impl_rowDeleted() ) |
| return sal_False; |
| |
| return m_pCache->rowUpdated(); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::rowInserted( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::rowInserted" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| |
| checkCache(); |
| |
| if ( impl_rowDeleted() ) |
| return sal_False; |
| |
| return m_pCache->rowInserted(); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSetBase::rowDeleted( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::rowDeleted" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| return impl_rowDeleted(); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool ORowSetBase::impl_rowDeleted( ) |
| { |
| return !m_aBookmark.hasValue() && !m_bBeforeFirst && !m_bAfterLast; |
| } |
| // ------------------------------------------------------------------------- |
| // XWarningsSupplier |
| Any SAL_CALL ORowSetBase::getWarnings( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getWarnings" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| |
| if ( m_pCache ) |
| { |
| Reference< XWarningsSupplier > xWarnings( m_pCache->m_xSet.get(), UNO_QUERY ); |
| if ( xWarnings.is() ) |
| return xWarnings->getWarnings(); |
| } |
| |
| return Any(); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSetBase::clearWarnings( ) throw(SQLException, RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::clearWarnings" ); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| |
| if ( m_pCache ) |
| { |
| Reference< XWarningsSupplier > xWarnings( m_pCache->m_xSet.get(), UNO_QUERY ); |
| if ( xWarnings.is() ) |
| xWarnings->clearWarnings(); |
| } |
| } |
| // ------------------------------------------------------------------------- |
| void ORowSetBase::firePropertyChange(const ORowSetRow& _rOldRow) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::firePropertyChange" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::firePropertyChange() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| OSL_ENSURE(m_pColumns,"Columns can not be NULL here!"); |
| #if OSL_DEBUG_LEVEL > 1 |
| sal_Bool bNull; |
| ORowSetMatrix::iterator atest; |
| bNull = m_aCurrentRow.isNull(); |
| atest = m_aCurrentRow; |
| #endif |
| sal_Int32 i=0; |
| try |
| { |
| TDataColumns::iterator aEnd = m_aDataColumns.end(); |
| for(TDataColumns::iterator aIter = m_aDataColumns.begin();aIter != aEnd;++aIter,++i) // #104278# OJ ++i inserted |
| (*aIter)->fireValueChange(_rOldRow.isValid() ? (_rOldRow->get())[i+1] : ::connectivity::ORowSetValue()); |
| } |
| catch(Exception&) |
| { |
| OSL_ENSURE(0,"firePropertyChange: Exception"); |
| } |
| DBG_TRACE2("DBACCESS ORowSetBase::firePropertyChange() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| } |
| // ------------------------------------------------------------------------- |
| void ORowSetBase::firePropertyChange(sal_Int32 _nPos,const ::connectivity::ORowSetValue& _rOldValue) |
| { |
| OSL_ENSURE(_nPos < (sal_Int32)m_aDataColumns.size(),"nPos is invalid!"); |
| m_aDataColumns[_nPos]->fireValueChange(_rOldValue); |
| } |
| // ----------------------------------------------------------------------------- |
| void ORowSetBase::fireRowcount() |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::fireRowcount" ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| sal_Bool ORowSetBase::notifyAllListenersCursorBeforeMove(::osl::ResettableMutexGuard& /*_rGuard*/) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::notifyAllListenersCursorBeforeMove" ); |
| return sal_True; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ORowSetBase::notifyAllListenersCursorMoved(::osl::ResettableMutexGuard& /*_rGuard*/) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::notifyAllListenersCursorMoved" ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ORowSetBase::notifyAllListeners(::osl::ResettableMutexGuard& /*_rGuard*/) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::notifyAllListeners" ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ORowSetBase::fireProperty( sal_Int32 _nProperty, sal_Bool _bNew, sal_Bool _bOld ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::fireProperty" ); |
| Any aNew = bool2any( _bNew ); |
| Any aOld = bool2any( _bOld ); |
| fire( &_nProperty, &aNew, &aOld, 1, sal_False ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ORowSetBase::positionCache( CursorMoveDirection _ePrepareForDirection ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::positionCache" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::positionCache() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| |
| sal_Bool bSuccess = sal_False; |
| if ( m_aBookmark.hasValue() ) |
| { |
| bSuccess = m_pCache->moveToBookmark( m_aBookmark ); |
| } |
| else |
| { |
| if ( m_bBeforeFirst ) |
| { |
| bSuccess = m_pCache->beforeFirst(); |
| } |
| else if ( m_bAfterLast ) |
| { |
| bSuccess = m_pCache->afterLast(); |
| } |
| else |
| { |
| OSL_ENSURE( m_nDeletedPosition >= 1, "ORowSetBase::positionCache: no bookmark, and no valid 'deleted position'!" ); |
| switch ( _ePrepareForDirection ) |
| { |
| case MOVE_FORWARD: |
| if ( m_nDeletedPosition > 1 ) |
| bSuccess = m_pCache->absolute( m_nDeletedPosition - 1 ); |
| else |
| { |
| m_pCache->beforeFirst(); |
| bSuccess = sal_True; |
| } |
| break; |
| |
| case MOVE_BACKWARD: |
| if ( m_pCache->m_bRowCountFinal && ( m_nDeletedPosition == impl_getRowCount() ) ) |
| { |
| m_pCache->afterLast(); |
| bSuccess = sal_True; |
| } |
| else |
| bSuccess = m_pCache->absolute( m_nDeletedPosition ); |
| break; |
| |
| case MOVE_NONE_REFRESH_ONLY: |
| bSuccess = sal_False; // will be asserted below |
| break; |
| } |
| } |
| } |
| OSL_ENSURE( bSuccess, "ORowSetBase::positionCache: failed!" ); |
| |
| DBG_TRACE2("DBACCESS ORowSetBase::positionCache() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| } |
| // ----------------------------------------------------------------------------- |
| void ORowSetBase::checkCache() |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::checkCache" ); |
| ::connectivity::checkDisposed(m_rBHelper.bDisposed); |
| if(!m_pCache) |
| throwFunctionSequenceException(*m_pMySelf); |
| } |
| // ----------------------------------------------------------------------------- |
| void ORowSetBase::movementFailed() |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::movementFailed" ); |
| DBG_TRACE2("DBACCESS ORowSetBase::movementFailed() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| m_aOldRow->clearRow(); |
| m_aCurrentRow = m_pCache->getEnd(); |
| m_bBeforeFirst = m_pCache->isBeforeFirst(); |
| m_bAfterLast = m_pCache->isAfterLast(); |
| m_aBookmark = Any(); |
| m_aCurrentRow.setBookmark(m_aBookmark); |
| OSL_ENSURE(m_bBeforeFirst || m_bAfterLast,"BeforeFirst or AfterLast is wrong!"); |
| DBG_TRACE2("DBACCESS ORowSetBase::movementFailed() Clone = %i ID = %i\n",m_bClone,osl_getThreadIdentifier(NULL)); |
| } |
| // ----------------------------------------------------------------------------- |
| ORowSetRow ORowSetBase::getOldRow(sal_Bool _bWasNew) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getOldRow" ); |
| OSL_ENSURE(m_aOldRow.isValid(),"RowSetRowHElper isn't valid!"); |
| ORowSetRow aOldValues; |
| if ( !_bWasNew && m_aOldRow->getRow().isValid() ) |
| aOldValues = new ORowSetValueVector( m_aOldRow->getRow().getBody()); // remember the old values |
| return aOldValues; |
| } |
| // ----------------------------------------------------------------------------- |
| void ORowSetBase::getPropertyDefaultByHandle( sal_Int32 /*_nHandle*/, Any& _rDefault ) const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::getPropertyDefaultByHandle" ); |
| _rDefault.clear(); |
| } |
| // ----------------------------------------------------------------------------- |
| void ORowSetBase::onDeleteRow( const Any& _rBookmark ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::onDeleteRow" ); |
| if ( rowDeleted() ) |
| // not interested in |
| return; |
| |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| //OSL_ENSURE( m_aBookmark.hasValue(), "ORowSetBase::onDeleteRow: Bookmark isn't valid!" ); |
| if ( compareBookmarks( _rBookmark, m_aBookmark ) == 0 ) |
| { |
| positionCache( MOVE_NONE_REFRESH_ONLY ); |
| m_nDeletedPosition = m_pCache->getRow(); |
| } |
| } |
| // ----------------------------------------------------------------------------- |
| void ORowSetBase::onDeletedRow( const Any& _rBookmark, sal_Int32 _nPos ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::onDeletedRow" ); |
| if ( rowDeleted() ) |
| { |
| // if we're a clone, and on a deleted row, and the main RowSet deleted another |
| // row (only the main RowSet can, clones can't), which is *before* our |
| // deleted position, then we have to adjust this position |
| if ( m_bClone && ( _nPos < m_nDeletedPosition ) ) |
| --m_nDeletedPosition; |
| return; |
| } |
| |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| if ( compareBookmarks( _rBookmark, m_aBookmark ) == 0 ) |
| { |
| m_aOldRow->clearRow(); |
| m_aCurrentRow = m_pCache->getEnd(); |
| m_aBookmark = Any(); |
| m_aCurrentRow.setBookmark( m_aBookmark ); |
| } |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Int32 ORowSetBase::impl_getRowCount() const |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetBase::impl_getRowCount" ); |
| sal_Int32 nRowCount( m_pCache->m_nRowCount ); |
| if ( const_cast< ORowSetBase* >( this )->rowDeleted() && !m_pCache->m_bNew ) |
| ++nRowCount; |
| return nRowCount; |
| } |
| // ============================================================================= |
| struct ORowSetNotifierImpl |
| { |
| ::std::vector<sal_Int32> aChangedColumns; |
| ::std::vector<Any> aChangedBookmarks; |
| ORowSetValueVector::Vector aRow; |
| |
| }; |
| DBG_NAME(ORowSetNotifier) |
| // ----------------------------------------------------------------------------- |
| ORowSetNotifier::ORowSetNotifier( ORowSetBase* _pRowSet ) |
| :m_pRowSet( _pRowSet ) |
| ,m_bWasNew( sal_False ) |
| ,m_bWasModified( sal_False ) |
| #ifdef DBG_UTIL |
| ,m_bNotifyCalled( sal_False ) |
| #endif |
| { |
| DBG_CTOR(ORowSetNotifier,NULL); |
| |
| OSL_ENSURE( m_pRowSet, "ORowSetNotifier::ORowSetNotifier: invalid row set. This wil crash." ); |
| |
| // remember the "inserted" and "modified" state for later firing |
| m_bWasNew = m_pRowSet->isNew( ORowSetBase::GrantNotifierAccess() ); |
| m_bWasModified = m_pRowSet->isModified( ORowSetBase::GrantNotifierAccess() ); |
| |
| // if the row set is on the insert row, then we need to cancel this |
| if ( m_pRowSet->isModification( ORowSetBase::GrantNotifierAccess() ) ) |
| m_pRowSet->doCancelModification( ORowSetBase::GrantNotifierAccess() ); |
| } |
| // ----------------------------------------------------------------------------- |
| ORowSetNotifier::ORowSetNotifier( ORowSetBase* _pRowSet,const ORowSetValueVector::Vector& i_aRow ) |
| :m_pImpl(new ORowSetNotifierImpl) |
| ,m_pRowSet( _pRowSet ) |
| ,m_bWasNew( sal_False ) |
| ,m_bWasModified( sal_False ) |
| #ifdef DBG_UTIL |
| ,m_bNotifyCalled( sal_False ) |
| #endif |
| { |
| DBG_CTOR(ORowSetNotifier,NULL); |
| |
| OSL_ENSURE( m_pRowSet, "ORowSetNotifier::ORowSetNotifier: invalid row set. This wil crash." ); |
| m_pImpl->aRow = i_aRow; // yes, create a copy to store the old values |
| } |
| // ----------------------------------------------------------------------------- |
| ORowSetNotifier::~ORowSetNotifier( ) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "ORowSetNotifier::~ORowSetNotifier" ); |
| DBG_DTOR(ORowSetNotifier,NULL); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ORowSetNotifier::fire() |
| { |
| // we're not interested in firing changes FALSE->TRUE, only TRUE->FALSE. |
| // (the former would be quite pathological, e.g. after a failed movement) |
| |
| if ( m_bWasModified |
| && ( m_bWasModified != m_pRowSet->isModified( ORowSetBase::GrantNotifierAccess() ) ) |
| ) |
| m_pRowSet->fireProperty( PROPERTY_ID_ISMODIFIED, sal_False, sal_True, ORowSetBase::GrantNotifierAccess() ); |
| |
| if ( m_bWasNew |
| && ( m_bWasNew != m_pRowSet->isNew( ORowSetBase::GrantNotifierAccess() ) ) |
| ) |
| m_pRowSet->fireProperty( PROPERTY_ID_ISNEW, sal_False, sal_True, ORowSetBase::GrantNotifierAccess() ); |
| |
| #ifdef DBG_UTIL |
| m_bNotifyCalled = sal_True; |
| #endif |
| } |
| // ----------------------------------------------------------------------------- |
| ::std::vector<sal_Int32>& ORowSetNotifier::getChangedColumns() const |
| { |
| OSL_ENSURE(m_pImpl.get(),"Illegal CTor call, use the other one!"); |
| return m_pImpl->aChangedColumns; |
| } |
| // ----------------------------------------------------------------------------- |
| ::std::vector<Any>& ORowSetNotifier::getChangedBookmarks() const |
| { |
| OSL_ENSURE(m_pImpl.get(),"Illegal CTor call, use the other one!"); |
| return m_pImpl->aChangedBookmarks; |
| } |
| // ----------------------------------------------------------------------------- |
| void ORowSetNotifier::firePropertyChange() |
| { |
| OSL_ENSURE(m_pImpl.get(),"Illegal CTor call, use the other one!"); |
| if( m_pImpl.get() ) |
| { |
| ::std::vector<sal_Int32>::iterator aIter = m_pImpl->aChangedColumns.begin(); |
| for(;aIter != m_pImpl->aChangedColumns.end();++aIter) |
| { |
| m_pRowSet->firePropertyChange((*aIter)-1 ,m_pImpl->aRow[(*aIter)-1], ORowSetBase::GrantNotifierAccess()); |
| } |
| if ( !m_pImpl->aChangedColumns.empty() ) |
| m_pRowSet->fireProperty(PROPERTY_ID_ISMODIFIED,sal_True,sal_False, ORowSetBase::GrantNotifierAccess()); |
| } |
| } |
| } // namespace dbaccess |
