RowSet.cxx

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the LibreOffice project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. * * This file incorporates work covered by the following license notice: * * 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 . */ #include <sal/config.h> #include <sal/log.hxx> #include <map> #include <utility> #include "RowSet.hxx" #include <stringconstants.hxx> #include <sdbcoretools.hxx> #include <SingleSelectQueryComposer.hxx> #include "CRowSetColumn.hxx" #include "CRowSetDataColumn.hxx" #include "RowSetCache.hxx" #include <strings.hrc> #include <strings.hxx> #include <core_resource.hxx> #include <tablecontainer.hxx> #include <com/sun/star/beans/PropertyAttribute.hpp> #include <com/sun/star/lang/DisposedException.hpp> #include <com/sun/star/lang/XMultiServiceFactory.hpp> #include <com/sun/star/sdb/CommandType.hpp> #include <com/sun/star/sdb/DatabaseContext.hpp> #include <com/sun/star/sdb/ErrorCondition.hpp> #include <com/sun/star/sdb/RowChangeAction.hpp> #include <com/sun/star/sdb/RowSetVetoException.hpp> #include <com/sun/star/sdb/XCompletedConnection.hpp> #include <com/sun/star/sdb/XParametersSupplier.hpp> #include <com/sun/star/sdb/XQueriesSupplier.hpp> #include <com/sun/star/sdbc/FetchDirection.hpp> #include <com/sun/star/sdbc/ResultSetConcurrency.hpp> #include <com/sun/star/sdbc/ResultSetType.hpp> #include <com/sun/star/sdbc/XDataSource.hpp> #include <com/sun/star/sdbcx/Privilege.hpp> #include <com/sun/star/util/XNumberFormatsSupplier.hpp> #include <comphelper/extract.hxx> #include <comphelper/seqstream.hxx> #include <comphelper/sequence.hxx> #include <comphelper/servicehelper.hxx> #include <comphelper/types.hxx> #include <comphelper/uno3.hxx> #include <connectivity/BlobHelper.hxx> #include <connectivity/dbconversion.hxx> #include <connectivity/dbexception.hxx> #include <connectivity/dbtools.hxx> #include <cppuhelper/exc_hlp.hxx> #include <cppuhelper/interfacecontainer.h> #include <cppuhelper/supportsservice.hxx> #include <cppuhelper/typeprovider.hxx> #include <i18nlangtag/languagetag.hxx> #include <o3tl/safeint.hxx> #include <unotools/syslocale.hxx> #include <comphelper/diagnose_ex.hxx> using namespace dbaccess; using namespace connectivity; using namespace comphelper; using namespace dbtools; using namespace ::com::sun::star; 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::task; using namespace ::com::sun::star::util; using namespace ::cppu; using namespace ::osl; extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* com_sun_star_comp_dba_ORowSet_get_implementation(css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const &) { return cppu::acquire(new ORowSet(context)); } namespace dbaccess { ORowSet::ORowSet( const Reference< css::uno::XComponentContext >& _rxContext ) :ORowSet_BASE1(m_aMutex) ,ORowSetBase( _rxContext, ORowSet_BASE1::rBHelper, &m_aMutex ) ,m_aPrematureParamValues(new ORowSetValueVector) ,m_aParameterValueForCache(new ORowSetValueVector) ,m_aRowsetListeners(*m_pMutex) ,m_aApproveListeners(*m_pMutex) ,m_aRowsChangeListener(*m_pMutex) ,m_sErrorString(ResourceManager::loadString(RID_STR_COMMAND_LEADING_TO_ERROR)) ,m_nFetchDirection(FetchDirection::FORWARD) ,m_nFetchSize(50) ,m_nMaxFieldSize(0) ,m_nMaxRows(0) ,m_nQueryTimeOut(0) ,m_nCommandType(CommandType::COMMAND) ,m_nTransactionIsolation(0) ,m_nPrivileges(0) ,m_nLastKnownRowCount(0) ,m_nInAppend(0) ,m_bInsertingRow(false) ,m_bLastKnownRowCountFinal(false) ,m_bUseEscapeProcessing(true) ,m_bApplyFilter(false) ,m_bCommandFacetsDirty( true ) ,m_bParametersDirty( true ) ,m_bModified(false) ,m_bRebuildConnOnExecute(false) ,m_bIsBookmarkable(true) ,m_bNew(false) ,m_bCanUpdateInsertedRows(true) ,m_bOwnConnection(false) ,m_bPropChangeNotifyEnabled(true) { m_nResultSetType = ResultSetType::SCROLL_SENSITIVE; m_nResultSetConcurrency = ResultSetConcurrency::UPDATABLE; m_pMySelf = this; m_aActiveConnection <<= m_xActiveConnection; sal_Int32 const nRBT = PropertyAttribute::READONLY | PropertyAttribute::BOUND | PropertyAttribute::TRANSIENT; sal_Int32 const nRT = PropertyAttribute::READONLY | PropertyAttribute::TRANSIENT; sal_Int32 const nBT = PropertyAttribute::BOUND | PropertyAttribute::TRANSIENT; m_aPrematureParamValues->resize( 0 ); // sdb.RowSet Properties registerMayBeVoidProperty(PROPERTY_ACTIVE_CONNECTION,PROPERTY_ID_ACTIVE_CONNECTION, PropertyAttribute::MAYBEVOID|PropertyAttribute::TRANSIENT|PropertyAttribute::BOUND, &m_aActiveConnection, cppu::UnoType<XConnection>::get()); registerProperty(PROPERTY_DATASOURCENAME, PROPERTY_ID_DATASOURCENAME, PropertyAttribute::BOUND, &m_aDataSourceName, ::cppu::UnoType<OUString>::get()); registerProperty(PROPERTY_COMMAND, PROPERTY_ID_COMMAND, PropertyAttribute::BOUND, &m_aCommand, ::cppu::UnoType<OUString>::get()); registerProperty(PROPERTY_COMMAND_TYPE, PROPERTY_ID_COMMAND_TYPE, PropertyAttribute::BOUND, &m_nCommandType, ::cppu::UnoType<sal_Int32>::get()); registerProperty(PROPERTY_ACTIVECOMMAND, PROPERTY_ID_ACTIVECOMMAND, nRBT, &m_aActiveCommand, ::cppu::UnoType<OUString>::get()); registerProperty(PROPERTY_IGNORERESULT, PROPERTY_ID_IGNORERESULT, PropertyAttribute::BOUND, &m_bIgnoreResult, cppu::UnoType<bool>::get()); registerProperty(PROPERTY_FILTER, PROPERTY_ID_FILTER, PropertyAttribute::BOUND, &m_aFilter, ::cppu::UnoType<OUString>::get()); registerProperty(PROPERTY_HAVING_CLAUSE, PROPERTY_ID_HAVING_CLAUSE, PropertyAttribute::BOUND, &m_aHavingClause, ::cppu::UnoType<OUString>::get()); registerProperty(PROPERTY_GROUP_BY, PROPERTY_ID_GROUP_BY, PropertyAttribute::BOUND, &m_aGroupBy, ::cppu::UnoType<OUString>::get()); registerProperty(PROPERTY_APPLYFILTER, PROPERTY_ID_APPLYFILTER, PropertyAttribute::BOUND, &m_bApplyFilter, cppu::UnoType<bool>::get()); registerProperty(PROPERTY_ORDER, PROPERTY_ID_ORDER, PropertyAttribute::BOUND, &m_aOrder, ::cppu::UnoType<OUString>::get()); registerProperty(PROPERTY_PRIVILEGES, PROPERTY_ID_PRIVILEGES, nRT, &m_nPrivileges, ::cppu::UnoType<sal_Int32>::get()); registerProperty(PROPERTY_ISMODIFIED, PROPERTY_ID_ISMODIFIED, nBT, &m_bModified, cppu::UnoType<bool>::get()); registerProperty(PROPERTY_ISNEW, PROPERTY_ID_ISNEW, nRBT, &m_bNew, cppu::UnoType<bool>::get()); registerProperty(PROPERTY_SINGLESELECTQUERYCOMPOSER,PROPERTY_ID_SINGLESELECTQUERYCOMPOSER, nRT, &m_xComposer, cppu::UnoType<XSingleSelectQueryComposer>::get()); // sdbcx.ResultSet Properties registerProperty(PROPERTY_ISBOOKMARKABLE, PROPERTY_ID_ISBOOKMARKABLE, nRT, &m_bIsBookmarkable, cppu::UnoType<bool>::get()); registerProperty(PROPERTY_CANUPDATEINSERTEDROWS,PROPERTY_ID_CANUPDATEINSERTEDROWS, nRT, &m_bCanUpdateInsertedRows, cppu::UnoType<bool>::get()); // sdbc.ResultSet Properties registerProperty(PROPERTY_RESULTSETCONCURRENCY, PROPERTY_ID_RESULTSETCONCURRENCY, PropertyAttribute::TRANSIENT, &m_nResultSetConcurrency,::cppu::UnoType<sal_Int32>::get()); registerProperty(PROPERTY_RESULTSETTYPE, PROPERTY_ID_RESULTSETTYPE, PropertyAttribute::TRANSIENT, &m_nResultSetType, ::cppu::UnoType<sal_Int32>::get()); registerProperty(PROPERTY_FETCHDIRECTION, PROPERTY_ID_FETCHDIRECTION, PropertyAttribute::TRANSIENT, &m_nFetchDirection, ::cppu::UnoType<sal_Int32>::get()); registerProperty(PROPERTY_FETCHSIZE, PROPERTY_ID_FETCHSIZE, PropertyAttribute::TRANSIENT, &m_nFetchSize, ::cppu::UnoType<sal_Int32>::get()); // sdbc.RowSet Properties registerProperty(PROPERTY_URL, PROPERTY_ID_URL, 0, &m_aURL, ::cppu::UnoType<OUString>::get()); registerProperty(PROPERTY_TRANSACTIONISOLATION, PROPERTY_ID_TRANSACTIONISOLATION, PropertyAttribute::TRANSIENT, &m_nTransactionIsolation,::cppu::UnoType<sal_Int32>::get()); registerMayBeVoidProperty(PROPERTY_TYPEMAP, PROPERTY_ID_TYPEMAP, PropertyAttribute::MAYBEVOID|PropertyAttribute::TRANSIENT, &m_aTypeMap, cppu::UnoType<XNameAccess>::get()); registerProperty(PROPERTY_ESCAPE_PROCESSING,PROPERTY_ID_ESCAPE_PROCESSING, PropertyAttribute::BOUND, &m_bUseEscapeProcessing,cppu::UnoType<bool>::get() ); registerProperty(PROPERTY_QUERYTIMEOUT, PROPERTY_ID_QUERYTIMEOUT, PropertyAttribute::TRANSIENT, &m_nQueryTimeOut, ::cppu::UnoType<sal_Int32>::get()); registerProperty(PROPERTY_MAXFIELDSIZE, PROPERTY_ID_MAXFIELDSIZE, PropertyAttribute::TRANSIENT, &m_nMaxFieldSize, ::cppu::UnoType<sal_Int32>::get()); registerProperty(PROPERTY_MAXROWS, PROPERTY_ID_MAXROWS, 0, &m_nMaxRows, ::cppu::UnoType<sal_Int32>::get() ); registerProperty(PROPERTY_USER, PROPERTY_ID_USER, PropertyAttribute::TRANSIENT, &m_aUser, ::cppu::UnoType<OUString>::get()); registerProperty(PROPERTY_PASSWORD, PROPERTY_ID_PASSWORD, PropertyAttribute::TRANSIENT, &m_aPassword, ::cppu::UnoType<OUString>::get()); registerProperty(PROPERTY_UPDATE_CATALOGNAME, PROPERTY_ID_UPDATE_CATALOGNAME, PropertyAttribute::BOUND, &m_aUpdateCatalogName, ::cppu::UnoType<OUString>::get()); registerProperty(PROPERTY_UPDATE_SCHEMANAME, PROPERTY_ID_UPDATE_SCHEMANAME, PropertyAttribute::BOUND, &m_aUpdateSchemaName, ::cppu::UnoType<OUString>::get()); registerProperty(PROPERTY_UPDATE_TABLENAME, PROPERTY_ID_UPDATE_TABLENAME, PropertyAttribute::BOUND, &m_aUpdateTableName, ::cppu::UnoType<OUString>::get()); // ??? registerProperty(PROPERTY_CHANGE_NOTIFICATION_ENABLED, PROPERTY_ID_PROPCHANGE_NOTIFY, PropertyAttribute::BOUND, &m_bPropChangeNotifyEnabled, cppu::UnoType<bool>::get()); } ORowSet::~ORowSet() { if ( !m_rBHelper.bDisposed && !m_rBHelper.bInDispose ) { SAL_WARN("dbaccess", "Please check who doesn't dispose this component!"); osl_atomic_increment( &m_refCount ); dispose(); } } void ORowSet::getPropertyDefaultByHandle( sal_Int32 _nHandle, Any& _rDefault ) const { switch( _nHandle ) { case PROPERTY_ID_COMMAND_TYPE: _rDefault <<= CommandType::COMMAND; break; case PROPERTY_ID_IGNORERESULT: _rDefault <<= false; break; case PROPERTY_ID_APPLYFILTER: _rDefault <<= false; break; case PROPERTY_ID_ISMODIFIED: _rDefault <<= false; break; case PROPERTY_ID_ISBOOKMARKABLE: _rDefault <<= true; break; case PROPERTY_ID_CANUPDATEINSERTEDROWS: _rDefault <<= true; break; case PROPERTY_ID_RESULTSETTYPE: _rDefault <<= ResultSetType::SCROLL_INSENSITIVE; break; case PROPERTY_ID_RESULTSETCONCURRENCY: _rDefault <<= ResultSetConcurrency::UPDATABLE; break; case PROPERTY_ID_FETCHDIRECTION: _rDefault <<= FetchDirection::FORWARD; break; case PROPERTY_ID_FETCHSIZE: _rDefault <<= static_cast<sal_Int32>(1); break; case PROPERTY_ID_ESCAPE_PROCESSING: _rDefault <<= true; break; case PROPERTY_ID_MAXROWS: _rDefault <<= sal_Int32( 0 ); break; case PROPERTY_ID_FILTER: case PROPERTY_ID_HAVING_CLAUSE: case PROPERTY_ID_GROUP_BY: case PROPERTY_ID_ORDER: case PROPERTY_ID_UPDATE_CATALOGNAME: case PROPERTY_ID_UPDATE_SCHEMANAME: case PROPERTY_ID_UPDATE_TABLENAME: _rDefault <<= OUString(); break; } } void SAL_CALL ORowSet::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue) { switch(nHandle) { case PROPERTY_ID_ISMODIFIED: m_bModified = cppu::any2bool(rValue); break; case PROPERTY_ID_FETCHDIRECTION: if( m_nResultSetType == ResultSetType::FORWARD_ONLY) throw Exception(u"resultsettype is FORWARD_ONLY"_ustr, nullptr); [[fallthrough]]; default: OPropertyStateContainer::setFastPropertyValue_NoBroadcast(nHandle,rValue); } if ( ( nHandle == PROPERTY_ID_ACTIVE_CONNECTION ) || ( nHandle == PROPERTY_ID_DATASOURCENAME ) || ( nHandle == PROPERTY_ID_COMMAND ) || ( nHandle == PROPERTY_ID_COMMAND_TYPE ) || ( nHandle == PROPERTY_ID_IGNORERESULT ) || ( nHandle == PROPERTY_ID_FILTER ) || ( nHandle == PROPERTY_ID_HAVING_CLAUSE ) || ( nHandle == PROPERTY_ID_GROUP_BY ) || ( nHandle == PROPERTY_ID_APPLYFILTER ) || ( nHandle == PROPERTY_ID_ORDER ) || ( nHandle == PROPERTY_ID_URL ) || ( nHandle == PROPERTY_ID_USER ) ) { m_bCommandFacetsDirty = true; } switch(nHandle) { case PROPERTY_ID_ACTIVE_CONNECTION: // the new connection { assert(m_aActiveConnection == rValue); Reference< XConnection > xNewConnection(m_aActiveConnection,UNO_QUERY); setActiveConnection(xNewConnection, false); } m_bOwnConnection = false; m_bRebuildConnOnExecute = false; break; case PROPERTY_ID_DATASOURCENAME: if(!m_xStatement.is()) { Reference< XConnection > xNewConn; Any aNewConn; aNewConn <<= xNewConn; setFastPropertyValue(PROPERTY_ID_ACTIVE_CONNECTION, aNewConn); } else m_bRebuildConnOnExecute = true; break; case PROPERTY_ID_FETCHSIZE: if(m_pCache) { m_pCache->setFetchSize(m_nFetchSize); fireRowcount(); } break; case PROPERTY_ID_URL: // is the connection-to-be-built determined by the url (which is the case if m_aDataSourceName is empty) ? if (m_aDataSourceName.isEmpty()) { // are we active at the moment ? if (m_xStatement.is()) // yes -> the next execute needs to rebuild our connection because of this new property m_bRebuildConnOnExecute = true; else { // no -> drop our active connection (if we have one) as it doesn't correspond to this new property value anymore Reference< XConnection > xNewConn; Any aNewConn; aNewConn <<= xNewConn; setFastPropertyValue(PROPERTY_ID_ACTIVE_CONNECTION, aNewConn); } } m_bOwnConnection = true; break; case PROPERTY_ID_TYPEMAP: m_xTypeMap.set(m_aTypeMap, css::uno::UNO_QUERY); break; case PROPERTY_ID_PROPCHANGE_NOTIFY: m_bPropChangeNotifyEnabled = ::cppu::any2bool(rValue); break; default: break; } } void SAL_CALL ORowSet::getFastPropertyValue(Any& rValue,sal_Int32 nHandle) const { if(m_pCache) { switch(nHandle) { case PROPERTY_ID_ISMODIFIED: rValue <<= m_bModified; break; case PROPERTY_ID_ISNEW: rValue <<= m_bNew; break; case PROPERTY_ID_PRIVILEGES: rValue <<= m_pCache->m_nPrivileges; break; case PROPERTY_ID_ACTIVE_CONNECTION: rValue <<= m_xActiveConnection; break; case PROPERTY_ID_TYPEMAP: rValue <<= m_xTypeMap; break; default: ORowSetBase::getFastPropertyValue(rValue,nHandle); } } else { switch(nHandle) { case PROPERTY_ID_ACTIVE_CONNECTION: rValue <<= m_xActiveConnection; break; case PROPERTY_ID_TYPEMAP: rValue <<= m_xTypeMap; break; case PROPERTY_ID_PROPCHANGE_NOTIFY: rValue <<= m_bPropChangeNotifyEnabled; break; default: ORowSetBase::getFastPropertyValue(rValue,nHandle); } } } // css::XTypeProvider Sequence< Type > SAL_CALL ORowSet::getTypes() { OTypeCollection aTypes(cppu::UnoType<XPropertySet>::get(), cppu::UnoType<XFastPropertySet>::get(), cppu::UnoType<XMultiPropertySet>::get(), ::comphelper::concatSequences(ORowSet_BASE1::getTypes(),ORowSetBase::getTypes())); return aTypes.getTypes(); } Sequence< sal_Int8 > SAL_CALL ORowSet::getImplementationId() { return css::uno::Sequence<sal_Int8>(); } // css::XInterface Any SAL_CALL ORowSet::queryInterface( const Type & rType ) { return ORowSet_BASE1::queryInterface( rType); } void SAL_CALL ORowSet::acquire() noexcept { ORowSet_BASE1::acquire(); } void SAL_CALL ORowSet::release() noexcept { ORowSet_BASE1::release(); } // css::XAggregation Any SAL_CALL ORowSet::queryAggregation( const Type& rType ) { Any aRet(ORowSetBase::queryInterface(rType)); if (!aRet.hasValue()) aRet = ORowSet_BASE1::queryAggregation(rType); return aRet; } // css::XServiceInfo OUString SAL_CALL ORowSet::getImplementationName() { return u"com.sun.star.comp.dba.ORowSet"_ustr; } sal_Bool SAL_CALL ORowSet::supportsService( const OUString& _rServiceName ) { return cppu::supportsService(this, _rServiceName); } Sequence< OUString > SAL_CALL ORowSet::getSupportedServiceNames() { return { SERVICE_SDBC_RESULTSET, SERVICE_SDBC_ROWSET, SERVICE_SDBCX_RESULTSET, SERVICE_SDB_RESULTSET, SERVICE_SDB_ROWSET }; } // OComponentHelper void SAL_CALL ORowSet::disposing() { OPropertyStateContainer::disposing(); MutexGuard aGuard(m_aMutex); EventObject aDisposeEvent; aDisposeEvent.Source = static_cast< XComponent* >(this); m_aRowsetListeners.disposeAndClear( aDisposeEvent ); m_aApproveListeners.disposeAndClear( aDisposeEvent ); m_aRowsChangeListener.disposeAndClear( aDisposeEvent ); freeResources( true ); // remove myself as dispose listener Reference< XComponent > xComponent(m_xActiveConnection, UNO_QUERY); if (xComponent.is()) xComponent->removeEventListener(query_aggregation<XEventListener>(this)); m_aActiveConnection = Any(); // the any contains a reference too if(m_bOwnConnection) ::comphelper::disposeComponent(m_xActiveConnection); m_xActiveConnection = nullptr; ORowSetBase::disposing(); } void ORowSet::freeResources( bool _bComplete ) { MutexGuard aGuard(m_aMutex); // free all clones for (auto const& clone : m_aClones) { Reference< XComponent > xComp(clone.get(), UNO_QUERY); if (xComp.is()) xComp->dispose(); } m_aClones.clear(); doCancelModification(); m_aBookmark = Any(); m_bBeforeFirst = true; m_bAfterLast = false; m_bNew = false; m_bModified = false; m_bIsInsertRow = false; m_bLastKnownRowCountFinal = false; m_nLastKnownRowCount = 0; if ( !_bComplete ) return; // the columns must be disposed before the querycomposer is disposed because // their owner can be the composer TDataColumns().swap(m_aDataColumns);// clear and resize capacity std::vector<bool>().swap(m_aReadOnlyDataColumns); m_xColumns = nullptr; if ( m_pColumns ) m_pColumns->disposing(); // dispose the composer to avoid that everybody knows that the querycomposer is eol try { ::comphelper::disposeComponent( m_xComposer ); } catch(Exception&) { DBG_UNHANDLED_EXCEPTION("dbaccess"); m_xComposer = nullptr; } // let our warnings container forget the reference to the (possibly disposed) old result set m_aWarnings.setExternalWarnings( nullptr ); m_pCache.reset(); impl_resetTables_nothrow(); m_xStatement = nullptr; m_xTypeMap = nullptr; if ( m_aOldRow.is() ) m_aOldRow->clearRow(); impl_disposeParametersContainer_nothrow(); m_bCommandFacetsDirty = true; } void ORowSet::setActiveConnection( Reference< XConnection > const & _rxNewConn, bool _bFireEvent ) { if (_rxNewConn.get() == m_xActiveConnection.get()) // nothing to do return; // remove the event listener for the old connection Reference< XComponent > xComponent(m_xActiveConnection, UNO_QUERY); if (xComponent.is()) xComponent->removeEventListener(query_aggregation<XEventListener>(this)); // if we owned the connection, remember it for later disposing if(m_bOwnConnection) m_xOldConnection = m_xActiveConnection; // for firing the PropertyChangeEvent sal_Int32 nHandle = PROPERTY_ID_ACTIVE_CONNECTION; Any aOldConnection; aOldConnection <<= m_xActiveConnection; Any aNewConnection; aNewConnection <<= _rxNewConn; // set the new connection m_xActiveConnection = _rxNewConn; if (m_xActiveConnection.is()) m_aActiveConnection <<= m_xActiveConnection; else m_aActiveConnection.clear(); // fire the event if (_bFireEvent) fire(&nHandle, &aNewConnection, &aOldConnection, 1, false); // register as event listener for the new connection xComponent.set(m_xActiveConnection,UNO_QUERY); if (xComponent.is()) xComponent->addEventListener(query_aggregation<XEventListener>(this)); } // css::XEventListener void SAL_CALL ORowSet::disposing( const css::lang::EventObject& Source ) { // close rowset because the connection is going to be deleted (someone told me :-) Reference<XConnection> xCon(Source.Source,UNO_QUERY); if(m_xActiveConnection == xCon) { close(); { MutexGuard aGuard( m_aMutex ); Reference< XConnection > xXConnection; setActiveConnection( xXConnection ); } } } // XCloseable void SAL_CALL ORowSet::close( ) { { MutexGuard aGuard( m_aMutex ); ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); } // additional things to set freeResources( true ); } // comphelper::OPropertyArrayUsageHelper ::cppu::IPropertyArrayHelper* ORowSet::createArrayHelper( ) const { Sequence< Property > aProps; describeProperties(aProps); return new ::cppu::OPropertyArrayHelper(aProps); } // cppu::OPropertySetHelper ::cppu::IPropertyArrayHelper& SAL_CALL ORowSet::getInfoHelper() { return *::comphelper::OPropertyArrayUsageHelper<ORowSet>::getArrayHelper(); } void ORowSet::updateValue(sal_Int32 columnIndex,const ORowSetValue& x) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::MutexGuard aGuard( *m_pMutex ); checkUpdateConditions(columnIndex); checkUpdateIterator(); ORowSetValueVector::Vector& rRow = **m_aCurrentRow; ORowSetNotifier aNotify(this, std::vector(rRow)); m_pCache->updateValue(columnIndex,x,rRow,aNotify.getChangedColumns()); m_bModified = m_bModified || !aNotify.getChangedColumns().empty(); aNotify.firePropertyChange(); } // XRowUpdate void SAL_CALL ORowSet::updateNull( sal_Int32 columnIndex ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::MutexGuard aGuard( *m_pMutex ); checkUpdateConditions(columnIndex); checkUpdateIterator(); ORowSetValueVector::Vector& rRow = **m_aCurrentRow; ORowSetNotifier aNotify(this, std::vector(rRow)); m_pCache->updateNull(columnIndex,rRow,aNotify.getChangedColumns()); m_bModified = m_bModified || !aNotify.getChangedColumns().empty(); aNotify.firePropertyChange(); } void SAL_CALL ORowSet::updateBoolean( sal_Int32 columnIndex, sal_Bool x ) { updateValue(columnIndex, static_cast<bool>(x)); } void SAL_CALL ORowSet::updateByte( sal_Int32 columnIndex, sal_Int8 x ) { updateValue(columnIndex,x); } void SAL_CALL ORowSet::updateShort( sal_Int32 columnIndex, sal_Int16 x ) { updateValue(columnIndex,x); } void SAL_CALL ORowSet::updateInt( sal_Int32 columnIndex, sal_Int32 x ) { updateValue(columnIndex,x); } void SAL_CALL ORowSet::updateLong( sal_Int32 columnIndex, sal_Int64 x ) { updateValue(columnIndex,x); } void SAL_CALL ORowSet::updateFloat( sal_Int32 columnIndex, float x ) { updateValue(columnIndex,x); } void SAL_CALL ORowSet::updateDouble( sal_Int32 columnIndex, double x ) { updateValue(columnIndex,x); } void SAL_CALL ORowSet::updateString( sal_Int32 columnIndex, const OUString& x ) { updateValue(columnIndex,x); } void SAL_CALL ORowSet::updateBytes( sal_Int32 columnIndex, const Sequence< sal_Int8 >& x ) { updateValue(columnIndex,x); } void SAL_CALL ORowSet::updateDate( sal_Int32 columnIndex, const css::util::Date& x ) { updateValue(columnIndex,x); } void SAL_CALL ORowSet::updateTime( sal_Int32 columnIndex, const css::util::Time& x ) { updateValue(columnIndex,x); } void SAL_CALL ORowSet::updateTimestamp( sal_Int32 columnIndex, const css::util::DateTime& x ) { updateValue(columnIndex,x); } void SAL_CALL ORowSet::updateBinaryStream( sal_Int32 columnIndex, const Reference< css::io::XInputStream >& x, sal_Int32 length ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::MutexGuard aGuard( *m_pMutex ); checkUpdateConditions(columnIndex); checkUpdateIterator(); { Sequence<sal_Int8> aSeq; if(x.is()) x->readBytes(aSeq,length); updateValue(columnIndex,aSeq); } } void SAL_CALL ORowSet::updateCharacterStream( sal_Int32 columnIndex, const Reference< css::io::XInputStream >& x, sal_Int32 length ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::MutexGuard aGuard( *m_pMutex ); checkUpdateConditions(columnIndex); checkUpdateIterator(); ORowSetValueVector::Vector& rRow = **m_aCurrentRow; ORowSetNotifier aNotify(this, std::vector(rRow)); m_pCache->updateCharacterStream(columnIndex,x,length,rRow,aNotify.getChangedColumns()); m_bModified = m_bModified || !aNotify.getChangedColumns().empty(); aNotify.firePropertyChange(); } void SAL_CALL ORowSet::updateObject( sal_Int32 columnIndex, const Any& x ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::MutexGuard aGuard( *m_pMutex ); checkUpdateConditions(columnIndex); checkUpdateIterator(); Any aNewValue = x; if ( m_pColumns ) { Reference<XPropertySet> xColumn(m_pColumns->getByIndex(columnIndex-1),UNO_QUERY); sal_Int32 nColType = 0; xColumn->getPropertyValue(PROPERTY_TYPE) >>= nColType; switch( nColType ) { case DataType::DATE: case DataType::TIME: case DataType::TIMESTAMP: { double nValue = 0; if ( x >>= nValue ) { if ( DataType::TIMESTAMP == nColType ) aNewValue <<= dbtools::DBTypeConversion::toDateTime( nValue ); else if ( DataType::DATE == nColType ) aNewValue <<= dbtools::DBTypeConversion::toDate( nValue ); else aNewValue <<= dbtools::DBTypeConversion::toTime( nValue ); } break; } } } if (!::dbtools::implUpdateObject(this, columnIndex, aNewValue)) { // there is no other updateXXX call which can handle the value in x ORowSetValueVector::Vector& rRow = **m_aCurrentRow; ORowSetNotifier aNotify(this, std::vector(rRow)); m_pCache->updateObject(columnIndex,aNewValue,rRow,aNotify.getChangedColumns()); m_bModified = m_bModified || !aNotify.getChangedColumns().empty(); aNotify.firePropertyChange(); } } void SAL_CALL ORowSet::updateNumericObject( sal_Int32 columnIndex, const Any& x, sal_Int32 /*scale*/ ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::MutexGuard aGuard( *m_pMutex ); checkUpdateConditions(columnIndex); checkUpdateIterator(); ORowSetValueVector::Vector& rRow = **m_aCurrentRow; ORowSetNotifier aNotify(this, std::vector(rRow)); m_pCache->updateNumericObject(columnIndex,x,rRow,aNotify.getChangedColumns()); m_bModified = m_bModified || !aNotify.getChangedColumns().empty(); aNotify.firePropertyChange(); } namespace { class ProtectFlag { bool& m_rInsertingRow; public: explicit ProtectFlag(bool& rInsertingRow) : m_rInsertingRow(rInsertingRow) { if (m_rInsertingRow) { throw std::runtime_error("recursion in insertRow"); } m_rInsertingRow = true; } ~ProtectFlag() { m_rInsertingRow = false; } }; } // XResultSetUpdate void SAL_CALL ORowSet::insertRow() { ProtectFlag aFlagControl(m_bInsertingRow); ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); // insertRow is not allowed when // standing not on the insert row nor // when the row isn't modified // or the concurrency is read only ::osl::ResettableMutexGuard aGuard( *m_pMutex ); if(!m_pCache || !m_bNew || !m_bModified || m_nResultSetConcurrency == ResultSetConcurrency::READ_ONLY) throwFunctionSequenceException(*this); // remember old value for fire bool bOld = m_bNew; ORowSetRow aOldValues; if ( !m_aCurrentRow.isNull() ) aOldValues = new ORowSetValueVector( *(*m_aCurrentRow)); Sequence<Any> aChangedBookmarks; RowsChangeEvent aEvt(*this,RowChangeAction::INSERT,1,aChangedBookmarks); notifyAllListenersRowBeforeChange(aGuard,aEvt); std::vector< Any > aBookmarks; bool bInserted = m_pCache->insertRow(aBookmarks); // make sure that our row is set to the new inserted row before clearing the insert flags in the cache m_pCache->resetInsertRow(bInserted); // notification order // - column values setCurrentRow( false, true, aOldValues, aGuard ); // we don't move here // read-only flag restored impl_restoreDataColumnsWriteable_throw(); // - rowChanged notifyAllListenersRowChanged(aGuard,aEvt); if ( !aBookmarks.empty() ) { RowsChangeEvent aUpEvt(*this,RowChangeAction::UPDATE,aBookmarks.size(),comphelper::containerToSequence(aBookmarks)); notifyAllListenersRowChanged(aGuard,aUpEvt); } // - IsModified if(!m_bModified) fireProperty(PROPERTY_ID_ISMODIFIED,false,true); OSL_ENSURE( !m_bModified, "ORowSet::insertRow: just updated, but _still_ modified?" ); // - IsNew if(m_bNew != bOld) fireProperty(PROPERTY_ID_ISNEW,m_bNew,bOld); // - RowCount/IsRowCountFinal fireRowcount(); } void SAL_CALL ORowSet::updateRow( ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); // not allowed when standing on insert row ::osl::ResettableMutexGuard aGuard( *m_pMutex ); if ( !m_pCache || m_nResultSetConcurrency == ResultSetConcurrency::READ_ONLY || m_bNew || ((m_pCache->m_nPrivileges & Privilege::UPDATE ) != Privilege::UPDATE) ) throwFunctionSequenceException(*this); if(!m_bModified) return; ORowSetRow aOldValues; if ( !m_aCurrentRow.isNull() ) aOldValues = new ORowSetValueVector( *(*m_aCurrentRow) ); Sequence<Any> aChangedBookmarks; RowsChangeEvent aEvt(*this,RowChangeAction::UPDATE,1,aChangedBookmarks); notifyAllListenersRowBeforeChange(aGuard,aEvt); std::vector< Any > aBookmarks; m_pCache->updateRow(m_aCurrentRow.operator ->(),aBookmarks); if ( !aBookmarks.empty() ) aEvt.Bookmarks = comphelper::containerToSequence(aBookmarks); aEvt.Rows += aBookmarks.size(); m_aBookmark = m_pCache->getBookmark(); m_aCurrentRow = m_pCache->m_aMatrixIter; m_bIsInsertRow = false; if ( m_pCache->m_aMatrixIter != m_pCache->getEnd() && (*m_pCache->m_aMatrixIter).is() ) { if ( m_pCache->isResultSetChanged() ) { impl_rebuild_throw(aGuard); } else { m_aOldRow->setRow(new ORowSetValueVector(*(*m_aCurrentRow))); // notification order // - column values ORowSetBase::firePropertyChange(aOldValues); } // - rowChanged notifyAllListenersRowChanged(aGuard,aEvt); // - IsModified if(!m_bModified) fireProperty(PROPERTY_ID_ISMODIFIED,false,true); OSL_ENSURE( !m_bModified, "ORowSet::updateRow: just updated, but _still_ modified?" ); // - RowCount/IsRowCountFinal fireRowcount(); } else if ( !m_bAfterLast ) // the update went wrong { ::dbtools::throwSQLException( DBA_RES( RID_STR_UPDATE_FAILED ), StandardSQLState::INVALID_CURSOR_POSITION, *this ); } } void SAL_CALL ORowSet::deleteRow( ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::ResettableMutexGuard aGuard( *m_pMutex ); checkCache(); if ( m_bBeforeFirst || m_bAfterLast ) ::dbtools::throwSQLException( DBA_RES( RID_STR_NO_DELETE_BEFORE_AFTER ), StandardSQLState::INVALID_CURSOR_POSITION, *this ); if ( m_bNew ) ::dbtools::throwSQLException( DBA_RES( RID_STR_NO_DELETE_INSERT_ROW ), StandardSQLState::INVALID_CURSOR_POSITION, *this ); if ( m_nResultSetConcurrency == ResultSetConcurrency::READ_ONLY ) ::dbtools::throwSQLException( DBA_RES( RID_STR_RESULT_IS_READONLY ), StandardSQLState::FUNCTION_SEQUENCE_ERROR, *this ); if ( ( m_pCache->m_nPrivileges & Privilege::DELETE ) != Privilege::DELETE ) ::dbtools::throwSQLException( DBA_RES( RID_STR_NO_DELETE_PRIVILEGE ), StandardSQLState::FUNCTION_SEQUENCE_ERROR, *this ); if ( rowDeleted() ) ::dbtools::throwSQLException( DBA_RES( RID_STR_ROW_ALREADY_DELETED ), StandardSQLState::FUNCTION_SEQUENCE_ERROR, *this ); // this call position the cache indirect Any aBookmarkToDelete( m_aBookmark ); positionCache( CursorMoveDirection::Current ); sal_Int32 nDeletePosition = m_pCache->getRow(); notifyRowSetAndClonesRowDelete( aBookmarkToDelete ); ORowSetRow aOldValues; if ( m_pCache->m_aMatrixIter != m_pCache->getEnd() && m_pCache->m_aMatrixIter->is() ) aOldValues = new ORowSetValueVector( *(*(m_pCache->m_aMatrixIter)) ); Sequence<Any> aChangedBookmarks; RowsChangeEvent aEvt(*this,RowChangeAction::DELETE,1,aChangedBookmarks); notifyAllListenersRowBeforeChange(aGuard,aEvt); m_pCache->deleteRow(); notifyRowSetAndClonesRowDeleted( aBookmarkToDelete, nDeletePosition ); ORowSetNotifier aNotifier( this ); // this will call cancelRowModification on the cache if necessary // notification order // - rowChanged notifyAllListenersRowChanged(aGuard,aEvt); // - IsModified // - IsNew aNotifier.fire( ); // - RowCount/IsRowCountFinal fireRowcount(); } void ORowSet::implCancelRowUpdates( bool _bNotifyModified ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::MutexGuard aGuard( *m_pMutex ); if ( m_bBeforeFirst || m_bAfterLast || rowDeleted() ) return; // nothing to do so return checkCache(); // cancelRowUpdates is not allowed when: // - standing on the insert row // - the concurrency is read only // - the current row is deleted if ( m_bNew || m_nResultSetConcurrency == ResultSetConcurrency::READ_ONLY ) throwFunctionSequenceException(*this); positionCache( CursorMoveDirection::Current ); ORowSetRow aOldValues; if ( !m_bModified && _bNotifyModified && !m_aCurrentRow.isNull() ) aOldValues = new ORowSetValueVector( *(*m_aCurrentRow) ); m_pCache->cancelRowUpdates(); m_aBookmark = m_pCache->getBookmark(); m_aCurrentRow = m_pCache->m_aMatrixIter; m_bIsInsertRow = false; // notification order // IsModified if( !m_bModified && _bNotifyModified ) { // - column values ORowSetBase::firePropertyChange(aOldValues); fireProperty(PROPERTY_ID_ISMODIFIED,false,true); } } void SAL_CALL ORowSet::cancelRowUpdates( ) { implCancelRowUpdates( true ); } void SAL_CALL ORowSet::addRowSetListener( const Reference< XRowSetListener >& listener ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::MutexGuard aGuard( m_aColumnsMutex ); if(listener.is()) m_aRowsetListeners.addInterface(listener); } void SAL_CALL ORowSet::removeRowSetListener( const Reference< XRowSetListener >& listener ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::MutexGuard aGuard( m_aColumnsMutex ); if(listener.is()) m_aRowsetListeners.removeInterface(listener); } void ORowSet::notifyAllListeners(::osl::ResettableMutexGuard& _rGuard) { EventObject aEvt(*m_pMySelf); _rGuard.clear(); m_aRowsetListeners.notifyEach( &XRowSetListener::rowSetChanged, aEvt ); _rGuard.reset(); } void ORowSet::notifyAllListenersCursorMoved(::osl::ResettableMutexGuard& _rGuard) { EventObject aEvt(*m_pMySelf); _rGuard.clear(); m_aRowsetListeners.notifyEach( &XRowSetListener::cursorMoved, aEvt ); _rGuard.reset(); } void ORowSet::notifyAllListenersRowChanged(::osl::ResettableMutexGuard& _rGuard, const RowsChangeEvent& aEvt) { _rGuard.clear(); m_aRowsetListeners.notifyEach( &XRowSetListener::rowChanged, static_cast<EventObject>(aEvt) ); m_aRowsChangeListener.notifyEach( &XRowsChangeListener::rowsChanged, aEvt ); _rGuard.reset(); } bool ORowSet::notifyAllListenersCursorBeforeMove(::osl::ResettableMutexGuard& _rGuard) { EventObject aEvt(*m_pMySelf); std::vector< Reference< css::sdb::XRowSetApproveListener > > aListenerSeq = m_aApproveListeners.getElements(); _rGuard.clear(); bool bCheck = std::all_of(aListenerSeq.rbegin(), aListenerSeq.rend(), [&aEvt](Reference<css::sdb::XRowSetApproveListener>& rxItem) { try { return static_cast<bool>(rxItem->approveCursorMove(aEvt)); } catch( RuntimeException& ) { return true; } }); _rGuard.reset(); return bCheck; } void ORowSet::notifyAllListenersRowBeforeChange(::osl::ResettableMutexGuard& _rGuard,const RowChangeEvent &aEvt) { std::vector< Reference< css::sdb::XRowSetApproveListener > > aListenerSeq = m_aApproveListeners.getElements(); _rGuard.clear(); bool bCheck = std::all_of(aListenerSeq.rbegin(), aListenerSeq.rend(), [&aEvt](Reference<css::sdb::XRowSetApproveListener>& rxItem) { try { return static_cast<bool>(rxItem->approveRowChange(aEvt)); } catch( RuntimeException& ) { return true; } }); _rGuard.reset(); if ( !bCheck ) m_aErrors.raiseTypedException( sdb::ErrorCondition::ROW_SET_OPERATION_VETOED, *this, ::cppu::UnoType< RowSetVetoException >::get() ); } void ORowSet::fireRowcount() { sal_Int32 nCurrentRowCount( impl_getRowCount() ); bool bCurrentRowCountFinal( m_pCache->m_bRowCountFinal ); if ( m_nLastKnownRowCount != nCurrentRowCount ) { sal_Int32 nHandle = PROPERTY_ID_ROWCOUNT; Any aNew,aOld; aNew <<= nCurrentRowCount; aOld <<= m_nLastKnownRowCount; fire(&nHandle,&aNew,&aOld,1,false); m_nLastKnownRowCount = nCurrentRowCount; } if ( !m_bLastKnownRowCountFinal && ( m_bLastKnownRowCountFinal != bCurrentRowCountFinal ) ) { sal_Int32 nHandle = PROPERTY_ID_ISROWCOUNTFINAL; Any aNew,aOld; aNew <<= bCurrentRowCountFinal; aOld <<= m_bLastKnownRowCountFinal; fire(&nHandle,&aNew,&aOld,1,false); m_bLastKnownRowCountFinal = bCurrentRowCountFinal; } } void SAL_CALL ORowSet::moveToInsertRow( ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::ResettableMutexGuard aGuard( *m_pMutex ); checkPositioningAllowed(); if ( ( m_pCache->m_nPrivileges & Privilege::INSERT ) != Privilege::INSERT ) ::dbtools::throwSQLException( DBA_RES( RID_STR_NO_INSERT_PRIVILEGE ), StandardSQLState::GENERAL_ERROR, *this ); if ( !notifyAllListenersCursorBeforeMove( aGuard ) ) return; // remember old value for fire ORowSetRow aOldValues; if ( rowDeleted() ) { positionCache( CursorMoveDirection::Forward ); m_pCache->next(); setCurrentRow( true, false, aOldValues, aGuard); } else positionCache( CursorMoveDirection::Current ); // check before because the resultset could be empty if ( !m_bBeforeFirst && !m_bAfterLast && m_pCache->m_aMatrixIter != m_pCache->getEnd() && m_pCache->m_aMatrixIter->is() ) aOldValues = new ORowSetValueVector( *(*(m_pCache->m_aMatrixIter)) ); const bool bNewState = m_bNew; const bool bModState = m_bModified; m_pCache->moveToInsertRow(); m_aCurrentRow = m_pCache->m_aInsertRow; m_bIsInsertRow = true; // set read-only flag to false impl_setDataColumnsWriteable_throw(); // notification order // - column values ORowSetBase::firePropertyChange(aOldValues); // - cursorMoved notifyAllListenersCursorMoved(aGuard); // - IsModified if ( bModState != m_bModified ) fireProperty( PROPERTY_ID_ISMODIFIED, m_bModified, bModState ); // - IsNew if ( bNewState != m_bNew ) fireProperty( PROPERTY_ID_ISNEW, m_bNew, bNewState ); // - RowCount/IsRowCountFinal fireRowcount(); } void ORowSet::impl_setDataColumnsWriteable_throw() { impl_restoreDataColumnsWriteable_throw(); m_aReadOnlyDataColumns.resize(m_aDataColumns.size(),false); std::vector<bool, std::allocator<bool> >::iterator aReadIter = m_aReadOnlyDataColumns.begin(); for (auto const& dataColumn : m_aDataColumns) { bool bReadOnly = false; dataColumn->getPropertyValue(PROPERTY_ISREADONLY) >>= bReadOnly; *aReadIter = bReadOnly; dataColumn->setPropertyValue(PROPERTY_ISREADONLY,Any(false)); ++aReadIter; } } void ORowSet::impl_restoreDataColumnsWriteable_throw() { assert(m_aDataColumns.size() == m_aReadOnlyDataColumns.size() || m_aReadOnlyDataColumns.empty()); TDataColumns::const_iterator aIter = m_aDataColumns.begin(); for (bool readOnlyDataColumn : m_aReadOnlyDataColumns) { (*aIter)->setPropertyValue(PROPERTY_ISREADONLY, Any(readOnlyDataColumn) ); ++aIter; } m_aReadOnlyDataColumns.clear(); } void SAL_CALL ORowSet::moveToCurrentRow( ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::ResettableMutexGuard aGuard( *m_pMutex ); checkPositioningAllowed(); if ( !m_pCache->m_bNew && !m_bModified ) // nothing to do if we're not on the insertion row, and not modified otherwise return; if ( rowDeleted() ) // this would perhaps even justify a RuntimeException... // if the current row is deleted, then no write access to this row should be possible. So, // m_bModified should be true. Also, as soon as somebody calls moveToInsertRow, // our current row should not be deleted anymore. So, we should not have survived the above // check "if ( !m_pCache->m_bNew && !m_bModified )" ::dbtools::throwSQLException( DBA_RES( RID_STR_ROW_ALREADY_DELETED ), StandardSQLState::FUNCTION_SEQUENCE_ERROR, *this ); if ( !notifyAllListenersCursorBeforeMove( aGuard ) ) return; positionCache( CursorMoveDirection::CurrentRefresh ); ORowSetNotifier aNotifier( this ); // notification order // - cursorMoved notifyAllListenersCursorMoved(aGuard); // - IsModified // - IsNew aNotifier.fire(); } // XRow sal_Bool SAL_CALL ORowSet::wasNull( ) { ::osl::MutexGuard aGuard( *m_pMutex ); checkCache(); return ( m_pCache && isInsertRow() ) ? (**m_pCache->m_aInsertRow)[m_nLastColumnIndex].isNull() : ORowSetBase::wasNull(); } const ORowSetValue& ORowSet::getInsertValue(sal_Int32 columnIndex) { checkCache(); if ( m_pCache && isInsertRow() ) { m_nLastColumnIndex = columnIndex; return (**m_pCache->m_aInsertRow)[m_nLastColumnIndex]; } return getValue(columnIndex); } OUString SAL_CALL ORowSet::getString( sal_Int32 columnIndex ) { ::osl::MutexGuard aGuard( *m_pMutex ); return getInsertValue(columnIndex).getString(); } sal_Bool SAL_CALL ORowSet::getBoolean( sal_Int32 columnIndex ) { ::osl::MutexGuard aGuard( *m_pMutex ); return getInsertValue(columnIndex).getBool(); } sal_Int8 SAL_CALL ORowSet::getByte( sal_Int32 columnIndex ) { ::osl::MutexGuard aGuard( *m_pMutex ); return getInsertValue(columnIndex).getInt8(); } sal_Int16 SAL_CALL ORowSet::getShort( sal_Int32 columnIndex ) { ::osl::MutexGuard aGuard( *m_pMutex ); return getInsertValue(columnIndex).getInt16(); } sal_Int32 SAL_CALL ORowSet::getInt( sal_Int32 columnIndex ) { ::osl::MutexGuard aGuard( *m_pMutex ); return getInsertValue(columnIndex).getInt32(); } sal_Int64 SAL_CALL ORowSet::getLong( sal_Int32 columnIndex ) { ::osl::MutexGuard aGuard( *m_pMutex ); return getInsertValue(columnIndex).getLong(); } float SAL_CALL ORowSet::getFloat( sal_Int32 columnIndex ) { ::osl::MutexGuard aGuard( *m_pMutex ); return getInsertValue(columnIndex).getFloat(); } double SAL_CALL ORowSet::getDouble( sal_Int32 columnIndex ) { ::osl::MutexGuard aGuard( *m_pMutex ); return getInsertValue(columnIndex).getDouble(); } Sequence< sal_Int8 > SAL_CALL ORowSet::getBytes( sal_Int32 columnIndex ) { ::osl::MutexGuard aGuard( *m_pMutex ); return getInsertValue(columnIndex).getSequence(); } css::util::Date SAL_CALL ORowSet::getDate( sal_Int32 columnIndex ) { ::osl::MutexGuard aGuard( *m_pMutex ); return getInsertValue(columnIndex).getDate(); } css::util::Time SAL_CALL ORowSet::getTime( sal_Int32 columnIndex ) { ::osl::MutexGuard aGuard( *m_pMutex ); return getInsertValue(columnIndex).getTime(); } css::util::DateTime SAL_CALL ORowSet::getTimestamp( sal_Int32 columnIndex ) { ::osl::MutexGuard aGuard( *m_pMutex ); return getInsertValue(columnIndex).getDateTime(); } Reference< css::io::XInputStream > SAL_CALL ORowSet::getBinaryStream( sal_Int32 columnIndex ) { ::osl::MutexGuard aGuard( *m_pMutex ); if ( m_pCache && isInsertRow() ) { checkCache(); m_nLastColumnIndex = columnIndex; return new ::comphelper::SequenceInputStream((**m_pCache->m_aInsertRow)[m_nLastColumnIndex].getSequence()); } return ORowSetBase::getBinaryStream(columnIndex); } Reference< css::io::XInputStream > SAL_CALL ORowSet::getCharacterStream( sal_Int32 columnIndex ) { ::osl::MutexGuard aGuard( *m_pMutex ); if(m_pCache && isInsertRow() ) { checkCache(); m_nLastColumnIndex = columnIndex; return new ::comphelper::SequenceInputStream((**m_pCache->m_aInsertRow)[m_nLastColumnIndex].getSequence()); } return ORowSetBase::getCharacterStream(columnIndex); } Any SAL_CALL ORowSet::getObject( sal_Int32 columnIndex, const Reference< XNameAccess >& /*typeMap*/ ) { ::osl::MutexGuard aGuard( *m_pMutex ); return getInsertValue(columnIndex).makeAny(); } Reference< XRef > SAL_CALL ORowSet::getRef( sal_Int32 /*columnIndex*/ ) { return Reference< XRef >(); } Reference< XBlob > SAL_CALL ORowSet::getBlob( sal_Int32 columnIndex ) { if ( m_pCache && isInsertRow() ) { checkCache(); m_nLastColumnIndex = columnIndex; return new ::connectivity::BlobHelper((**m_pCache->m_aInsertRow)[m_nLastColumnIndex].getSequence()); } return ORowSetBase::getBlob(columnIndex); } Reference< XClob > SAL_CALL ORowSet::getClob( sal_Int32 columnIndex ) { return Reference< XClob >(getInsertValue(columnIndex).makeAny(),UNO_QUERY); } Reference< XArray > SAL_CALL ORowSet::getArray( sal_Int32 /*columnIndex*/ ) { return Reference< XArray >(); } void SAL_CALL ORowSet::executeWithCompletion( const Reference< XInteractionHandler >& _rxHandler ) { if (!_rxHandler.is()) execute(); ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); // tell everybody that we will change the result set approveExecution(); ResettableMutexGuard aGuard( m_aMutex ); try { freeResources( m_bCommandFacetsDirty ); // calc the connection to be used if (m_xActiveConnection.is() && m_bRebuildConnOnExecute) { // there was a setProperty(ActiveConnection), but a setProperty(DataSource) _after_ that, too Reference< XConnection > xXConnection; setActiveConnection( xXConnection ); } calcConnection( _rxHandler ); m_bRebuildConnOnExecute = false; Reference< XSingleSelectQueryComposer > xComposer = getCurrentSettingsComposer( this, m_aContext, nullptr ); Reference<XParametersSupplier> xParameters(xComposer, UNO_QUERY); Reference<XIndexAccess> xParamsAsIndicies = xParameters.is() ? xParameters->getParameters() : Reference<XIndexAccess>(); const sal_Int32 nParamCount = xParamsAsIndicies.is() ? xParamsAsIndicies->getCount() : 0; if ( m_aParametersSet.size() < o3tl::make_unsigned(nParamCount) ) m_aParametersSet.resize( nParamCount ,false); ::dbtools::askForParameters( xComposer, this, m_xActiveConnection, _rxHandler,m_aParametersSet ); } // ensure that only the allowed exceptions leave this block catch(SQLException&) { throw; } catch(RuntimeException&) { throw; } catch(Exception const &) { TOOLS_WARN_EXCEPTION("dbaccess", "ORowSet::executeWithCompletion: caught an unexpected exception type while filling in the parameters"); } // we're done with the parameters, now for the real execution // do the real execute execute_NoApprove_NoNewConn(aGuard); } Reference< XIndexAccess > SAL_CALL ORowSet::getParameters( ) { ::osl::MutexGuard aGuard( *m_pMutex ); ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); if ( m_bCommandFacetsDirty ) // need to rebuild the parameters, since some property which contributes to the // complete command, and thus the parameters, changed impl_disposeParametersContainer_nothrow(); if ( !m_pParameters && !m_aCommand.isEmpty() ) { try { OUString sNotInterestedIn; impl_initComposer_throw( sNotInterestedIn ); } catch( const Exception& ) { DBG_UNHANDLED_EXCEPTION("dbaccess"); } } // our caller could change our parameters at any time m_bParametersDirty = true; return m_pParameters; } void ORowSet::approveExecution() { ::osl::MutexGuard aGuard( m_aColumnsMutex ); EventObject aEvt(*this); OInterfaceIteratorHelper3 aApproveIter( m_aApproveListeners ); while ( aApproveIter.hasMoreElements() ) { Reference< XRowSetApproveListener > xListener( aApproveIter.next() ); try { if ( !xListener->approveRowSetChange( aEvt ) ) throw RowSetVetoException(); } catch ( const DisposedException& e ) { if ( e.Context == xListener ) aApproveIter.remove(); } catch ( const RuntimeException& ) { throw; } catch ( const RowSetVetoException& ) { throw; } catch ( const Exception& ) { DBG_UNHANDLED_EXCEPTION("dbaccess"); } } } // XRowSet void SAL_CALL ORowSet::execute( ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); // tell everybody that we will change the result set approveExecution(); ResettableMutexGuard aGuard( m_aMutex ); freeResources( m_bCommandFacetsDirty ); // calc the connection to be used if (m_xActiveConnection.is() && m_bRebuildConnOnExecute) { // there was a setProperty(ActiveConnection), but a setProperty(DataSource) _after_ that, too Reference< XConnection> xXConnection; setActiveConnection( xXConnection ); } calcConnection(nullptr); m_bRebuildConnOnExecute = false; // do the real execute execute_NoApprove_NoNewConn(aGuard); } void ORowSet::setStatementResultSetType( const Reference< XPropertySet >& _rxStatement, sal_Int32 _nDesiredResultSetType, sal_Int32 _nDesiredResultSetConcurrency ) { OSL_ENSURE( _rxStatement.is(), "ORowSet::setStatementResultSetType: invalid statement - this will crash!" ); sal_Int32 nResultSetType( _nDesiredResultSetType ); sal_Int32 nResultSetConcurrency( _nDesiredResultSetConcurrency ); // there *might* be a data source setting which tells use to be more defensive with those settings // #i15113# bool bRespectDriverRST = false; Any aSetting; if ( getDataSourceSetting( ::dbaccess::getDataSource( m_xActiveConnection ), "RespectDriverResultSetType", aSetting ) ) { OSL_VERIFY( aSetting >>= bRespectDriverRST ); } if ( bRespectDriverRST ) { // try type/concurrency settings with decreasing usefulness, and rely on what the connection claims // to support Reference< XDatabaseMetaData > xMeta( m_xActiveConnection->getMetaData() ); sal_Int32 nCharacteristics[5][2] = { { ResultSetType::SCROLL_SENSITIVE, ResultSetConcurrency::UPDATABLE }, { ResultSetType::SCROLL_INSENSITIVE, ResultSetConcurrency::UPDATABLE }, { ResultSetType::SCROLL_SENSITIVE, ResultSetConcurrency::READ_ONLY }, { ResultSetType::SCROLL_INSENSITIVE, ResultSetConcurrency::READ_ONLY }, { ResultSetType::FORWARD_ONLY, ResultSetConcurrency::READ_ONLY } }; sal_Int32 i=0; if ( m_xActiveConnection->getMetaData()->isReadOnly() ) i = 2; // if the database is read-only we only should use read-only concurrency for ( ; i<5; ++i ) { nResultSetType = nCharacteristics[i][0]; nResultSetConcurrency = nCharacteristics[i][1]; // don't try type/concurrency pairs which are more featured than what our caller requested if ( nResultSetType > _nDesiredResultSetType ) continue; if ( nResultSetConcurrency > _nDesiredResultSetConcurrency ) continue; if ( xMeta.is() && xMeta->supportsResultSetConcurrency( nResultSetType, nResultSetConcurrency ) ) break; } } _rxStatement->setPropertyValue( PROPERTY_RESULTSETTYPE, Any( nResultSetType ) ); _rxStatement->setPropertyValue( PROPERTY_RESULTSETCONCURRENCY, Any( nResultSetConcurrency ) ); } void ORowSet::impl_ensureStatement_throw() { OUString sCommandToExecute; if(m_bCommandFacetsDirty) { impl_initComposer_throw( sCommandToExecute ); } else { sCommandToExecute = m_bUseEscapeProcessing ? m_xComposer->getQueryWithSubstitution() : m_aActiveCommand; } try { m_xStatement = m_xActiveConnection->prepareStatement( sCommandToExecute ); if ( !m_xStatement.is() ) { ::dbtools::throwSQLException( DBA_RES( RID_STR_INTERNAL_ERROR ), StandardSQLState::GENERAL_ERROR, *this ); } Reference< XPropertySet > xStatementProps( m_xStatement, UNO_QUERY_THROW ); // set the result set type and concurrency try { xStatementProps->setPropertyValue( PROPERTY_USEBOOKMARKS, Any( true ) ); xStatementProps->setPropertyValue( PROPERTY_MAXROWS, Any( m_nMaxRows ) ); setStatementResultSetType( xStatementProps, m_nResultSetType, m_nResultSetConcurrency ); } catch ( const Exception& ) { // this exception doesn't matter here because when we catch an exception // then the driver doesn't support this feature } } catch (SQLException& rException) { css::sdbc::SQLException* pLastExceptionInChain = SQLExceptionInfo::getLastException(&rException); assert(pLastExceptionInChain && "will at least be &rException"); // append information about what we were actually going to execute OUString sInfo(m_sErrorString.replaceFirst("$command$", sCommandToExecute)); pLastExceptionInChain->NextException = SQLExceptionInfo::createException(SQLExceptionInfo::TYPE::SQLContext, sInfo, OUString(), 0); // propagate throw; } } Reference< XResultSet > ORowSet::impl_prepareAndExecute_throw() { impl_ensureStatement_throw(); m_aParameterValueForCache->resize(1); Reference< XParameters > xParam( m_xStatement, UNO_QUERY_THROW ); size_t nParamCount( m_pParameters.is() ? m_pParameters->size() : m_aPrematureParamValues->size() ); for ( size_t i=1; i<=nParamCount; ++i ) { ORowSetValue& rParamValue( getParameterStorage( static_cast<sal_Int32>(i) ) ); ::dbtools::setObjectWithInfo( xParam, i, rParamValue.makeAny(), rParamValue.getTypeKind() ); m_aParameterValueForCache->push_back(rParamValue); } m_bParametersDirty = false; Reference< XResultSet > xResultSet(m_xStatement->executeQuery()); OUString aComposedUpdateTableName; if ( !m_aUpdateTableName.isEmpty() ) aComposedUpdateTableName = composeTableName( m_xActiveConnection->getMetaData(), m_aUpdateCatalogName, m_aUpdateSchemaName, m_aUpdateTableName, false, ::dbtools::EComposeRule::InDataManipulation ); SAL_INFO("dbaccess", "ORowSet::impl_prepareAndExecute_throw: creating cache" ); m_pCache = std::make_shared<ORowSetCache>(xResultSet, m_xComposer.get(), m_aContext, aComposedUpdateTableName, m_bModified, m_bNew, *m_aParameterValueForCache, m_aFilter, m_nMaxRows); if ( m_nResultSetConcurrency == ResultSetConcurrency::READ_ONLY ) { m_nPrivileges = Privilege::SELECT; m_pCache->m_nPrivileges = Privilege::SELECT; } m_pCache->setFetchSize(m_nFetchSize); m_aCurrentRow = m_pCache->createIterator(this); m_bIsInsertRow = false; m_aOldRow = m_pCache->registerOldRow(); return xResultSet; } void ORowSet::impl_initializeColumnSettings_nothrow( const Reference< XPropertySet >& _rxTemplateColumn, const Reference< XPropertySet >& _rxRowSetColumn ) { OSL_ENSURE( _rxTemplateColumn.is() && _rxRowSetColumn.is(), "ORowSet::impl_initializeColumnSettings_nothrow: this will crash!" ); bool bHaveAnyColumnSetting = false; try { Reference< XPropertySetInfo > xInfo( _rxTemplateColumn->getPropertySetInfo(), UNO_SET_THROW ); // a number of properties is plain copied const OUString aPropertyNames[] = { PROPERTY_ALIGN, PROPERTY_RELATIVEPOSITION, PROPERTY_WIDTH, PROPERTY_HIDDEN, PROPERTY_CONTROLMODEL, PROPERTY_HELPTEXT, PROPERTY_CONTROLDEFAULT }; for (const auto & aPropertyName : aPropertyNames) { if ( xInfo->hasPropertyByName( aPropertyName ) ) { _rxRowSetColumn->setPropertyValue( aPropertyName, _rxTemplateColumn->getPropertyValue( aPropertyName ) ); bHaveAnyColumnSetting = true; } } // the format key is slightly more complex sal_Int32 nFormatKey = 0; if( xInfo->hasPropertyByName( PROPERTY_NUMBERFORMAT ) ) { _rxTemplateColumn->getPropertyValue( PROPERTY_NUMBERFORMAT ) >>= nFormatKey; bHaveAnyColumnSetting = true; } if ( !nFormatKey && m_xNumberFormatTypes.is() ) nFormatKey = ::dbtools::getDefaultNumberFormat( _rxTemplateColumn, m_xNumberFormatTypes, SvtSysLocale().GetLanguageTag().getLocale() ); _rxRowSetColumn->setPropertyValue( PROPERTY_NUMBERFORMAT, Any( nFormatKey ) ); } catch(Exception&) { DBG_UNHANDLED_EXCEPTION("dbaccess"); return; } if ( bHaveAnyColumnSetting ) return; // the template column could not provide *any* setting. Okay, probably it's a parser column, which // does not offer those. However, perhaps the template column refers to a table column, which we // can use as new template column try { Reference< XPropertySetInfo > xInfo( _rxTemplateColumn->getPropertySetInfo(), UNO_SET_THROW ); if ( !xInfo->hasPropertyByName( PROPERTY_TABLENAME ) ) // no chance return; OUString sTableName; OSL_VERIFY( _rxTemplateColumn->getPropertyValue( PROPERTY_TABLENAME ) >>= sTableName ); Reference< XNameAccess > xTables( impl_getTables_throw(), UNO_SET_THROW ); if ( !xTables->hasByName( sTableName ) ) // no chance return; Reference< XColumnsSupplier > xTableColSup( xTables->getByName( sTableName ), UNO_QUERY_THROW ); Reference< XNameAccess > xTableCols( xTableColSup->getColumns(), UNO_SET_THROW ); OUString sTableColumnName; // get the "Name" or (preferred) "RealName" property of the column OUString sNamePropertyName( PROPERTY_NAME ); if ( xInfo->hasPropertyByName( PROPERTY_REALNAME ) ) sNamePropertyName = PROPERTY_REALNAME; OSL_VERIFY( _rxTemplateColumn->getPropertyValue( sNamePropertyName ) >>= sTableColumnName ); if ( !xTableCols->hasByName( sTableColumnName ) ) return; Reference< XPropertySet > xTableColumn( xTableCols->getByName( sTableColumnName ), UNO_QUERY_THROW ); impl_initializeColumnSettings_nothrow( xTableColumn, _rxRowSetColumn ); } catch( const Exception& ) { DBG_UNHANDLED_EXCEPTION("dbaccess"); } } void ORowSet::execute_NoApprove_NoNewConn(ResettableMutexGuard& _rClearForNotification) { // now we can dispose our old connection ::comphelper::disposeComponent(m_xOldConnection); m_xOldConnection = nullptr; // do we need a new statement if ( m_bCommandFacetsDirty ) { m_xStatement = nullptr; m_xComposer = nullptr; Reference< XResultSet > xResultSet( impl_prepareAndExecute_throw() ); // let our warnings container forget the reference to the (possibly disposed) old result set m_aWarnings.setExternalWarnings( nullptr ); // clear all current warnings m_aWarnings.clearWarnings(); // let the warnings container know about the new "external warnings" m_aWarnings.setExternalWarnings( Reference< XWarningsSupplier >( xResultSet, UNO_QUERY ) ); // get the locale Locale aLocale = SvtSysLocale().GetLanguageTag().getLocale(); // get the numberformatTypes OSL_ENSURE(m_xActiveConnection.is(),"No ActiveConnection"); Reference< XNumberFormatsSupplier> xNumberFormat = ::dbtools::getNumberFormats(m_xActiveConnection); if ( xNumberFormat.is() ) m_xNumberFormatTypes.set(xNumberFormat->getNumberFormats(),UNO_QUERY); ::rtl::Reference< ::connectivity::OSQLColumns> aColumns = new ::connectivity::OSQLColumns(); std::vector< OUString> aNames; OUString aDescription; const std::map<sal_Int32,sal_Int32>& rKeyColumns = m_pCache->getKeyColumns(); if(!m_xColumns.is()) { SAL_INFO("dbaccess", "ORowSet::execute_NoApprove_NoNewConn::creating columns" ); // use the meta data Reference<XResultSetMetaDataSupplier> xMetaSup(m_xStatement,UNO_QUERY); try { Reference<XResultSetMetaData> xMetaData = xMetaSup->getMetaData(); if ( xMetaData.is() ) { sal_Int32 nCount = xMetaData->getColumnCount(); m_aDataColumns.reserve(nCount+1); aColumns->reserve(nCount+1); std::map< OUString, int > aColumnMap; for (sal_Int32 i = 0 ; i < nCount; ++i) { // retrieve the name of the column OUString sName = xMetaData->getColumnName(i + 1); // check for duplicate entries if(aColumnMap.contains(sName)) { OUString sAlias(sName); sal_Int32 searchIndex=1; while(aColumnMap.contains(sAlias)) { sAlias = sName + OUString::number(searchIndex++); } sName = sAlias; } rtl::Reference<ORowSetDataColumn> pColumn = new ORowSetDataColumn( getMetaData(), this, this, i+1, m_xActiveConnection->getMetaData(), aDescription, OUString(), [this] (sal_Int32 const column) -> ORowSetValue const& { return this->getInsertValue(column); }); aColumnMap.insert(std::make_pair(sName,0)); aColumns->emplace_back(pColumn); pColumn->setName(sName); aNames.push_back(sName); m_aDataColumns.push_back(pColumn.get()); pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_ISREADONLY,Any(rKeyColumns.find(i+1) != rKeyColumns.end())); try { sal_Int32 nFormatKey = 0; if(m_xNumberFormatTypes.is()) nFormatKey = ::dbtools::getDefaultNumberFormat(pColumn,m_xNumberFormatTypes,aLocale); pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_NUMBERFORMAT,Any(nFormatKey)); pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_RELATIVEPOSITION,Any(sal_Int32(i+1))); pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_WIDTH,Any(sal_Int32(227))); pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_ALIGN,Any(sal_Int32(0))); pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_HIDDEN, css::uno::Any(false)); } catch(Exception&) { } } } } catch (SQLException&) { } } else { // create the rowset columns Reference< XResultSetMetaData > xMeta( getMetaData(), UNO_SET_THROW ); sal_Int32 nCount = xMeta->getColumnCount(); m_aDataColumns.reserve(nCount+1); aColumns->reserve(nCount+1); std::set< Reference< XPropertySet > > aAllColumns; for(sal_Int32 i=1; i <= nCount ;++i) { OUString sName = xMeta->getColumnName(i); OUString sColumnLabel = xMeta->getColumnLabel(i); // retrieve the column number |i| Reference<XPropertySet> xColumn; { bool bReFetchName = false; if (m_xColumns->hasByName(sColumnLabel)) m_xColumns->getByName(sColumnLabel) >>= xColumn; if (!xColumn.is() && m_xColumns->hasByName(sName)) m_xColumns->getByName(sName) >>= xColumn; // check if column already in the list we need another if ( aAllColumns.find( xColumn ) != aAllColumns.end() ) { xColumn = nullptr; bReFetchName = true; sColumnLabel.clear(); } if(!xColumn.is()) { // no column found so we could look at the position i Reference<XIndexAccess> xIndexAccess(m_xColumns,UNO_QUERY); if(xIndexAccess.is() && i <= xIndexAccess->getCount()) { xIndexAccess->getByIndex(i-1) >>= xColumn; } else { Sequence< OUString> aSeq = m_xColumns->getElementNames(); if( i <= aSeq.getLength()) { m_xColumns->getByName(aSeq[i-1]) >>= xColumn; } } } if(bReFetchName && xColumn.is()) xColumn->getPropertyValue(PROPERTY_NAME) >>= sName; aAllColumns.insert( xColumn ); } // create a RowSetDataColumn { Reference<XPropertySetInfo> xInfo = xColumn.is() ? xColumn->getPropertySetInfo() : Reference<XPropertySetInfo>(); if(xInfo.is() && xInfo->hasPropertyByName(PROPERTY_DESCRIPTION)) aDescription = comphelper::getString(xColumn->getPropertyValue(PROPERTY_DESCRIPTION)); OUString sParseLabel; if ( xColumn.is() ) { xColumn->getPropertyValue(PROPERTY_LABEL) >>= sParseLabel; } rtl::Reference<ORowSetDataColumn> pColumn = new ORowSetDataColumn( getMetaData(), this, this, i, m_xActiveConnection->getMetaData(), aDescription, sParseLabel, [this] (sal_Int32 const column) -> ORowSetValue const& { return this->getInsertValue(column); }); aColumns->emplace_back(pColumn); pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_ISREADONLY,Any(rKeyColumns.find(i) != rKeyColumns.end())); if(sColumnLabel.isEmpty()) { if(xColumn.is()) xColumn->getPropertyValue(PROPERTY_NAME) >>= sColumnLabel; else sColumnLabel = DBA_RES( RID_STR_EXPRESSION1 ); } pColumn->setName(sColumnLabel); aNames.push_back(sColumnLabel); m_aDataColumns.push_back(pColumn.get()); if ( xColumn.is() ) impl_initializeColumnSettings_nothrow( xColumn, pColumn ); } } } // now create the columns we need if(m_pColumns) m_pColumns->assign(aColumns,aNames); else { Reference<XDatabaseMetaData> xMeta = m_xActiveConnection->getMetaData(); m_pColumns.reset( new ORowSetDataColumns(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers(), aColumns,*this,m_aColumnsMutex,aNames) ); } } else // !m_bCommandFacetsDirty { Reference< XResultSet > xResultSet; if(m_bParametersDirty) { xResultSet = impl_prepareAndExecute_throw(); } else { xResultSet = m_xStatement->executeQuery(); m_pCache->reset(xResultSet); } // let our warnings container forget the reference to the (possibly disposed) old result set m_aWarnings.setExternalWarnings( nullptr ); // clear all current warnings m_aWarnings.clearWarnings(); // let the warnings container know about the new "external warnings" m_aWarnings.setExternalWarnings( Reference< XWarningsSupplier >( xResultSet, UNO_QUERY ) ); } checkCache(); // notify the rowset listeners notifyAllListeners(_rClearForNotification); } // XRowSetApproveBroadcaster void SAL_CALL ORowSet::addRowSetApproveListener( const Reference< XRowSetApproveListener >& listener ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::MutexGuard aGuard( m_aColumnsMutex ); m_aApproveListeners.addInterface(listener); } void SAL_CALL ORowSet::removeRowSetApproveListener( const Reference< XRowSetApproveListener >& listener ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::MutexGuard aGuard( m_aColumnsMutex ); m_aApproveListeners.removeInterface(listener); } // XRowsChangeBroadcaster void SAL_CALL ORowSet::addRowsChangeListener( const Reference< XRowsChangeListener >& listener ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::MutexGuard aGuard( m_aColumnsMutex ); m_aRowsChangeListener.addInterface(listener); } void SAL_CALL ORowSet::removeRowsChangeListener( const Reference< XRowsChangeListener >& listener ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::MutexGuard aGuard( m_aColumnsMutex ); m_aRowsChangeListener.removeInterface(listener); } // XResultSetAccess Reference< XResultSet > SAL_CALL ORowSet::createResultSet( ) { ::osl::MutexGuard aGuard( m_aColumnsMutex ); if(m_xStatement.is()) { rtl::Reference<ORowSetClone> pClone = new ORowSetClone( m_aContext, *this, m_pMutex ); m_aClones.emplace_back(css::uno::Reference< css::uno::XWeak >(pClone)); return pClone; } return Reference< XResultSet >(); } // css::util::XCancellable void SAL_CALL ORowSet::cancel( ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); } // css::sdbcx::XDeleteRows Sequence< sal_Int32 > SAL_CALL ORowSet::deleteRows( const Sequence< Any >& rows ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); if(!m_pCache || m_nResultSetConcurrency == ResultSetConcurrency::READ_ONLY) throwFunctionSequenceException(*this); ::osl::ResettableMutexGuard aGuard( *m_pMutex ); Sequence<Any> aChangedBookmarks; RowsChangeEvent aEvt(*this,RowChangeAction::DELETE,rows.getLength(),aChangedBookmarks); // notify the rowset listeners notifyAllListenersRowBeforeChange(aGuard,aEvt); Sequence< sal_Int32 > aResults( rows.getLength() ); sal_Int32* result = aResults.getArray(); for (sal_Int32 i = 0; i < rows.getLength(); ++i) { result[i] = 0; if (!m_pCache->moveToBookmark(rows[i])) continue; sal_Int32 nDeletePosition = m_pCache->getRow(); // first notify the clones so that they can save their position notifyRowSetAndClonesRowDelete(rows[i]); // now delete the row if ( !m_pCache->deleteRow() ) continue; result[i] = 1; // now notify that we have deleted notifyRowSetAndClonesRowDeleted(rows[i], nDeletePosition); } aEvt.Rows = aResults.getLength(); // we have to check if we stand on the insert row and if so we have to reset it ORowSetNotifier aNotifier( this ); // this will call cancelRowModification on the cache if necessary // notification order // - rowChanged notifyAllListenersRowChanged(aGuard,aEvt); // - IsModified // - IsNew aNotifier.fire(); // - RowCount/IsRowCountFinal fireRowcount(); return aResults; } void ORowSet::notifyRowSetAndClonesRowDelete( const Any& _rBookmark ) { // notify ourself onDeleteRow( _rBookmark ); // notify the clones for (auto const& elem : m_aClones) { rtl::Reference<ORowSetClone> pClone = dynamic_cast<ORowSetClone*>(elem.get().get()); if(pClone) pClone->onDeleteRow( _rBookmark ); } } void ORowSet::notifyRowSetAndClonesRowDeleted( const Any& _rBookmark, sal_Int32 _nPos ) { // notify ourself onDeletedRow( _rBookmark, _nPos ); // notify the clones for (auto const& clone : m_aClones) { rtl::Reference<ORowSetClone> pClone = dynamic_cast<ORowSetClone*>(clone.get().get()); if(pClone) pClone->onDeletedRow( _rBookmark, _nPos ); } } Reference< XConnection > ORowSet::calcConnection(const Reference< XInteractionHandler >& _rxHandler) { MutexGuard aGuard(m_aMutex); if (!m_xActiveConnection.is()) { Reference< XConnection > xNewConn; if ( !m_aDataSourceName.isEmpty() ) { Reference< XDatabaseContext > xDatabaseContext( DatabaseContext::create(m_aContext) ); try { Reference< XDataSource > xDataSource( xDatabaseContext->getByName( m_aDataSourceName ), UNO_QUERY_THROW ); // try connecting with the interaction handler Reference< XCompletedConnection > xComplConn( xDataSource, UNO_QUERY ); if ( _rxHandler.is() && xComplConn.is() ) { xNewConn = xComplConn->connectWithCompletion( _rxHandler ); } else { xNewConn = xDataSource->getConnection( m_aUser, m_aPassword ); } } catch ( const SQLException& ) { throw; } catch ( const Exception& ) { Any aError = ::cppu::getCaughtException(); OUString sMessage = ResourceManager::loadString( RID_NO_SUCH_DATA_SOURCE, u"$name$", m_aDataSourceName, u"$error$", extractExceptionMessage( m_aContext, aError ) ); ::dbtools::throwGenericSQLException( sMessage, *this, aError ); } } setActiveConnection(xNewConn); m_bOwnConnection = true; } return m_xActiveConnection; } Reference< XNameAccess > ORowSet::impl_getTables_throw() { Reference< XNameAccess > xTables; Reference< XTablesSupplier > xTablesAccess( m_xActiveConnection, UNO_QUERY ); if ( xTablesAccess.is() ) { xTables.set( xTablesAccess->getTables(), UNO_SET_THROW ); } else if ( m_xTables ) { xTables = m_xTables.get(); } else { if ( !m_xActiveConnection.is() ) throw SQLException(DBA_RES(RID_STR_CONNECTION_INVALID),*this,SQLSTATE_GENERAL,1000,Any() ); bool bCase = true; try { Reference<XDatabaseMetaData> xMeta = m_xActiveConnection->getMetaData(); bCase = xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers(); } catch(SQLException&) { DBG_UNHANDLED_EXCEPTION("dbaccess"); } m_xTables.reset(new OTableContainer(*this,m_aMutex,m_xActiveConnection,bCase,nullptr,nullptr,m_nInAppend)); xTables = m_xTables.get(); Sequence<OUString> aTableFilter { u"%"_ustr }; m_xTables->construct(aTableFilter,Sequence< OUString>()); } return xTables; } void ORowSet::impl_resetTables_nothrow() { if ( !m_xTables ) return; try { m_xTables->dispose(); } catch( const Exception& ) { DBG_UNHANDLED_EXCEPTION("dbaccess"); } m_xTables.reset(); } void ORowSet::impl_initComposer_throw( OUString& _out_rCommandToExecute ) { bool bUseEscapeProcessing = impl_buildActiveCommand_throw( ); _out_rCommandToExecute = m_aActiveCommand; if ( !bUseEscapeProcessing ) return; if (m_bCommandFacetsDirty) m_xComposer = nullptr; Reference< XMultiServiceFactory > xFactory( m_xActiveConnection, UNO_QUERY ); if ( !m_xComposer.is() && xFactory.is() ) { try { m_xComposer.set( xFactory->createInstance( SERVICE_NAME_SINGLESELECTQUERYCOMPOSER ), UNO_QUERY_THROW ); } catch (const Exception& ) { m_xComposer = nullptr; } } if ( !m_xComposer.is() ) m_xComposer = new OSingleSelectQueryComposer( impl_getTables_throw(), m_xActiveConnection, m_aContext ); m_xComposer->setCommand( m_aCommand,m_nCommandType ); m_aActiveCommand = m_xComposer->getQuery(); m_xComposer->setFilter( m_bApplyFilter ? m_aFilter : OUString() ); m_xComposer->setHavingClause( m_bApplyFilter ? m_aHavingClause : OUString() ); if ( m_bIgnoreResult ) { // append a "0=1" filter // don't simply overwrite an existent filter, this would lead to problems if this existent // filter contains parameters (since a keyset may add parameters itself) m_xComposer->setElementaryQuery( m_xComposer->getQuery( ) ); m_xComposer->setFilter( u"0 = 1"_ustr ); } m_xComposer->setOrder( m_aOrder ); m_xComposer->setGroup( m_aGroupBy ); if ( !m_xColumns.is() ) { Reference< XColumnsSupplier > xCols( m_xComposer, UNO_QUERY_THROW ); m_xColumns = xCols->getColumns(); } impl_initParametersContainer_nothrow(); _out_rCommandToExecute = m_xComposer->getQueryWithSubstitution(); m_bCommandFacetsDirty = false; } bool ORowSet::impl_buildActiveCommand_throw() { // create the sql command // from a table name or get the command out of a query (not a view) // the last use the command as it is bool bDoEscapeProcessing = m_bUseEscapeProcessing; m_aActiveCommand.clear(); OUString sCommand; if ( m_aCommand.isEmpty() ) return bDoEscapeProcessing; switch (m_nCommandType) { case CommandType::TABLE: { impl_resetTables_nothrow(); if ( bDoEscapeProcessing ) { Reference< XNameAccess > xTables( impl_getTables_throw() ); if ( xTables->hasByName(m_aCommand) ) { } else { OUString sMessage( DBA_RES( RID_STR_TABLE_DOES_NOT_EXIST ) ); throwGenericSQLException(sMessage.replaceAll( "$table$", m_aCommand ),*this); } } else { sCommand = "SELECT * FROM "; OUString sCatalog, sSchema, sTable; ::dbtools::qualifiedNameComponents( m_xActiveConnection->getMetaData(), m_aCommand, sCatalog, sSchema, sTable, ::dbtools::EComposeRule::InDataManipulation ); sCommand += ::dbtools::composeTableNameForSelect( m_xActiveConnection, sCatalog, sSchema, sTable ); } } break; case CommandType::QUERY: { Reference< XQueriesSupplier > xQueriesAccess(m_xActiveConnection, UNO_QUERY); if (!xQueriesAccess.is()) throw SQLException(DBA_RES(RID_STR_NO_XQUERIESSUPPLIER),*this,OUString(),0,Any()); Reference< css::container::XNameAccess > xQueries(xQueriesAccess->getQueries()); if (xQueries->hasByName(m_aCommand)) { Reference< XPropertySet > xQuery(xQueries->getByName(m_aCommand),UNO_QUERY); OSL_ENSURE(xQuery.is(),"ORowSet::impl_buildActiveCommand_throw: Query is NULL!"); if ( xQuery.is() ) { xQuery->getPropertyValue(PROPERTY_COMMAND) >>= sCommand; xQuery->getPropertyValue(PROPERTY_ESCAPE_PROCESSING) >>= bDoEscapeProcessing; if ( bDoEscapeProcessing != m_bUseEscapeProcessing ) { bool bOldValue = m_bUseEscapeProcessing; m_bUseEscapeProcessing = bDoEscapeProcessing; fireProperty(PROPERTY_ID_ESCAPE_PROCESSING,bOldValue,bDoEscapeProcessing); } OUString aCatalog,aSchema,aTable; xQuery->getPropertyValue(PROPERTY_UPDATE_CATALOGNAME) >>= aCatalog; xQuery->getPropertyValue(PROPERTY_UPDATE_SCHEMANAME) >>= aSchema; xQuery->getPropertyValue(PROPERTY_UPDATE_TABLENAME) >>= aTable; if(!aTable.isEmpty()) m_aUpdateTableName = composeTableName( m_xActiveConnection->getMetaData(), aCatalog, aSchema, aTable, false, ::dbtools::EComposeRule::InDataManipulation ); } } else { OUString sMessage( DBA_RES( RID_STR_QUERY_DOES_NOT_EXIST ) ); throwGenericSQLException(sMessage.replaceAll( "$table$", m_aCommand ),*this); } } break; default: sCommand = m_aCommand; break; } m_aActiveCommand = sCommand; if ( m_aActiveCommand.isEmpty() && !bDoEscapeProcessing ) ::dbtools::throwSQLException( DBA_RES( RID_STR_NO_SQL_COMMAND ), StandardSQLState::FUNCTION_SEQUENCE_ERROR, *this ); return bDoEscapeProcessing; } void ORowSet::impl_initParametersContainer_nothrow() { OSL_PRECOND( !m_pParameters.is(), "ORowSet::impl_initParametersContainer_nothrow: already initialized the parameters!" ); m_pParameters = new param::ParameterWrapperContainer( m_xComposer ); // copy the premature parameters into the final ones size_t nParamCount( std::min( m_pParameters->size(), m_aPrematureParamValues->size() ) ); for ( size_t i=0; i<nParamCount; ++i ) { (*m_pParameters)[i] = (*m_aPrematureParamValues)[i]; } } void ORowSet::impl_disposeParametersContainer_nothrow() { if ( !m_pParameters.is() ) return; // copy the actual values to our "premature" ones, to preserve them for later use size_t nParamCount( m_pParameters->size() ); m_aPrematureParamValues->resize( nParamCount ); for ( size_t i=0; i<nParamCount; ++i ) { (*m_aPrematureParamValues)[i] = (*m_pParameters)[i]; } m_pParameters->dispose(); m_pParameters = nullptr; } ORowSetValue& ORowSet::getParameterStorage(sal_Int32 parameterIndex) { ::connectivity::checkDisposed( ORowSet_BASE1::rBHelper.bDisposed ); if ( parameterIndex < 1 ) throwInvalidIndexException( *this ); if ( m_aParametersSet.size() < o3tl::make_unsigned(parameterIndex) ) m_aParametersSet.resize( parameterIndex ,false); m_aParametersSet[parameterIndex - 1] = true; if ( m_pParameters.is() ) { if ( m_bCommandFacetsDirty ) // need to rebuild the parameters, since some property which contributes to the // complete command, and thus the parameters, changed impl_disposeParametersContainer_nothrow(); if ( m_pParameters.is() ) { if ( o3tl::make_unsigned(parameterIndex) > m_pParameters->size() ) throwInvalidIndexException( *this ); return (*m_pParameters)[ parameterIndex - 1 ]; } } if ( m_aPrematureParamValues->size() < o3tl::make_unsigned(parameterIndex) ) m_aPrematureParamValues->resize( parameterIndex ); return (*m_aPrematureParamValues)[ parameterIndex - 1 ]; } // XParameters void SAL_CALL ORowSet::setNull( sal_Int32 parameterIndex, sal_Int32 /*sqlType*/ ) { ::osl::MutexGuard aGuard( m_aColumnsMutex ); getParameterStorage( parameterIndex ).setNull(); m_bParametersDirty = true; } void SAL_CALL ORowSet::setObjectNull( sal_Int32 parameterIndex, sal_Int32 sqlType, const OUString& /*typeName*/ ) { setNull( parameterIndex, sqlType ); } void ORowSet::setParameter(sal_Int32 parameterIndex, const ORowSetValue& x) { ::osl::MutexGuard aGuard( m_aColumnsMutex ); getParameterStorage( parameterIndex ) = x; m_bParametersDirty = true; } void SAL_CALL ORowSet::setBoolean( sal_Int32 parameterIndex, sal_Bool x ) { setParameter(parameterIndex, static_cast<bool>(x)); } void SAL_CALL ORowSet::setByte( sal_Int32 parameterIndex, sal_Int8 x ) { setParameter(parameterIndex,x); } void SAL_CALL ORowSet::setShort( sal_Int32 parameterIndex, sal_Int16 x ) { setParameter(parameterIndex,x); } void SAL_CALL ORowSet::setInt( sal_Int32 parameterIndex, sal_Int32 x ) { setParameter(parameterIndex,x); } void SAL_CALL ORowSet::setLong( sal_Int32 parameterIndex, sal_Int64 x ) { setParameter(parameterIndex,x); } void SAL_CALL ORowSet::setFloat( sal_Int32 parameterIndex, float x ) { setParameter(parameterIndex,x); } void SAL_CALL ORowSet::setDouble( sal_Int32 parameterIndex, double x ) { setParameter(parameterIndex,x); } void SAL_CALL ORowSet::setString( sal_Int32 parameterIndex, const OUString& x ) { setParameter(parameterIndex,x); } void SAL_CALL ORowSet::setBytes( sal_Int32 parameterIndex, const Sequence< sal_Int8 >& x ) { setParameter(parameterIndex,x); } void SAL_CALL ORowSet::setDate( sal_Int32 parameterIndex, const css::util::Date& x ) { setParameter(parameterIndex,x); } void SAL_CALL ORowSet::setTime( sal_Int32 parameterIndex, const css::util::Time& x ) { setParameter(parameterIndex,x); } void SAL_CALL ORowSet::setTimestamp( sal_Int32 parameterIndex, const css::util::DateTime& x ) { setParameter(parameterIndex,x); } void SAL_CALL ORowSet::setBinaryStream( sal_Int32 parameterIndex, const Reference< css::io::XInputStream >& x, sal_Int32 length ) { ::osl::MutexGuard aGuard( m_aColumnsMutex ); ORowSetValue& rParamValue( getParameterStorage( parameterIndex ) ); try { Sequence <sal_Int8> aData; x->readBytes(aData, length); rParamValue = aData; m_bParametersDirty = true; x->closeInput(); } catch( Exception const & ) { css::uno::Any anyEx = cppu::getCaughtException(); throw SQLException(u"ORowSet::setBinaryStream"_ustr, *this, u"S1000"_ustr, 0,anyEx); } } void SAL_CALL ORowSet::setCharacterStream( sal_Int32 parameterIndex, const Reference< css::io::XInputStream >& x, sal_Int32 length ) { ::osl::MutexGuard aGuard( m_aColumnsMutex ); ORowSetValue& rParamValue( getParameterStorage( parameterIndex ) ); try { Sequence <sal_Int8> aData; OUString aDataStr; // the data is given as character data and the length defines the character length sal_Int32 nSize = x->readBytes(aData, length * sizeof(sal_Unicode)); if (nSize / sizeof(sal_Unicode)) aDataStr = OUString(reinterpret_cast<sal_Unicode const *>(aData.getConstArray()), nSize / sizeof(sal_Unicode)); m_bParametersDirty = true; rParamValue = aDataStr; rParamValue.setTypeKind( DataType::LONGVARCHAR ); x->closeInput(); } catch( Exception const & ) { css::uno::Any anyEx = cppu::getCaughtException(); throw SQLException(u"ORowSet::setCharacterStream"_ustr, *this, u"S1000"_ustr, 0, anyEx); } } void SAL_CALL ORowSet::setObject( sal_Int32 parameterIndex, const Any& x ) { if ( !::dbtools::implSetObject( this, parameterIndex, x ) ) { // there is no other setXXX call which can handle the value in x throw SQLException(); } m_bParametersDirty = true; } void SAL_CALL ORowSet::setObjectWithInfo( sal_Int32 parameterIndex, const Any& x, sal_Int32 targetSqlType, sal_Int32 /*scale*/ ) { ::osl::MutexGuard aGuard( m_aColumnsMutex ); ORowSetValue& rParamValue( getParameterStorage( parameterIndex ) ); setObject( parameterIndex, x ); rParamValue.setTypeKind( targetSqlType ); } void SAL_CALL ORowSet::setRef( sal_Int32 /*parameterIndex*/, const Reference< XRef >& /*x*/ ) { ::dbtools::throwFeatureNotImplementedSQLException( u"XParameters::setRef"_ustr, *this ); } void SAL_CALL ORowSet::setBlob( sal_Int32 /*parameterIndex*/, const Reference< XBlob >& /*x*/ ) { ::dbtools::throwFeatureNotImplementedSQLException( u"XParameters::setBlob"_ustr, *this ); } void SAL_CALL ORowSet::setClob( sal_Int32 /*parameterIndex*/, const Reference< XClob >& /*x*/ ) { ::dbtools::throwFeatureNotImplementedSQLException( u"XParameters::setClob"_ustr, *this ); } void SAL_CALL ORowSet::setArray( sal_Int32 /*parameterIndex*/, const Reference< XArray >& /*x*/ ) { ::dbtools::throwFeatureNotImplementedSQLException( u"XParameters::setArray"_ustr, *this ); } void SAL_CALL ORowSet::clearParameters( ) { ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); ::osl::MutexGuard aGuard( m_aColumnsMutex ); size_t nParamCount( m_pParameters.is() ? m_pParameters->size() : m_aPrematureParamValues->size() ); for ( size_t i=1; i<=nParamCount; ++i ) getParameterStorage( static_cast<sal_Int32>(i) ).setNull(); m_aParametersSet.clear(); } Any SAL_CALL ORowSet::getWarnings( ) { return m_aWarnings.getWarnings(); } void SAL_CALL ORowSet::clearWarnings( ) { m_aWarnings.clearWarnings(); } void ORowSet::doCancelModification( ) { if ( isModification() ) { // read-only flag restored impl_restoreDataColumnsWriteable_throw(); m_pCache->cancelRowModification(); } m_bModified = false; m_bIsInsertRow = false; } bool ORowSet::isModification( ) { return isNew(); } bool ORowSet::isModified( ) { return m_bModified; } bool ORowSet::isNew( ) { return m_bNew; } bool ORowSet::isPropertyChangeNotificationEnabled() const { return m_bPropChangeNotifyEnabled; } void ORowSet::checkUpdateIterator() { if(!m_bIsInsertRow) { m_pCache->setUpdateIterator(m_aCurrentRow); m_aCurrentRow = m_pCache->m_aInsertRow; m_bIsInsertRow = true; } } void ORowSet::checkUpdateConditions(sal_Int32 columnIndex) { checkCache(); if ( m_nResultSetConcurrency == ResultSetConcurrency::READ_ONLY) ::dbtools::throwSQLException( DBA_RES( RID_STR_RESULT_IS_READONLY ), StandardSQLState::GENERAL_ERROR, *this ); if ( rowDeleted() ) ::dbtools::throwSQLException( DBA_RES( RID_STR_ROW_ALREADY_DELETED ), StandardSQLState::INVALID_CURSOR_POSITION, *this ); if ( m_aCurrentRow.isNull() ) ::dbtools::throwSQLException( DBA_RES( RID_STR_INVALID_CURSOR_STATE ), StandardSQLState::INVALID_CURSOR_STATE, *this ); if ( columnIndex <= 0 || (*m_aCurrentRow)->size() <= o3tl::make_unsigned(columnIndex) ) ::dbtools::throwSQLException( DBA_RES( RID_STR_INVALID_INDEX ), StandardSQLState::INVALID_DESCRIPTOR_INDEX, *this ); } void SAL_CALL ORowSet::refreshRow( ) { ORowSetNotifier aNotifier( this ); // this will call cancelRowModification on the cache if necessary // notification order: if ( m_bModified && m_pCache ) implCancelRowUpdates( false ); // do _not_ notify the IsModify - will do this ourself below // - column values ORowSetBase::refreshRow(); // - IsModified // - IsNew aNotifier.fire( ); } void ORowSet::impl_rebuild_throw(::osl::ResettableMutexGuard& _rGuard) { Reference< XResultSet > xResultSet(m_xStatement->executeQuery()); m_pCache->reset(xResultSet); m_aWarnings.setExternalWarnings( Reference< XWarningsSupplier >( xResultSet, UNO_QUERY ) ); notifyAllListeners(_rGuard); } // *********************************************************** // ORowSetClone // *********************************************************** ORowSetClone::ORowSetClone( const Reference<XComponentContext>& _rContext, ORowSet& rParent, ::osl::Mutex* _pMutex ) : ::cppu::WeakComponentImplHelper<>(m_aMutex) ,ORowSetBase( _rContext, WeakComponentImplHelper::rBHelper, _pMutex ) ,m_xParent(&rParent) ,m_nFetchDirection(rParent.m_nFetchDirection) ,m_nFetchSize(rParent.m_nFetchSize) ,m_bIsBookmarkable(true) { m_nResultSetType = rParent.m_nResultSetType; m_nResultSetConcurrency = ResultSetConcurrency::READ_ONLY; m_pMySelf = this; m_bClone = true; m_bBeforeFirst = rParent.m_bBeforeFirst; m_bAfterLast = rParent.m_bAfterLast; m_pCache = rParent.m_pCache; m_aBookmark = rParent.m_aBookmark; m_aCurrentRow = m_pCache->createIterator(this); m_xNumberFormatTypes = rParent.m_xNumberFormatTypes; m_aOldRow = m_pCache->registerOldRow(); ::rtl::Reference< ::connectivity::OSQLColumns> aColumns = new ::connectivity::OSQLColumns(); std::vector< OUString> aNames; OUString aDescription; Locale aLocale = SvtSysLocale().GetLanguageTag().getLocale(); if ( rParent.m_pColumns ) { Sequence< OUString> aSeq = rParent.m_pColumns->getElementNames(); aColumns->reserve(aSeq.getLength()+1); sal_Int32 i = 0; for (auto& columnName : aSeq) { ++i; Reference<XPropertySet> xColumn; rParent.m_pColumns->getByName(columnName) >>= xColumn; if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_DESCRIPTION)) aDescription = comphelper::getString(xColumn->getPropertyValue(PROPERTY_DESCRIPTION)); OUString sParseLabel; xColumn->getPropertyValue(PROPERTY_LABEL) >>= sParseLabel; rtl::Reference<ORowSetColumn> pColumn = new ORowSetColumn( rParent.getMetaData(), this, i, rParent.m_xActiveConnection->getMetaData(), aDescription, sParseLabel, [this] (sal_Int32 const column) -> ORowSetValue const& { return this->getValue(column); }); aColumns->emplace_back(pColumn); pColumn->setName(columnName); aNames.push_back(columnName); m_aDataColumns.push_back(pColumn.get()); pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_ALIGN,xColumn->getPropertyValue(PROPERTY_ALIGN)); sal_Int32 nFormatKey = 0; xColumn->getPropertyValue(PROPERTY_NUMBERFORMAT) >>= nFormatKey; if(!nFormatKey && xColumn.is() && m_xNumberFormatTypes.is()) nFormatKey = ::dbtools::getDefaultNumberFormat(xColumn,m_xNumberFormatTypes,aLocale); pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_NUMBERFORMAT,Any(nFormatKey)); pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_RELATIVEPOSITION,xColumn->getPropertyValue(PROPERTY_RELATIVEPOSITION)); pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_WIDTH,xColumn->getPropertyValue(PROPERTY_WIDTH)); pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_HIDDEN,xColumn->getPropertyValue(PROPERTY_HIDDEN)); pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_CONTROLMODEL,xColumn->getPropertyValue(PROPERTY_CONTROLMODEL)); pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_HELPTEXT,xColumn->getPropertyValue(PROPERTY_HELPTEXT)); pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_CONTROLDEFAULT,xColumn->getPropertyValue(PROPERTY_CONTROLDEFAULT)); } } Reference<XDatabaseMetaData> xMeta = rParent.m_xActiveConnection->getMetaData(); m_pColumns.reset( new ORowSetDataColumns(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers(), aColumns,*this,m_aMutex,aNames) ); sal_Int32 const nRT = PropertyAttribute::READONLY | PropertyAttribute::TRANSIENT; // sdb.RowSet Properties registerMayBeVoidProperty(PROPERTY_ACTIVE_CONNECTION,PROPERTY_ID_ACTIVE_CONNECTION, PropertyAttribute::MAYBEVOID|PropertyAttribute::READONLY, &rParent.m_aActiveConnection, cppu::UnoType<XConnection>::get()); registerProperty(PROPERTY_RESULTSETCONCURRENCY, PROPERTY_ID_RESULTSETCONCURRENCY, PropertyAttribute::READONLY, &m_nResultSetConcurrency,::cppu::UnoType<sal_Int32>::get()); registerProperty(PROPERTY_RESULTSETTYPE, PROPERTY_ID_RESULTSETTYPE, PropertyAttribute::READONLY, &m_nResultSetType, ::cppu::UnoType<sal_Int32>::get()); registerProperty(PROPERTY_FETCHDIRECTION, PROPERTY_ID_FETCHDIRECTION, PropertyAttribute::TRANSIENT, &m_nFetchDirection, ::cppu::UnoType<sal_Int32>::get()); registerProperty(PROPERTY_FETCHSIZE, PROPERTY_ID_FETCHSIZE, PropertyAttribute::TRANSIENT, &m_nFetchSize, ::cppu::UnoType<sal_Int32>::get()); registerProperty(PROPERTY_ISBOOKMARKABLE, PROPERTY_ID_ISBOOKMARKABLE, nRT, &m_bIsBookmarkable, cppu::UnoType<bool>::get()); } ORowSetClone::~ORowSetClone() { } // css::XTypeProvider Sequence< Type > ORowSetClone::getTypes() { return ::comphelper::concatSequences(::cppu::WeakComponentImplHelper<>::getTypes(),ORowSetBase::getTypes()); } // css::XInterface Any ORowSetClone::queryInterface( const Type & rType ) { Any aRet = ORowSetBase::queryInterface(rType); if(!aRet.hasValue()) aRet = ::cppu::WeakComponentImplHelper<>::queryInterface(rType); return aRet; } void ORowSetClone::acquire() noexcept { ::cppu::WeakComponentImplHelper<>::acquire(); } void ORowSetClone::release() noexcept { ::cppu::WeakComponentImplHelper<>::release(); } // XServiceInfo OUString ORowSetClone::getImplementationName( ) { return u"com.sun.star.sdb.ORowSetClone"_ustr; } sal_Bool ORowSetClone::supportsService( const OUString& _rServiceName ) { return cppu::supportsService(this, _rServiceName); } Sequence< OUString > ORowSetClone::getSupportedServiceNames( ) { return { SERVICE_SDBC_RESULTSET, SERVICE_SDB_RESULTSET }; } // OComponentHelper void ORowSetClone::disposing() { MutexGuard aGuard( m_aMutex ); ORowSetBase::disposing(); m_xParent = nullptr; m_pMutex = &m_aMutex; // this must be done here because someone could hold a ref to us and try to do something ::cppu::WeakComponentImplHelper<>::disposing(); } // XCloseable void ORowSetClone::close() { { MutexGuard aGuard( m_aMutex ); if (WeakComponentImplHelper::rBHelper.bDisposed) return; } dispose(); } // comphelper::OPropertyArrayUsageHelper ::cppu::IPropertyArrayHelper* ORowSetClone::createArrayHelper( ) const { Sequence< Property > aProps; describeProperties(aProps); return new ::cppu::OPropertyArrayHelper(aProps); } // cppu::OPropertySetHelper ::cppu::IPropertyArrayHelper& SAL_CALL ORowSetClone::getInfoHelper() { return *::comphelper::OPropertyArrayUsageHelper<ORowSetClone>::getArrayHelper(); } void SAL_CALL ORowSetClone::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue) { if ( nHandle == PROPERTY_ID_FETCHSIZE ) { if ( auto xParent = m_xParent.get() ) xParent->setFastPropertyValue_NoBroadcast( nHandle, rValue ); } OPropertyStateContainer::setFastPropertyValue_NoBroadcast(nHandle,rValue); } void ORowSetClone::doCancelModification( ) { } bool ORowSetClone::isModification( ) { return false; } bool ORowSetClone::isModified( ) { return false; } bool ORowSetClone::isNew( ) { return false; } void SAL_CALL ORowSetClone::execute( ) { throwFunctionNotSupportedSQLException( u"RowSetClone::XRowSet::execute"_ustr, *this ); } void SAL_CALL ORowSetClone::addRowSetListener( const Reference< XRowSetListener >& ) { throwFunctionNotSupportedRuntimeException( u"RowSetClone::XRowSet"_ustr, *this ); } void SAL_CALL ORowSetClone::removeRowSetListener( const Reference< XRowSetListener >& ) { throwFunctionNotSupportedRuntimeException( u"RowSetClone::XRowSet"_ustr, *this ); } } // dbaccess /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V560 A part of conditional expression is always true: !nFormatKey.

↑ V785 Constant expression in switch statement.

↑ V793 It is odd that the result of the 'nSize / sizeof (sal_Unicode)' statement is a part of the condition. Perhaps, this statement should have been compared with something else.

↑ V1037 Two or more case-branches perform the same actions. Check lines: 208, 211, 214

↑ V1037 Two or more case-branches perform the same actions. Check lines: 217, 220, 235