| /************************************************************** |
| * |
| * 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 "RowSet.hxx" |
| #include "dbastrings.hrc" |
| #include "sdbcoretools.hxx" |
| #include "SingleSelectQueryComposer.hxx" |
| #include "module_dba.hxx" |
| #include "sdbcoretools.hxx" |
| #include "CRowSetColumn.hxx" |
| #include "CRowSetDataColumn.hxx" |
| #include "RowSetCache.hxx" |
| #include "core_resource.hrc" |
| #include "core_resource.hxx" |
| #include "tablecontainer.hxx" |
| |
| /** === begin UNO includes === **/ |
| #include <com/sun/star/beans/PropertyAttribute.hpp> |
| #include <com/sun/star/container/XChild.hpp> |
| #include <com/sun/star/lang/DisposedException.hpp> |
| #include <com/sun/star/sdb/CommandType.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/XDataSource.hpp> |
| #include <com/sun/star/sdbc/XDriverAccess.hpp> |
| #include <com/sun/star/sdbcx/CompareBookmark.hpp> |
| #include <com/sun/star/sdbcx/Privilege.hpp> |
| #include <com/sun/star/sdbcx/XDataDefinitionSupplier.hpp> |
| #include <com/sun/star/uno/XNamingService.hpp> |
| #include <com/sun/star/util/XNumberFormatsSupplier.hpp> |
| /** === end UNO includes === **/ |
| |
| #include <comphelper/componentcontext.hxx> |
| #include <comphelper/extract.hxx> |
| #include <comphelper/interaction.hxx> |
| #include <comphelper/property.hxx> |
| #include <comphelper/seqstream.hxx> |
| #include <comphelper/sequence.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/typeprovider.hxx> |
| #include <rtl/logfile.hxx> |
| #include <unotools/syslocale.hxx> |
| #include <tools/debug.hxx> |
| #include <tools/diagnose_ex.h> |
| #include <unotools/configmgr.hxx> |
| |
| using namespace utl; |
| 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" void SAL_CALL createRegistryInfo_ORowSet() |
| { |
| static ::dba::OAutoRegistration< ORowSet > aAutoRegistration; |
| } |
| // ----------------------------------------------------------------------------- |
| |
| #define NOTIFY_LISTERNERS_CHECK(_rListeners,T,method) \ |
| Sequence< Reference< XInterface > > aListenerSeq = _rListeners.getElements(); \ |
| \ |
| const Reference< XInterface >* pxIntBegin = aListenerSeq.getConstArray(); \ |
| const Reference< XInterface >* pxInt = pxIntBegin + aListenerSeq.getLength(); \ |
| \ |
| _rGuard.clear(); \ |
| sal_Bool bCheck = sal_True; \ |
| while( pxInt > pxIntBegin && bCheck ) \ |
| { \ |
| try \ |
| { \ |
| while( pxInt > pxIntBegin && bCheck ) \ |
| { \ |
| --pxInt; \ |
| bCheck = static_cast< T* >( pxInt->get() )->method(aEvt); \ |
| } \ |
| } \ |
| catch( RuntimeException& ) \ |
| { \ |
| } \ |
| } \ |
| _rGuard.reset(); |
| |
| |
| //.................................................................. |
| namespace dbaccess |
| { |
| //.................................................................. |
| //-------------------------------------------------------------------------- |
| Reference< XInterface > ORowSet_CreateInstance(const Reference< XMultiServiceFactory >& _rxFactory) |
| { |
| return *(new ORowSet(_rxFactory)); |
| } |
| //-------------------------------------------------------------------------- |
| ORowSet::ORowSet( const Reference< ::com::sun::star::lang::XMultiServiceFactory >& _rxORB ) |
| :ORowSet_BASE1(m_aMutex) |
| ,ORowSetBase( _rxORB, ORowSet_BASE1::rBHelper, &m_aMutex ) |
| ,m_pParameters( NULL ) |
| ,m_aRowsetListeners(*m_pMutex) |
| ,m_aApproveListeners(*m_pMutex) |
| ,m_aRowsChangeListener(*m_pMutex) |
| ,m_pTables(NULL) |
| ,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_nInAppend(0) |
| ,m_bUseEscapeProcessing(sal_True) |
| ,m_bApplyFilter(sal_False) |
| ,m_bCommandFacetsDirty( sal_True ) |
| ,m_bModified(sal_False) |
| ,m_bRebuildConnOnExecute(sal_False) |
| ,m_bIsBookmarable(sal_True) |
| ,m_bNew(sal_False) |
| ,m_bCanUpdateInsertedRows(sal_True) |
| ,m_bOwnConnection(sal_False) |
| { |
| m_nResultSetType = ResultSetType::SCROLL_SENSITIVE; |
| m_nResultSetConcurrency = ResultSetConcurrency::UPDATABLE; |
| m_pMySelf = this; |
| m_aActiveConnection <<= m_xActiveConnection; |
| |
| sal_Int32 nRBT = PropertyAttribute::READONLY | PropertyAttribute::BOUND | PropertyAttribute::TRANSIENT; |
| sal_Int32 nRT = PropertyAttribute::READONLY | PropertyAttribute::TRANSIENT; |
| sal_Int32 nBT = PropertyAttribute::BOUND | PropertyAttribute::TRANSIENT; |
| |
| m_aPrematureParamValues.get().resize( 0 ); |
| |
| // sdb.RowSet Properties |
| registerMayBeVoidProperty(PROPERTY_ACTIVE_CONNECTION,PROPERTY_ID_ACTIVE_CONNECTION, PropertyAttribute::MAYBEVOID|PropertyAttribute::TRANSIENT|PropertyAttribute::BOUND, &m_aActiveConnection, ::getCppuType(reinterpret_cast< Reference< XConnection >* >(NULL))); |
| registerProperty(PROPERTY_DATASOURCENAME, PROPERTY_ID_DATASOURCENAME, PropertyAttribute::BOUND, &m_aDataSourceName, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); |
| registerProperty(PROPERTY_COMMAND, PROPERTY_ID_COMMAND, PropertyAttribute::BOUND, &m_aCommand, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); |
| registerProperty(PROPERTY_COMMAND_TYPE, PROPERTY_ID_COMMAND_TYPE, PropertyAttribute::BOUND, &m_nCommandType, ::getCppuType(reinterpret_cast< sal_Int32*>(NULL))); |
| registerProperty(PROPERTY_ACTIVECOMMAND, PROPERTY_ID_ACTIVECOMMAND, nRBT, &m_aActiveCommand, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); |
| registerProperty(PROPERTY_IGNORERESULT, PROPERTY_ID_IGNORERESULT, PropertyAttribute::BOUND, &m_bIgnoreResult, ::getBooleanCppuType()); |
| registerProperty(PROPERTY_FILTER, PROPERTY_ID_FILTER, PropertyAttribute::BOUND, &m_aFilter, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); |
| registerProperty(PROPERTY_HAVING_CLAUSE, PROPERTY_ID_HAVING_CLAUSE, PropertyAttribute::BOUND, &m_aHavingClause, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); |
| registerProperty(PROPERTY_GROUP_BY, PROPERTY_ID_GROUP_BY, PropertyAttribute::BOUND, &m_aGroupBy, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); |
| registerProperty(PROPERTY_APPLYFILTER, PROPERTY_ID_APPLYFILTER, PropertyAttribute::BOUND, &m_bApplyFilter, ::getBooleanCppuType()); |
| registerProperty(PROPERTY_ORDER, PROPERTY_ID_ORDER, PropertyAttribute::BOUND, &m_aOrder, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); |
| registerProperty(PROPERTY_PRIVILEGES, PROPERTY_ID_PRIVILEGES, nRT, &m_nPrivileges, ::getCppuType(reinterpret_cast< sal_Int32*>(NULL))); |
| registerProperty(PROPERTY_ISMODIFIED, PROPERTY_ID_ISMODIFIED, nBT, &m_bModified, ::getBooleanCppuType()); |
| registerProperty(PROPERTY_ISNEW, PROPERTY_ID_ISNEW, nRBT, &m_bNew, ::getBooleanCppuType()); |
| registerProperty(PROPERTY_SINGLESELECTQUERYCOMPOSER,PROPERTY_ID_SINGLESELECTQUERYCOMPOSER, nRT, &m_xComposer, ::getCppuType(reinterpret_cast< Reference< XSingleSelectQueryComposer >* >(NULL))); |
| |
| // sdbcx.ResultSet Properties |
| registerProperty(PROPERTY_ISBOOKMARKABLE, PROPERTY_ID_ISBOOKMARKABLE, nRT, &m_bIsBookmarable, ::getBooleanCppuType()); |
| registerProperty(PROPERTY_CANUPDATEINSERTEDROWS,PROPERTY_ID_CANUPDATEINSERTEDROWS, nRT, &m_bCanUpdateInsertedRows, ::getBooleanCppuType()); |
| // sdbc.ResultSet Properties |
| registerProperty(PROPERTY_RESULTSETCONCURRENCY, PROPERTY_ID_RESULTSETCONCURRENCY, PropertyAttribute::TRANSIENT, &m_nResultSetConcurrency,::getCppuType(reinterpret_cast< sal_Int32*>(NULL))); |
| registerProperty(PROPERTY_RESULTSETTYPE, PROPERTY_ID_RESULTSETTYPE, PropertyAttribute::TRANSIENT, &m_nResultSetType, ::getCppuType(reinterpret_cast< sal_Int32*>(NULL))); |
| registerProperty(PROPERTY_FETCHDIRECTION, PROPERTY_ID_FETCHDIRECTION, PropertyAttribute::TRANSIENT, &m_nFetchDirection, ::getCppuType(reinterpret_cast< sal_Int32*>(NULL))); |
| registerProperty(PROPERTY_FETCHSIZE, PROPERTY_ID_FETCHSIZE, PropertyAttribute::TRANSIENT, &m_nFetchSize, ::getCppuType(reinterpret_cast< sal_Int32*>(NULL))); |
| |
| // sdbc.RowSet Properties |
| registerProperty(PROPERTY_URL, PROPERTY_ID_URL, 0, &m_aURL, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); |
| registerProperty(PROPERTY_TRANSACTIONISOLATION, PROPERTY_ID_TRANSACTIONISOLATION, PropertyAttribute::TRANSIENT, &m_nTransactionIsolation,::getCppuType(reinterpret_cast< sal_Int32*>(NULL))); |
| registerMayBeVoidProperty(PROPERTY_TYPEMAP, PROPERTY_ID_TYPEMAP, PropertyAttribute::MAYBEVOID|PropertyAttribute::TRANSIENT, &m_aTypeMap, ::getCppuType(reinterpret_cast< Reference< XNameAccess >* >(NULL))); |
| registerProperty(PROPERTY_ESCAPE_PROCESSING,PROPERTY_ID_ESCAPE_PROCESSING, PropertyAttribute::BOUND, &m_bUseEscapeProcessing,::getBooleanCppuType() ); |
| registerProperty(PROPERTY_QUERYTIMEOUT, PROPERTY_ID_QUERYTIMEOUT, PropertyAttribute::TRANSIENT, &m_nQueryTimeOut, ::getCppuType(reinterpret_cast< sal_Int32*>(NULL))); |
| registerProperty(PROPERTY_MAXFIELDSIZE, PROPERTY_ID_MAXFIELDSIZE, PropertyAttribute::TRANSIENT, &m_nMaxFieldSize, ::getCppuType(reinterpret_cast< sal_Int32*>(NULL))); |
| registerProperty(PROPERTY_MAXROWS, PROPERTY_ID_MAXROWS, 0, &m_nMaxRows, ::getCppuType(reinterpret_cast< sal_Int32*>(NULL)) ); |
| registerProperty(PROPERTY_USER, PROPERTY_ID_USER, PropertyAttribute::TRANSIENT, &m_aUser, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); |
| registerProperty(PROPERTY_PASSWORD, PROPERTY_ID_PASSWORD, PropertyAttribute::TRANSIENT, &m_aPassword, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); |
| |
| registerProperty(PROPERTY_UPDATE_CATALOGNAME, PROPERTY_ID_UPDATE_CATALOGNAME, PropertyAttribute::BOUND, &m_aUpdateCatalogName, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); |
| registerProperty(PROPERTY_UPDATE_SCHEMANAME, PROPERTY_ID_UPDATE_SCHEMANAME, PropertyAttribute::BOUND, &m_aUpdateSchemaName, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); |
| registerProperty(PROPERTY_UPDATE_TABLENAME, PROPERTY_ID_UPDATE_TABLENAME, PropertyAttribute::BOUND, &m_aUpdateTableName, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); |
| } |
| |
| ORowSet::~ORowSet() |
| { |
| if ( !m_rBHelper.bDisposed && !m_rBHelper.bInDispose ) |
| { |
| OSL_ENSURE(0, "Please check who doesn't dispose this component!"); |
| osl_incrementInterlockedCount( &m_refCount ); |
| dispose(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ORowSet::getPropertyDefaultByHandle( sal_Int32 _nHandle, Any& _rDefault ) const |
| { |
| switch( _nHandle ) |
| { |
| case PROPERTY_ID_COMMAND_TYPE: |
| _rDefault <<= static_cast<sal_Int32>(CommandType::COMMAND); |
| break; |
| case PROPERTY_ID_IGNORERESULT: |
| _rDefault <<= sal_False; |
| break; |
| case PROPERTY_ID_APPLYFILTER: |
| _rDefault <<= sal_False; |
| break; |
| case PROPERTY_ID_ISMODIFIED: |
| _rDefault <<= sal_False; |
| break; |
| case PROPERTY_ID_ISBOOKMARKABLE: |
| _rDefault <<= sal_True; |
| break; |
| case PROPERTY_ID_CANUPDATEINSERTEDROWS: |
| _rDefault <<= sal_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 <<= sal_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 <<= ::rtl::OUString(); |
| break; |
| } |
| } |
| // ------------------------------------------------------------------------- |
| // typedef ::comphelper::OPropertyArrayUsageHelper<ORowSet> ORowSet_Prop; |
| |
| void SAL_CALL ORowSet::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue) throw (Exception) |
| { |
| switch(nHandle) |
| { |
| case PROPERTY_ID_ISMODIFIED: |
| m_bModified = cppu::any2bool(rValue); |
| break; |
| case PROPERTY_ID_FETCHDIRECTION: |
| if( m_nResultSetType == ResultSetType::FORWARD_ONLY) |
| throw Exception(); // else run through |
| 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 = sal_True; |
| } |
| |
| |
| switch(nHandle) |
| { |
| case PROPERTY_ID_ACTIVE_CONNECTION: |
| // the new connection |
| { |
| Reference< XConnection > xNewConnection(m_aActiveConnection,UNO_QUERY); |
| setActiveConnection(xNewConnection, sal_False); |
| } |
| |
| m_bOwnConnection = sal_False; |
| m_bRebuildConnOnExecute = sal_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 = sal_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.getLength()) |
| { |
| // 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 = sal_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 = sal_True; |
| break; |
| case PROPERTY_ID_TYPEMAP: |
| ::cppu::extractInterface(m_xTypeMap,m_aTypeMap); |
| break; |
| default: |
| break; |
| }; |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::getFastPropertyValue(Any& rValue,sal_Int32 nHandle) const |
| { |
| if(m_pCache) |
| { |
| switch(nHandle) |
| { |
| case PROPERTY_ID_ISMODIFIED: |
| rValue.setValue(&m_bModified,::getCppuBooleanType()); |
| break; |
| case PROPERTY_ID_ISNEW: |
| rValue.setValue(&m_bNew,::getCppuBooleanType()); |
| 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; |
| default: |
| ORowSetBase::getFastPropertyValue(rValue,nHandle); |
| } |
| } |
| } |
| // ------------------------------------------------------------------------- |
| // com::sun::star::XTypeProvider |
| Sequence< Type > SAL_CALL ORowSet::getTypes() throw (RuntimeException) |
| { |
| OTypeCollection aTypes(::getCppuType( (const Reference< XPropertySet > *)0 ), |
| ::getCppuType( (const Reference< XFastPropertySet > *)0 ), |
| ::getCppuType( (const Reference< XMultiPropertySet > *)0 ), |
| ::comphelper::concatSequences(ORowSet_BASE1::getTypes(),ORowSetBase::getTypes())); |
| return aTypes.getTypes(); |
| } |
| // ------------------------------------------------------------------------- |
| Sequence< sal_Int8 > SAL_CALL ORowSet::getImplementationId() throw (RuntimeException) |
| { |
| static OImplementationId * pId = 0; |
| if (! pId) |
| { |
| MutexGuard aGuard( Mutex::getGlobalMutex() ); |
| if (! pId) |
| { |
| static OImplementationId aId; |
| pId = &aId; |
| } |
| } |
| return pId->getImplementationId(); |
| } |
| // ------------------------------------------------------------------------- |
| |
| // com::sun::star::XInterface |
| Any SAL_CALL ORowSet::queryInterface( const Type & rType ) throw (RuntimeException) |
| { |
| return ORowSet_BASE1::queryInterface( rType); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::acquire() throw() |
| { |
| ORowSet_BASE1::acquire(); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::release() throw() |
| { |
| ORowSet_BASE1::release(); |
| } |
| // ------------------------------------------------------------------------- |
| |
| // com::sun::star::XUnoTunnel |
| sal_Int64 SAL_CALL ORowSet::getSomething( const Sequence< sal_Int8 >& rId ) throw(RuntimeException) |
| { |
| if (rId.getLength() == 16 && 0 == rtl_compareMemory(getImplementationId().getConstArray(), rId.getConstArray(), 16 ) ) |
| return reinterpret_cast<sal_Int64>(this); |
| |
| return 0; |
| } |
| // ------------------------------------------------------------------------- |
| // com::sun::star::XAggregation |
| Any SAL_CALL ORowSet::queryAggregation( const Type& rType ) throw(RuntimeException) |
| { |
| Any aRet(ORowSetBase::queryInterface(rType)); |
| if (!aRet.hasValue()) |
| aRet = ORowSet_BASE1::queryAggregation(rType); |
| return aRet; |
| } |
| //------------------------------------------------------------------------------ |
| rtl::OUString ORowSet::getImplementationName_static( ) throw(RuntimeException) |
| { |
| return rtl::OUString::createFromAscii("com.sun.star.comp.dba.ORowSet"); |
| } |
| // ------------------------------------------------------------------------- |
| // ::com::sun::star::XServiceInfo |
| ::rtl::OUString SAL_CALL ORowSet::getImplementationName( ) throw(RuntimeException) |
| { |
| return getImplementationName_static(); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSet::supportsService( const ::rtl::OUString& _rServiceName ) throw(RuntimeException) |
| { |
| return ::comphelper::findValue(getSupportedServiceNames(), _rServiceName, sal_True).getLength() != 0; |
| } |
| //------------------------------------------------------------------------------ |
| Sequence< ::rtl::OUString > ORowSet::getSupportedServiceNames_static( ) throw (RuntimeException) |
| { |
| Sequence< rtl::OUString > aSNS( 5 ); |
| aSNS[0] = SERVICE_SDBC_RESULTSET; |
| aSNS[1] = SERVICE_SDBC_ROWSET; |
| aSNS[2] = SERVICE_SDBCX_RESULTSET; |
| aSNS[3] = SERVICE_SDB_RESULTSET; |
| aSNS[4] = SERVICE_SDB_ROWSET; |
| return aSNS; |
| } |
| // ------------------------------------------------------------------------- |
| Sequence< ::rtl::OUString > SAL_CALL ORowSet::getSupportedServiceNames( ) throw(RuntimeException) |
| { |
| return getSupportedServiceNames_static(); |
| } |
| //------------------------------------------------------------------------------ |
| Reference< XInterface > ORowSet::Create(const Reference< XComponentContext >& _rxContext) |
| { |
| ::comphelper::ComponentContext aContext( _rxContext ); |
| return ORowSet_CreateInstance( aContext.getLegacyServiceFactory() ); |
| } |
| // ------------------------------------------------------------------------- |
| // 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()) |
| { |
| Reference<XEventListener> xEvt; |
| query_aggregation(this,xEvt); |
| xComponent->removeEventListener(xEvt); |
| } |
| |
| m_aActiveConnection = Any(); // the any conatains a reference too |
| if(m_bOwnConnection) |
| ::comphelper::disposeComponent(m_xActiveConnection); |
| m_xActiveConnection = NULL; |
| |
| |
| ORowSetBase::disposing(); |
| } |
| // ------------------------------------------------------------------------- |
| void ORowSet::freeResources( bool _bComplete ) |
| { |
| MutexGuard aGuard(m_aMutex); |
| |
| // free all clones |
| connectivity::OWeakRefArray::iterator aEnd = m_aClones.end(); |
| for (connectivity::OWeakRefArray::iterator i = m_aClones.begin(); aEnd != i; i++) |
| { |
| Reference< XComponent > xComp(i->get(), UNO_QUERY); |
| if (xComp.is()) |
| xComp->dispose(); |
| } |
| m_aClones.clear(); |
| |
| if ( _bComplete ) |
| { |
| // 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 |
| m_xColumns = NULL; |
| if ( m_pColumns ) |
| m_pColumns->disposing(); |
| // dispose the composer to avoid that everbody knows that the querycomposer is eol |
| try { ::comphelper::disposeComponent( m_xComposer ); } |
| catch(Exception&) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| m_xComposer = NULL; |
| } |
| |
| // let our warnings container forget the reference to the (possibly disposed) old result set |
| m_aWarnings.setExternalWarnings( NULL ); |
| |
| DELETEZ(m_pCache); |
| |
| impl_resetTables_nothrow(); |
| |
| m_xStatement = NULL; |
| m_xTypeMap = NULL; |
| |
| m_aBookmark = Any(); |
| m_bBeforeFirst = sal_True; |
| m_bAfterLast = sal_False; |
| m_bNew = sal_False; |
| m_bModified = sal_False; |
| m_bIsInsertRow = sal_False; |
| m_bLastKnownRowCountFinal = sal_False; |
| m_nLastKnownRowCount = 0; |
| if ( m_aOldRow.isValid() ) |
| m_aOldRow->clearRow(); |
| |
| impl_disposeParametersContainer_nothrow(); |
| |
| m_bCommandFacetsDirty = sal_True; |
| } |
| } |
| |
| // ------------------------------------------------------------------------- |
| void ORowSet::setActiveConnection( Reference< XConnection >& _rxNewConn, sal_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()) |
| { |
| Reference<XEventListener> xListener; |
| query_aggregation(this, xListener); |
| xComponent->removeEventListener(xListener); |
| } |
| |
| // 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, sal_False); |
| |
| // register as event listener for the new connection |
| xComponent.set(m_xActiveConnection,UNO_QUERY); |
| if (xComponent.is()) |
| { |
| Reference<XEventListener> xListener; |
| query_aggregation(this, xListener); |
| xComponent->addEventListener(xListener); |
| } |
| } |
| |
| // ------------------------------------------------------------------------- |
| // ::com::sun::star::XEventListener |
| void SAL_CALL ORowSet::disposing( const ::com::sun::star::lang::EventObject& Source ) throw(RuntimeException) |
| { |
| // 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( ) throw(SQLException, RuntimeException) |
| { |
| { |
| MutexGuard aGuard( m_aMutex ); |
| ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); |
| } |
| // additionals 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() |
| { |
| typedef ::comphelper::OPropertyArrayUsageHelper<ORowSet> ORowSet_PROP; |
| return *ORowSet_PROP::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)->get()); |
| ORowSetNotifier aNotify(this,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 ) throw(SQLException, RuntimeException) |
| { |
| ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); |
| |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkUpdateConditions(columnIndex); |
| checkUpdateIterator(); |
| |
| ORowSetValueVector::Vector& rRow = ((*m_aCurrentRow)->get()); |
| ORowSetNotifier aNotify(this,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 ) throw(SQLException, RuntimeException) |
| { |
| updateValue(columnIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::updateByte( sal_Int32 columnIndex, sal_Int8 x ) throw(SQLException, RuntimeException) |
| { |
| updateValue(columnIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::updateShort( sal_Int32 columnIndex, sal_Int16 x ) throw(SQLException, RuntimeException) |
| { |
| updateValue(columnIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::updateInt( sal_Int32 columnIndex, sal_Int32 x ) throw(SQLException, RuntimeException) |
| { |
| updateValue(columnIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::updateLong( sal_Int32 columnIndex, sal_Int64 x ) throw(SQLException, RuntimeException) |
| { |
| updateValue(columnIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::updateFloat( sal_Int32 columnIndex, float x ) throw(SQLException, RuntimeException) |
| { |
| updateValue(columnIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::updateDouble( sal_Int32 columnIndex, double x ) throw(SQLException, RuntimeException) |
| { |
| updateValue(columnIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::updateString( sal_Int32 columnIndex, const ::rtl::OUString& x ) throw(SQLException, RuntimeException) |
| { |
| updateValue(columnIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::updateBytes( sal_Int32 columnIndex, const Sequence< sal_Int8 >& x ) throw(SQLException, RuntimeException) |
| { |
| updateValue(columnIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::updateDate( sal_Int32 columnIndex, const ::com::sun::star::util::Date& x ) throw(SQLException, RuntimeException) |
| { |
| updateValue(columnIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::updateTime( sal_Int32 columnIndex, const ::com::sun::star::util::Time& x ) throw(SQLException, RuntimeException) |
| { |
| updateValue(columnIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::updateTimestamp( sal_Int32 columnIndex, const ::com::sun::star::util::DateTime& x ) throw(SQLException, RuntimeException) |
| { |
| updateValue(columnIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::updateBinaryStream( sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException) |
| { |
| ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkUpdateConditions(columnIndex); |
| checkUpdateIterator(); |
| |
| //if(((*m_aCurrentRow)->get())[columnIndex].getTypeKind() == DataType::BLOB) |
| //{ |
| // ::connectivity::ORowSetValue aOldValue = ((*m_aCurrentRow)->get())[columnIndex]; |
| // m_pCache->updateBinaryStream(columnIndex,x,length); |
| // ((*m_aCurrentRow)->get())[columnIndex] = makeAny(x); |
| // ((*m_aCurrentRow)->get())[columnIndex].setTypeKind(DataType::BLOB); |
| // firePropertyChange(columnIndex-1 ,aOldValue); |
| // fireProperty(PROPERTY_ID_ISMODIFIED,sal_True,sal_False); |
| //} |
| //else |
| { |
| Sequence<sal_Int8> aSeq; |
| if(x.is()) |
| x->readBytes(aSeq,length); |
| updateValue(columnIndex,aSeq); |
| } |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::updateCharacterStream( sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException) |
| { |
| ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkUpdateConditions(columnIndex); |
| checkUpdateIterator(); |
| ORowSetValueVector::Vector& rRow = ((*m_aCurrentRow)->get()); |
| ORowSetNotifier aNotify(this,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 ) throw(SQLException, RuntimeException) |
| { |
| ::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)->get()); |
| ORowSetNotifier aNotify(this,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 ) throw(SQLException, RuntimeException) |
| { |
| ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkUpdateConditions(columnIndex); |
| checkUpdateIterator(); |
| ORowSetValueVector::Vector& rRow = ((*m_aCurrentRow)->get()); |
| ORowSetNotifier aNotify(this,rRow); |
| m_pCache->updateNumericObject(columnIndex,x,scale,rRow,aNotify.getChangedColumns()); |
| m_bModified = m_bModified || !aNotify.getChangedColumns().empty(); |
| aNotify.firePropertyChange(); |
| } |
| // ------------------------------------------------------------------------- |
| |
| // XResultSetUpdate |
| void SAL_CALL ORowSet::insertRow( ) throw(SQLException, RuntimeException) |
| { |
| ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); |
| // insertRow is not allowd when |
| // standing not on the insert row nor |
| // when the row isn't modified |
| // or the concurency 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 |
| sal_Bool bOld = m_bNew; |
| |
| ORowSetRow aOldValues; |
| if ( !m_aCurrentRow.isNull() ) |
| aOldValues = new ORowSetValueVector( m_aCurrentRow->getBody() ); |
| Sequence<Any> aChangedBookmarks; |
| RowsChangeEvent aEvt(*this,RowChangeAction::INSERT,1,aChangedBookmarks); |
| notifyAllListenersRowBeforeChange(aGuard,aEvt); |
| |
| ::std::vector< Any > aBookmarks; |
| sal_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( sal_False, sal_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(),Sequence<Any>(&(*aBookmarks.begin()),aBookmarks.size())); |
| notifyAllListenersRowChanged(aGuard,aUpEvt); |
| } |
| |
| // - IsModified |
| if(!m_bModified) |
| fireProperty(PROPERTY_ID_ISMODIFIED,sal_False,sal_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(); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int32 SAL_CALL ORowSet::getRow( ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| |
| // check if we are inserting a row |
| return (m_pCache && isInsertRow()) ? 0 : ORowSetBase::getRow(); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::updateRow( ) throw(SQLException, RuntimeException) |
| { |
| ::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) |
| { |
| ORowSetRow aOldValues; |
| if ( !m_aCurrentRow.isNull() ) |
| aOldValues = new ORowSetValueVector( m_aCurrentRow->getBody() ); |
| |
| 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 = Sequence<Any>(&(*aBookmarks.begin()),aBookmarks.size()); |
| aEvt.Rows += aBookmarks.size(); |
| m_aBookmark = m_pCache->getBookmark(); |
| m_aCurrentRow = m_pCache->m_aMatrixIter; |
| m_bIsInsertRow = sal_False; |
| if ( m_pCache->m_aMatrixIter != m_pCache->getEnd() && (*m_pCache->m_aMatrixIter).isValid() ) |
| { |
| if ( m_pCache->isResultSetChanged() ) |
| { |
| impl_rebuild_throw(aGuard); |
| } |
| else |
| { |
| m_aOldRow->setRow(new ORowSetValueVector(m_aCurrentRow->getBody())); |
| |
| // notification order |
| // - column values |
| ORowSetBase::firePropertyChange(aOldValues); |
| } |
| // - rowChanged |
| notifyAllListenersRowChanged(aGuard,aEvt); |
| |
| // - IsModified |
| if(!m_bModified) |
| fireProperty(PROPERTY_ID_ISMODIFIED,sal_False,sal_True); |
| OSL_ENSURE( !m_bModified, "ORowSet::updateRow: just updated, but _still_ modified?" ); |
| |
| // - RowCount/IsRowCountFinal |
| fireRowcount(); |
| } |
| else if ( !m_bAfterLast ) // the update went rong |
| { |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_UPDATE_FAILED ), SQL_INVALID_CURSOR_POSITION, *this ); |
| } |
| } |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::deleteRow( ) throw(SQLException, RuntimeException) |
| { |
| ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); |
| |
| ::osl::ResettableMutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| |
| if ( m_bBeforeFirst || m_bAfterLast ) |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_NO_DELETE_BEFORE_AFTER ), SQL_INVALID_CURSOR_POSITION, *this ); |
| if ( m_bNew ) |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_NO_DELETE_INSERT_ROW ), SQL_INVALID_CURSOR_POSITION, *this ); |
| if ( m_nResultSetConcurrency == ResultSetConcurrency::READ_ONLY ) |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_RESULT_IS_READONLY ), SQL_FUNCTION_SEQUENCE_ERROR, *this ); |
| if ( ( m_pCache->m_nPrivileges & Privilege::DELETE ) != Privilege::DELETE ) |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_NO_DELETE_PRIVILEGE ), SQL_FUNCTION_SEQUENCE_ERROR, *this ); |
| if ( rowDeleted() ) |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_ROW_ALREADY_DELETED ), SQL_FUNCTION_SEQUENCE_ERROR, *this ); |
| |
| // this call position the cache indirect |
| Any aBookmarkToDelete( m_aBookmark ); |
| positionCache( MOVE_NONE_REFRESH_ONLY ); |
| sal_Int32 nDeletePosition = m_pCache->getRow(); |
| |
| notifyRowSetAndClonesRowDelete( aBookmarkToDelete ); |
| |
| ORowSetRow aOldValues; |
| if ( m_pCache->m_aMatrixIter != m_pCache->getEnd() && m_pCache->m_aMatrixIter->isValid() ) |
| aOldValues = new ORowSetValueVector( m_pCache->m_aMatrixIter->getBody() ); |
| |
| 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( sal_Bool _bNotifyModified ) SAL_THROW( ( SQLException, RuntimeException ) ) |
| { |
| ::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( MOVE_NONE_REFRESH_ONLY ); |
| |
| ORowSetRow aOldValues; |
| if ( !m_bModified && _bNotifyModified && !m_aCurrentRow.isNull() ) |
| aOldValues = new ORowSetValueVector( m_aCurrentRow->getBody() ); |
| |
| m_pCache->cancelRowUpdates(); |
| |
| m_aBookmark = m_pCache->getBookmark(); |
| m_aCurrentRow = m_pCache->m_aMatrixIter; |
| m_bIsInsertRow = sal_False; |
| m_aCurrentRow.setBookmark(m_aBookmark); |
| |
| // notification order |
| // IsModified |
| if( !m_bModified && _bNotifyModified ) |
| { |
| // - column values |
| ORowSetBase::firePropertyChange(aOldValues); |
| fireProperty(PROPERTY_ID_ISMODIFIED,sal_False,sal_True); |
| } |
| } |
| |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::cancelRowUpdates( ) throw(SQLException, RuntimeException) |
| { |
| implCancelRowUpdates( sal_True ); |
| } |
| |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::addRowSetListener( const Reference< XRowSetListener >& listener ) throw(RuntimeException) |
| { |
| ::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 ) throw(RuntimeException) |
| { |
| ::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, (EventObject)aEvt ); |
| m_aRowsChangeListener.notifyEach( &XRowsChangeListener::rowsChanged, aEvt ); |
| _rGuard.reset(); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool ORowSet::notifyAllListenersCursorBeforeMove(::osl::ResettableMutexGuard& _rGuard) |
| { |
| EventObject aEvt(*m_pMySelf); |
| NOTIFY_LISTERNERS_CHECK(m_aApproveListeners,XRowSetApproveListener,approveCursorMove); |
| return bCheck; |
| } |
| // ------------------------------------------------------------------------- |
| void ORowSet::notifyAllListenersRowBeforeChange(::osl::ResettableMutexGuard& _rGuard,const RowChangeEvent &aEvt) |
| { |
| NOTIFY_LISTERNERS_CHECK(m_aApproveListeners,XRowSetApproveListener,approveRowChange); |
| if ( !bCheck ) |
| m_aErrors.raiseTypedException( sdb::ErrorCondition::ROW_SET_OPERATION_VETOED, *this, ::cppu::UnoType< RowSetVetoException >::get() ); |
| } |
| // ------------------------------------------------------------------------- |
| void ORowSet::fireRowcount() |
| { |
| sal_Int32 nCurrentRowCount( impl_getRowCount() ); |
| sal_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,sal_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,sal_False); |
| m_bLastKnownRowCountFinal = bCurrentRowCountFinal; |
| } |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::moveToInsertRow( ) throw(SQLException, RuntimeException) |
| { |
| ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); |
| |
| ::osl::ResettableMutexGuard aGuard( *m_pMutex ); |
| checkPositioningAllowed(); |
| if ( ( m_pCache->m_nPrivileges & Privilege::INSERT ) != Privilege::INSERT ) |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_NO_INSERT_PRIVILEGE ), SQL_GENERAL_ERROR, *this ); |
| |
| if ( notifyAllListenersCursorBeforeMove( aGuard ) ) |
| { |
| // remember old value for fire |
| ORowSetRow aOldValues; |
| if ( rowDeleted() ) |
| { |
| positionCache( MOVE_FORWARD ); |
| m_pCache->next(); |
| setCurrentRow( sal_True, sal_False, aOldValues, aGuard); |
| } |
| else |
| positionCache( MOVE_NONE_REFRESH_ONLY ); |
| |
| // check before because the resultset could be empty |
| if ( !m_bBeforeFirst |
| && !m_bAfterLast |
| && m_pCache->m_aMatrixIter != m_pCache->getEnd() |
| && m_pCache->m_aMatrixIter->isValid() |
| ) |
| aOldValues = new ORowSetValueVector( m_pCache->m_aMatrixIter->getBody() ); |
| |
| const sal_Bool bNewState = m_bNew; |
| const sal_Bool bModState = m_bModified; |
| |
| m_pCache->moveToInsertRow(); |
| m_aCurrentRow = m_pCache->m_aInsertRow; |
| m_bIsInsertRow = sal_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(); |
| TDataColumns::iterator aIter = m_aDataColumns.begin(); |
| m_aReadOnlyDataColumns.resize(m_aDataColumns.size(),false); |
| ::std::bit_vector::iterator aReadIter = m_aReadOnlyDataColumns.begin(); |
| for(;aIter != m_aDataColumns.end();++aIter,++aReadIter) |
| { |
| sal_Bool bReadOnly = sal_False; |
| (*aIter)->getPropertyValue(PROPERTY_ISREADONLY) >>= bReadOnly; |
| *aReadIter = bReadOnly; |
| |
| (*aIter)->setPropertyValue(PROPERTY_ISREADONLY,makeAny(sal_False)); |
| } |
| } |
| // ------------------------------------------------------------------------- |
| void ORowSet::impl_restoreDataColumnsWriteable_throw() |
| { |
| TDataColumns::iterator aIter = m_aDataColumns.begin(); |
| ::std::bit_vector::iterator aReadIter = m_aReadOnlyDataColumns.begin(); |
| for(;aReadIter != m_aReadOnlyDataColumns.end();++aIter,++aReadIter) |
| { |
| (*aIter)->setPropertyValue(PROPERTY_ISREADONLY,makeAny((sal_Bool)*aReadIter )); |
| } |
| m_aReadOnlyDataColumns.clear(); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::moveToCurrentRow( ) throw(SQLException, RuntimeException) |
| { |
| ::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( DBACORE_RESSTRING( RID_STR_ROW_ALREADY_DELETED ), SQL_FUNCTION_SEQUENCE_ERROR, *this ); |
| |
| if ( notifyAllListenersCursorBeforeMove( aGuard ) ) |
| { |
| positionCache( MOVE_NONE_REFRESH_ONLY ); |
| |
| ORowSetNotifier aNotifier( this ); |
| |
| // notification order |
| // - cursorMoved |
| notifyAllListenersCursorMoved(aGuard); |
| |
| // - IsModified |
| // - IsNew |
| aNotifier.fire(); |
| } |
| } |
| // ------------------------------------------------------------------------- |
| // XRow |
| sal_Bool SAL_CALL ORowSet::wasNull( ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| checkCache(); |
| |
| return ( m_pCache && isInsertRow() ) ? ((*m_pCache->m_aInsertRow)->get())[m_nLastColumnIndex].isNull() : ORowSetBase::wasNull(); |
| } |
| // ----------------------------------------------------------------------------- |
| const ORowSetValue& ORowSet::getInsertValue(sal_Int32 columnIndex) |
| { |
| checkCache(); |
| |
| if ( m_pCache && isInsertRow() ) |
| return ((*m_pCache->m_aInsertRow)->get())[m_nLastColumnIndex = columnIndex]; |
| |
| return getValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| ::rtl::OUString SAL_CALL ORowSet::getString( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getInsertValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORowSet::getBoolean( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getInsertValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int8 SAL_CALL ORowSet::getByte( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getInsertValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int16 SAL_CALL ORowSet::getShort( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getInsertValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int32 SAL_CALL ORowSet::getInt( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getInsertValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int64 SAL_CALL ORowSet::getLong( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getInsertValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| float SAL_CALL ORowSet::getFloat( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getInsertValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| double SAL_CALL ORowSet::getDouble( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getInsertValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| Sequence< sal_Int8 > SAL_CALL ORowSet::getBytes( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getInsertValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| ::com::sun::star::util::Date SAL_CALL ORowSet::getDate( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getInsertValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| ::com::sun::star::util::Time SAL_CALL ORowSet::getTime( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getInsertValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| ::com::sun::star::util::DateTime SAL_CALL ORowSet::getTimestamp( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getInsertValue(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| Reference< ::com::sun::star::io::XInputStream > SAL_CALL ORowSet::getBinaryStream( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| if ( m_pCache && isInsertRow() ) |
| { |
| checkCache(); |
| return new ::comphelper::SequenceInputStream(((*m_pCache->m_aInsertRow)->get())[m_nLastColumnIndex = columnIndex].getSequence()); |
| } |
| |
| return ORowSetBase::getBinaryStream(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| Reference< ::com::sun::star::io::XInputStream > SAL_CALL ORowSet::getCharacterStream( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| if(m_pCache && isInsertRow() ) |
| { |
| checkCache(); |
| return new ::comphelper::SequenceInputStream(((*m_pCache->m_aInsertRow)->get())[m_nLastColumnIndex = columnIndex].getSequence()); |
| } |
| |
| return ORowSetBase::getCharacterStream(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| Any SAL_CALL ORowSet::getObject( sal_Int32 columnIndex, const Reference< XNameAccess >& /*typeMap*/ ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( *m_pMutex ); |
| return getInsertValue(columnIndex).makeAny(); |
| } |
| // ------------------------------------------------------------------------- |
| Reference< XRef > SAL_CALL ORowSet::getRef( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException) |
| { |
| return Reference< XRef >(); |
| } |
| // ------------------------------------------------------------------------- |
| Reference< XBlob > SAL_CALL ORowSet::getBlob( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| if ( m_pCache && isInsertRow() ) |
| { |
| checkCache(); |
| return new ::connectivity::BlobHelper(((*m_pCache->m_aInsertRow)->get())[m_nLastColumnIndex = columnIndex].getSequence()); |
| } |
| return ORowSetBase::getBlob(columnIndex); |
| } |
| // ------------------------------------------------------------------------- |
| Reference< XClob > SAL_CALL ORowSet::getClob( sal_Int32 columnIndex ) throw(SQLException, RuntimeException) |
| { |
| return Reference< XClob >(getInsertValue(columnIndex).makeAny(),UNO_QUERY); |
| } |
| // ------------------------------------------------------------------------- |
| Reference< XArray > SAL_CALL ORowSet::getArray( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException) |
| { |
| return Reference< XArray >(); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::executeWithCompletion( const Reference< XInteractionHandler >& _rxHandler ) throw(SQLException, RuntimeException) |
| { |
| 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 = sal_False; |
| |
| Reference< XSingleSelectQueryComposer > xComposer = getCurrentSettingsComposer( this, m_aContext.getLegacyServiceFactory() ); |
| 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() < (size_t)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&) |
| { |
| DBG_ERROR("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( ) throw (RuntimeException) |
| { |
| ::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.get() && m_aCommand.getLength() ) |
| { |
| try |
| { |
| ::rtl::OUString sNotInterestedIn; |
| impl_initComposer_throw( sNotInterestedIn ); |
| } |
| catch( const Exception& ) |
| { |
| // silence it |
| } |
| } |
| |
| return m_pParameters.get(); |
| } |
| |
| // ------------------------------------------------------------------------- |
| void ORowSet::approveExecution() throw (RowSetVetoException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( m_aColumnsMutex ); |
| EventObject aEvt(*this); |
| |
| OInterfaceIteratorHelper aApproveIter( m_aApproveListeners ); |
| while ( aApproveIter.hasMoreElements() ) |
| { |
| Reference< XRowSetApproveListener > xListener( static_cast< XRowSetApproveListener* >( aApproveIter.next() ) ); |
| try |
| { |
| if ( xListener.is() && !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(); |
| } |
| } |
| } |
| // ------------------------------------------------------------------------- |
| // XRowSet |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::execute( ) throw(SQLException, RuntimeException) |
| { |
| ::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(NULL); |
| m_bRebuildConnOnExecute = sal_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# / 2005-02-10 / frank.schoenheit@sun.com |
| sal_Bool bRespectDriverRST = sal_False; |
| Any aSetting; |
| if ( getDataSourceSetting( ::dbaccess::getDataSource( m_xActiveConnection ), "RespectDriverResultSetType", aSetting ) ) |
| { |
| OSL_VERIFY( aSetting >>= bRespectDriverRST ); |
| } |
| |
| if ( bRespectDriverRST ) |
| { |
| // try type/concurrency settings with decreasing usefullness, 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, makeAny( nResultSetType ) ); |
| _rxStatement->setPropertyValue( PROPERTY_RESULTSETCONCURRENCY, makeAny( nResultSetConcurrency ) ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| Reference< XResultSet > ORowSet::impl_prepareAndExecute_throw() |
| { |
| ::rtl::OUString sCommandToExecute; |
| sal_Bool bUseEscapeProcessing = impl_initComposer_throw( sCommandToExecute ); |
| |
| Reference< XResultSet> xResultSet; |
| try |
| { |
| m_xStatement = m_xActiveConnection->prepareStatement( sCommandToExecute ); |
| if ( !m_xStatement.is() ) |
| { |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_INTERNAL_ERROR ), SQL_GENERAL_ERROR, *this ); |
| } |
| |
| Reference< XPropertySet > xStatementProps( m_xStatement, UNO_QUERY_THROW ); |
| // set the result set type and concurrency |
| try |
| { |
| xStatementProps->setPropertyValue( PROPERTY_USEBOOKMARKS, makeAny( sal_True ) ); |
| xStatementProps->setPropertyValue( PROPERTY_MAXROWS, makeAny( 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 |
| } |
| m_aParameterValueForCache.get().resize(1); |
| Reference< XParameters > xParam( m_xStatement, UNO_QUERY_THROW ); |
| size_t nParamCount( m_pParameters.is() ? m_pParameters->size() : m_aPrematureParamValues.get().size() ); |
| for ( size_t i=1; i<=nParamCount; ++i ) |
| { |
| ORowSetValue& rParamValue( getParameterStorage( (sal_Int32)i ) ); |
| ::dbtools::setObjectWithInfo( xParam, i, rParamValue.makeAny(), rParamValue.getTypeKind() ); |
| m_aParameterValueForCache.get().push_back(rParamValue); |
| } |
| |
| xResultSet = m_xStatement->executeQuery(); |
| } |
| catch( const SQLException& ) |
| { |
| SQLExceptionInfo aError( ::cppu::getCaughtException() ); |
| OSL_ENSURE( aError.isValid(), "ORowSet::impl_prepareAndExecute_throw: caught an SQLException which we cannot analyze!" ); |
| |
| // append information about what we were actually going to execute |
| try |
| { |
| String sQuery = bUseEscapeProcessing && m_xComposer.is() ? m_xComposer->getQuery() : m_aActiveCommand; |
| String sInfo( DBA_RES_PARAM( RID_STR_COMMAND_LEADING_TO_ERROR, "$command$", sQuery ) ); |
| aError.append( SQLExceptionInfo::SQL_CONTEXT, sInfo ); |
| } |
| catch( const Exception& ) { DBG_UNHANDLED_EXCEPTION(); } |
| |
| // propagate |
| aError.doThrow(); |
| } |
| |
| 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_QUERY_THROW ); |
| |
| // a number of properties is plain copied |
| const ::rtl::OUString aPropertyNames[] = { |
| PROPERTY_ALIGN, PROPERTY_RELATIVEPOSITION, PROPERTY_WIDTH, PROPERTY_HIDDEN, PROPERTY_CONTROLMODEL, |
| PROPERTY_HELPTEXT, PROPERTY_CONTROLDEFAULT |
| }; |
| for ( size_t i=0; i<sizeof( aPropertyNames ) / sizeof( aPropertyNames[0] ); ++i ) |
| { |
| if ( xInfo->hasPropertyByName( aPropertyNames[i] ) ) |
| { |
| _rxRowSetColumn->setPropertyValue( aPropertyNames[i], _rxTemplateColumn->getPropertyValue( aPropertyNames[i] ) ); |
| 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().GetLocaleData().getLocale() ); |
| _rxRowSetColumn->setPropertyValue( PROPERTY_NUMBERFORMAT, makeAny( nFormatKey ) ); |
| } |
| catch(Exception&) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| 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 referes to a table column, which we |
| // can use as new template column |
| try |
| { |
| Reference< XPropertySetInfo > xInfo( _rxTemplateColumn->getPropertySetInfo(), UNO_QUERY_THROW ); |
| if ( !xInfo->hasPropertyByName( PROPERTY_TABLENAME ) ) |
| // no chance |
| return; |
| |
| ::rtl::OUString sTableName; |
| OSL_VERIFY( _rxTemplateColumn->getPropertyValue( PROPERTY_TABLENAME ) >>= sTableName ); |
| |
| Reference< XNameAccess > xTables( impl_getTables_throw(), UNO_QUERY_THROW ); |
| if ( !xTables->hasByName( sTableName ) ) |
| // no chance |
| return; |
| |
| Reference< XColumnsSupplier > xTableColSup( xTables->getByName( sTableName ), UNO_QUERY_THROW ); |
| Reference< XNameAccess > xTableCols( xTableColSup->getColumns(), UNO_QUERY_THROW ); |
| |
| ::rtl::OUString sTableColumnName; |
| |
| // get the "Name" or (preferred) "RealName" property of the column |
| ::rtl::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(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ORowSet::execute_NoApprove_NoNewConn(ResettableMutexGuard& _rClearForNotification) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "frank.schoenheit@sun.com", "ORowSet::execute_NoApprove_NoNewConn" ); |
| |
| // now we can dispose our old connection |
| ::comphelper::disposeComponent(m_xOldConnection); |
| m_xOldConnection = NULL; |
| |
| // do we need a new statement |
| if ( m_bCommandFacetsDirty ) |
| { |
| m_xStatement = NULL; |
| m_xComposer = NULL; |
| |
| Reference< XResultSet > xResultSet( impl_prepareAndExecute_throw() ); |
| |
| // let our warnings container forget the reference to the (possibly disposed) old result set |
| m_aWarnings.setExternalWarnings( NULL ); |
| // 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 ) ); |
| |
| ::rtl::OUString aComposedUpdateTableName; |
| if ( m_aUpdateTableName.getLength() ) |
| aComposedUpdateTableName = composeTableName( m_xActiveConnection->getMetaData(), m_aUpdateCatalogName, m_aUpdateSchemaName, m_aUpdateTableName, sal_False, ::dbtools::eInDataManipulation ); |
| |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "frank.schoenheit@sun.com", "ORowSet::execute_NoApprove_NoNewConn: creating cache" ); |
| m_pCache = new 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 = sal_False; |
| m_aOldRow = m_pCache->registerOldRow(); |
| } |
| |
| // get the locale |
| // ConfigManager* pConfigMgr = ConfigManager::GetConfigManager(); |
| Locale aLocale = SvtSysLocale().GetLocaleData().getLocale(); |
| // pConfigMgr->GetDirectConfigProperty(ConfigManager::LOCALE) >>= aLocale; |
| |
| // get the numberformatTypes |
| OSL_ENSURE(m_xActiveConnection.is(),"No ActiveConnection"); |
| Reference< XNumberFormatTypes> xNumberFormatTypes; |
| Reference< XNumberFormatsSupplier> xNumberFormat = ::dbtools::getNumberFormats(m_xActiveConnection); |
| if ( xNumberFormat.is() ) |
| m_xNumberFormatTypes.set(xNumberFormat->getNumberFormats(),UNO_QUERY); |
| |
| ::vos::ORef< ::connectivity::OSQLColumns> aColumns = new ::connectivity::OSQLColumns(); |
| ::std::vector< ::rtl::OUString> aNames; |
| ::rtl::OUString aDescription; |
| sal_Int32 nFormatKey = 0; |
| |
| const ::std::map<sal_Int32,sal_Int32>& rKeyColumns = m_pCache->getKeyColumns(); |
| if(!m_xColumns.is()) |
| { |
| RTL_LOGFILE_CONTEXT_AUTHOR( aColumnCreateLog, "dbaccess", "frank.schoenheit@sun.com", "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->get().reserve(nCount+1); |
| DECLARE_STL_USTRINGACCESS_MAP(int,StringMap); |
| StringMap aColumnMap; |
| for (sal_Int32 i = 0 ; i < nCount; ++i) |
| { |
| // retrieve the name of the column |
| ::rtl::OUString sName = xMetaData->getColumnName(i + 1); |
| // check for duplicate entries |
| if(aColumnMap.find(sName) != aColumnMap.end()) |
| { |
| ::rtl::OUString sAlias(sName); |
| sal_Int32 searchIndex=1; |
| while(aColumnMap.find(sAlias) != aColumnMap.end()) |
| { |
| (sAlias = sName) += ::rtl::OUString::valueOf(searchIndex++); |
| } |
| sName = sAlias; |
| } |
| ORowSetDataColumn* pColumn = new ORowSetDataColumn( getMetaData(), |
| this, |
| this, |
| i+1, |
| m_xActiveConnection->getMetaData(), |
| aDescription, |
| ::rtl::OUString(), |
| m_aCurrentRow); |
| aColumnMap.insert(StringMap::value_type(sName,0)); |
| aColumns->get().push_back(pColumn); |
| pColumn->setName(sName); |
| aNames.push_back(sName); |
| m_aDataColumns.push_back(pColumn); |
| |
| pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_ISREADONLY,makeAny(rKeyColumns.find(i+1) != rKeyColumns.end())); |
| |
| try |
| { |
| nFormatKey = 0; |
| if(m_xNumberFormatTypes.is()) |
| nFormatKey = ::dbtools::getDefaultNumberFormat(pColumn,m_xNumberFormatTypes,aLocale); |
| |
| |
| pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_NUMBERFORMAT,makeAny(nFormatKey)); |
| pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_RELATIVEPOSITION,makeAny(sal_Int32(i+1))); |
| pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_WIDTH,makeAny(sal_Int32(227))); |
| pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_ALIGN,makeAny((sal_Int32)0)); |
| pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_HIDDEN,::cppu::bool2any(sal_False)); |
| } |
| catch(Exception&) |
| { |
| } |
| } |
| } |
| } |
| catch (SQLException&) |
| { |
| } |
| } |
| else |
| { |
| // create the rowset columns |
| Reference< XResultSetMetaData > xMeta( getMetaData(), UNO_QUERY_THROW ); |
| sal_Int32 nCount = xMeta->getColumnCount(); |
| m_aDataColumns.reserve(nCount+1); |
| aColumns->get().reserve(nCount+1); |
| ::std::set< Reference< XPropertySet > > aAllColumns; |
| |
| for(sal_Int32 i=1; i <= nCount ;++i) |
| { |
| ::rtl::OUString sName = xMeta->getColumnName(i); |
| ::rtl::OUString sColumnLabel = xMeta->getColumnLabel(i); |
| |
| // retrieve the column number |i| |
| Reference<XPropertySet> xColumn; |
| { |
| sal_Bool bReFetchName = sal_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 = NULL; |
| bReFetchName = sal_True; |
| sColumnLabel = ::rtl::OUString(); |
| } |
| if(!xColumn.is()) |
| { |
| // no column found so we could look at the position i |
| //bReFetchName = sal_True; |
| //sColumnLabel = ::rtl::OUString(); |
| Reference<XIndexAccess> xIndexAccess(m_xColumns,UNO_QUERY); |
| if(xIndexAccess.is() && i <= xIndexAccess->getCount()) |
| { |
| xIndexAccess->getByIndex(i-1) >>= xColumn; |
| } |
| else |
| { |
| Sequence< ::rtl::OUString> aSeq = m_xColumns->getElementNames(); |
| if( i <= aSeq.getLength()) |
| { |
| m_xColumns->getByName(aSeq.getConstArray()[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)); |
| |
| ::rtl::OUString sParseLabel; |
| if ( xColumn.is() ) |
| { |
| xColumn->getPropertyValue(PROPERTY_LABEL) >>= sParseLabel; |
| } |
| ORowSetDataColumn* pColumn = new ORowSetDataColumn( getMetaData(), |
| this, |
| this, |
| i, |
| m_xActiveConnection->getMetaData(), |
| aDescription, |
| sParseLabel, |
| m_aCurrentRow); |
| aColumns->get().push_back(pColumn); |
| |
| pColumn->setFastPropertyValue_NoBroadcast(PROPERTY_ID_ISREADONLY,makeAny(rKeyColumns.find(i) != rKeyColumns.end())); |
| |
| if(!sColumnLabel.getLength()) |
| { |
| if(xColumn.is()) |
| xColumn->getPropertyValue(PROPERTY_NAME) >>= sColumnLabel; |
| else |
| sColumnLabel = DBACORE_RESSTRING( RID_STR_EXPRESSION1 ); |
| } |
| pColumn->setName(sColumnLabel); |
| aNames.push_back(sColumnLabel); |
| m_aDataColumns.push_back(pColumn); |
| |
| 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 = new ORowSetDataColumns(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers(), |
| aColumns,*this,m_aColumnsMutex,aNames); |
| } |
| } |
| checkCache(); |
| // notify the rowset listeners |
| notifyAllListeners(_rClearForNotification); |
| } |
| // ------------------------------------------------------------------------- |
| // XRowSetApproveBroadcaster |
| void SAL_CALL ORowSet::addRowSetApproveListener( const Reference< XRowSetApproveListener >& listener ) throw(RuntimeException) |
| { |
| ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); |
| |
| ::osl::MutexGuard aGuard( m_aColumnsMutex ); |
| |
| m_aApproveListeners.addInterface(listener); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::removeRowSetApproveListener( const Reference< XRowSetApproveListener >& listener ) throw(RuntimeException) |
| { |
| ::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 ) throw(RuntimeException) |
| { |
| ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); |
| |
| ::osl::MutexGuard aGuard( m_aColumnsMutex ); |
| |
| m_aRowsChangeListener.addInterface(listener); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::removeRowsChangeListener( const Reference< XRowsChangeListener >& listener ) throw(RuntimeException) |
| { |
| ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); |
| |
| ::osl::MutexGuard aGuard( m_aColumnsMutex ); |
| |
| m_aRowsChangeListener.removeInterface(listener); |
| } |
| // ------------------------------------------------------------------------- |
| |
| // XResultSetAccess |
| Reference< XResultSet > SAL_CALL ORowSet::createResultSet( ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( m_aColumnsMutex ); |
| |
| if(m_xStatement.is()) |
| { |
| ORowSetClone* pClone = new ORowSetClone( m_aContext, *this, m_pMutex ); |
| Reference< XResultSet > xRet(pClone); |
| m_aClones.push_back(WeakReferenceHelper(xRet)); |
| return xRet; |
| } |
| return Reference< XResultSet >(); |
| } |
| // ------------------------------------------------------------------------- |
| |
| // ::com::sun::star::util::XCancellable |
| void SAL_CALL ORowSet::cancel( ) throw(RuntimeException) |
| { |
| ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); |
| } |
| // ------------------------------------------------------------------------- |
| |
| // ::com::sun::star::sdbcx::XDeleteRows |
| Sequence< sal_Int32 > SAL_CALL ORowSet::deleteRows( const Sequence< Any >& rows ) throw(SQLException, RuntimeException) |
| { |
| ::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() ); |
| const Any* row = rows.getConstArray(); |
| const Any* rowEnd = rows.getConstArray() + rows.getLength(); |
| sal_Int32* result = aResults.getArray(); |
| for ( ; row != rowEnd; ++row, ++result ) |
| { |
| *result = 0; |
| if ( !m_pCache->moveToBookmark( *row ) ) |
| continue; |
| sal_Int32 nDeletePosition = m_pCache->getRow(); |
| |
| // first notify the clones so that they can save their position |
| notifyRowSetAndClonesRowDelete( *row ); |
| |
| // now delete the row |
| if ( !m_pCache->deleteRow() ) |
| continue; |
| *result = 1; |
| // now notify that we have deleted |
| notifyRowSetAndClonesRowDeleted( *row, 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 |
| connectivity::OWeakRefArray::iterator aEnd = m_aClones.end(); |
| for (connectivity::OWeakRefArray::iterator i = m_aClones.begin(); aEnd != i; i++) |
| { |
| Reference< XUnoTunnel > xTunnel(i->get(),UNO_QUERY); |
| if(xTunnel.is()) |
| { |
| ORowSetClone* pClone = reinterpret_cast<ORowSetClone*>(xTunnel->getSomething(ORowSetClone::getUnoTunnelImplementationId())); |
| if(pClone) |
| pClone->onDeleteRow( _rBookmark ); |
| } |
| } |
| } |
| //------------------------------------------------------------------------------ |
| void ORowSet::notifyRowSetAndClonesRowDeleted( const Any& _rBookmark, sal_Int32 _nPos ) |
| { |
| // notify ourself |
| onDeletedRow( _rBookmark, _nPos ); |
| // notify the clones |
| connectivity::OWeakRefArray::iterator aEnd = m_aClones.end(); |
| for (connectivity::OWeakRefArray::iterator i = m_aClones.begin(); aEnd != i; i++) |
| { |
| Reference< XUnoTunnel > xTunnel(i->get(),UNO_QUERY); |
| if(xTunnel.is()) |
| { |
| ORowSetClone* pClone = reinterpret_cast<ORowSetClone*>(xTunnel->getSomething(ORowSetClone::getUnoTunnelImplementationId())); |
| if(pClone) |
| pClone->onDeletedRow( _rBookmark, _nPos ); |
| } |
| } |
| } |
| //------------------------------------------------------------------------------ |
| Reference< XConnection > ORowSet::calcConnection(const Reference< XInteractionHandler >& _rxHandler) throw( SQLException, RuntimeException ) |
| { |
| MutexGuard aGuard(m_aMutex); |
| if (!m_xActiveConnection.is()) |
| { |
| Reference< XConnection > xNewConn; |
| if ( m_aDataSourceName.getLength() ) |
| { |
| Reference< XNameAccess > xDatabaseContext( |
| m_aContext.createComponent( (::rtl::OUString)SERVICE_SDB_DATABASECONTEXT ), |
| UNO_QUERY_THROW ); |
| 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& e ) |
| { |
| throw; |
| } |
| catch ( const Exception& e ) |
| { |
| Any aError = ::cppu::getCaughtException(); |
| ::rtl::OUString sMessage = ResourceManager::loadString( RID_NO_SUCH_DATA_SOURCE, |
| "$name$", m_aDataSourceName, "$error$", extractExceptionMessage( m_aContext, aError ) ); |
| ::dbtools::throwGenericSQLException( sMessage, *this ); |
| } |
| } |
| setActiveConnection(xNewConn); |
| m_bOwnConnection = sal_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_QUERY_THROW ); |
| } |
| else if ( m_pTables ) |
| { |
| xTables = m_pTables; |
| } |
| else |
| { |
| if ( !m_xActiveConnection.is() ) |
| throw SQLException(DBA_RES(RID_STR_CONNECTION_INVALID),*this,SQLSTATE_GENERAL,1000,Any() ); |
| |
| sal_Bool bCase = sal_True; |
| try |
| { |
| Reference<XDatabaseMetaData> xMeta = m_xActiveConnection->getMetaData(); |
| bCase = xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers(); |
| } |
| catch(SQLException&) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| |
| m_pTables = new OTableContainer(*this,m_aMutex,m_xActiveConnection,bCase,NULL,NULL,NULL,m_nInAppend); |
| xTables = m_pTables; |
| Sequence< ::rtl::OUString> aTableFilter(1); |
| aTableFilter[0] = ::rtl::OUString::createFromAscii("%"); |
| m_pTables->construct(aTableFilter,Sequence< ::rtl::OUString>()); |
| } |
| |
| return xTables; |
| } |
| |
| //------------------------------------------------------------------------------ |
| void ORowSet::impl_resetTables_nothrow() |
| { |
| if ( !m_pTables ) |
| return; |
| |
| try |
| { |
| m_pTables->dispose(); |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| |
| DELETEZ( m_pTables ); |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Bool ORowSet::impl_initComposer_throw( ::rtl::OUString& _out_rCommandToExecute ) |
| { |
| sal_Bool bUseEscapeProcessing = impl_buildActiveCommand_throw( ); |
| _out_rCommandToExecute = m_aActiveCommand; |
| if ( !bUseEscapeProcessing ) |
| return bUseEscapeProcessing; |
| |
| Reference< XMultiServiceFactory > xFactory( m_xActiveConnection, UNO_QUERY ); |
| if ( xFactory.is() ) |
| { |
| try |
| { |
| ::comphelper::disposeComponent( m_xComposer ); |
| m_xComposer.set( xFactory->createInstance( SERVICE_NAME_SINGLESELECTQUERYCOMPOSER ), UNO_QUERY_THROW ); |
| } |
| catch (const Exception& ) { m_xComposer = NULL; } |
| } |
| 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 : ::rtl::OUString() ); |
| m_xComposer->setHavingClause( m_bApplyFilter ? m_aHavingClause : ::rtl::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 paramters (since a keyset may add parameters itself) |
| // 2003-12-12 - #23418# - fs@openoffice.org |
| m_xComposer->setElementaryQuery( m_xComposer->getQuery( ) ); |
| m_xComposer->setFilter( ::rtl::OUString::createFromAscii( "0 = 1" ) ); |
| } |
| |
| 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(); |
| |
| return bUseEscapeProcessing; |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_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 |
| sal_Bool bDoEscapeProcessing = m_bUseEscapeProcessing; |
| |
| m_aActiveCommand = ::rtl::OUString(); |
| ::rtl::OUString sCommand; |
| |
| if ( !m_aCommand.getLength() ) |
| return bDoEscapeProcessing; |
| |
| switch (m_nCommandType) |
| { |
| case CommandType::TABLE: |
| { |
| impl_resetTables_nothrow(); |
| if ( bDoEscapeProcessing ) |
| { |
| Reference< XNameAccess > xTables( impl_getTables_throw() ); |
| if ( xTables->hasByName(m_aCommand) ) |
| { |
| /* |
| Reference< XPropertySet > xTable; |
| try |
| { |
| xTables->getByName( m_aCommand ) >>= xTable; |
| } |
| catch(const WrappedTargetException& e) |
| { |
| SQLException e2; |
| if ( e.TargetException >>= e2 ) |
| throw e2; |
| } |
| catch(Exception&) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| |
| Reference<XColumnsSupplier> xSup(xTable,UNO_QUERY); |
| if ( xSup.is() ) |
| m_xColumns = xSup->getColumns(); |
| |
| sCommand = rtl::OUString::createFromAscii("SELECT * FROM "); |
| ::rtl::OUString sCatalog, sSchema, sTable; |
| ::dbtools::qualifiedNameComponents( m_xActiveConnection->getMetaData(), m_aCommand, sCatalog, sSchema, sTable, ::dbtools::eInDataManipulation ); |
| sCommand += ::dbtools::composeTableNameForSelect( m_xActiveConnection, sCatalog, sSchema, sTable ); |
| */ |
| } |
| else |
| { |
| String sMessage( DBACORE_RESSTRING( RID_STR_TABLE_DOES_NOT_EXIST ) ); |
| sMessage.SearchAndReplaceAscii( "$table$", m_aCommand ); |
| throwGenericSQLException(sMessage,*this); |
| } |
| } |
| else |
| { |
| sCommand = rtl::OUString::createFromAscii("SELECT * FROM "); |
| ::rtl::OUString sCatalog, sSchema, sTable; |
| ::dbtools::qualifiedNameComponents( m_xActiveConnection->getMetaData(), m_aCommand, sCatalog, sSchema, sTable, ::dbtools::eInDataManipulation ); |
| sCommand += ::dbtools::composeTableNameForSelect( m_xActiveConnection, sCatalog, sSchema, sTable ); |
| } |
| } |
| break; |
| |
| case CommandType::QUERY: |
| { |
| Reference< XQueriesSupplier > xQueriesAccess(m_xActiveConnection, UNO_QUERY); |
| if (xQueriesAccess.is()) |
| { |
| Reference< ::com::sun::star::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 ) |
| { |
| sal_Bool bOldValue = m_bUseEscapeProcessing; |
| m_bUseEscapeProcessing = bDoEscapeProcessing; |
| fireProperty(PROPERTY_ID_ESCAPE_PROCESSING,bOldValue,bDoEscapeProcessing); |
| } |
| |
| ::rtl::OUString aCatalog,aSchema,aTable; |
| xQuery->getPropertyValue(PROPERTY_UPDATE_CATALOGNAME) >>= aCatalog; |
| xQuery->getPropertyValue(PROPERTY_UPDATE_SCHEMANAME) >>= aSchema; |
| xQuery->getPropertyValue(PROPERTY_UPDATE_TABLENAME) >>= aTable; |
| if(aTable.getLength()) |
| m_aUpdateTableName = composeTableName( m_xActiveConnection->getMetaData(), aCatalog, aSchema, aTable, sal_False, ::dbtools::eInDataManipulation ); |
| /* |
| Reference<XColumnsSupplier> xSup(xQuery,UNO_QUERY); |
| if(xSup.is()) |
| m_xColumns = xSup->getColumns(); |
| */ |
| } |
| } |
| else |
| { |
| String sMessage( DBACORE_RESSTRING( RID_STR_QUERY_DOES_NOT_EXIST ) ); |
| sMessage.SearchAndReplaceAscii( "$table$", m_aCommand ); |
| throwGenericSQLException(sMessage,*this); |
| } |
| } |
| else |
| throw SQLException(DBA_RES(RID_STR_NO_XQUERIESSUPPLIER),*this,::rtl::OUString(),0,Any()); |
| } |
| break; |
| |
| default: |
| sCommand = m_aCommand; |
| break; |
| } |
| |
| m_aActiveCommand = sCommand; |
| |
| if ( !m_aActiveCommand.getLength() && !bDoEscapeProcessing ) |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_NO_SQL_COMMAND ), SQL_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.get() ); |
| // copy the premature parameters into the final ones |
| size_t nParamCount( ::std::min( m_pParameters->size(), m_aPrematureParamValues.get().size() ) ); |
| for ( size_t i=0; i<nParamCount; ++i ) |
| { |
| (*m_pParameters)[i] = m_aPrematureParamValues.get()[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.get().resize( nParamCount ); |
| for ( size_t i=0; i<nParamCount; ++i ) |
| { |
| m_aPrematureParamValues.get()[i] = (*m_pParameters)[i]; |
| } |
| |
| m_pParameters->dispose(); |
| m_pParameters = NULL; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| ORowSetValue& ORowSet::getParameterStorage(sal_Int32 parameterIndex) |
| { |
| ::connectivity::checkDisposed( ORowSet_BASE1::rBHelper.bDisposed ); |
| if ( parameterIndex < 1 ) |
| throwInvalidIndexException( *this ); |
| |
| if ( m_aParametersSet.size() < (size_t)parameterIndex ) |
| m_aParametersSet.resize( parameterIndex ,false); |
| m_aParametersSet[parameterIndex - 1] = true; |
| |
| if ( m_aParametersSet.size() < (size_t)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 ( (size_t)parameterIndex > m_pParameters->size() ) |
| throwInvalidIndexException( *this ); |
| return (*m_pParameters)[ parameterIndex - 1 ]; |
| } |
| } |
| |
| if ( m_aPrematureParamValues.get().size() < (size_t)parameterIndex ) |
| m_aPrematureParamValues.get().resize( parameterIndex ); |
| return m_aPrematureParamValues.get()[ parameterIndex - 1 ]; |
| } |
| // ------------------------------------------------------------------------- |
| // XParameters |
| void SAL_CALL ORowSet::setNull( sal_Int32 parameterIndex, sal_Int32 /*sqlType*/ ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( m_aColumnsMutex ); |
| |
| getParameterStorage( parameterIndex ).setNull(); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setObjectNull( sal_Int32 parameterIndex, sal_Int32 sqlType, const ::rtl::OUString& /*typeName*/ ) throw(SQLException, RuntimeException) |
| { |
| setNull( parameterIndex, sqlType ); |
| } |
| // ----------------------------------------------------------------------------- |
| void ORowSet::setParameter(sal_Int32 parameterIndex, const ORowSetValue& x) |
| { |
| ::osl::MutexGuard aGuard( m_aColumnsMutex ); |
| |
| getParameterStorage( parameterIndex ) = x; |
| } |
| |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setBoolean( sal_Int32 parameterIndex, sal_Bool x ) throw(SQLException, RuntimeException) |
| { |
| setParameter(parameterIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setByte( sal_Int32 parameterIndex, sal_Int8 x ) throw(SQLException, RuntimeException) |
| { |
| setParameter(parameterIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setShort( sal_Int32 parameterIndex, sal_Int16 x ) throw(SQLException, RuntimeException) |
| { |
| setParameter(parameterIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setInt( sal_Int32 parameterIndex, sal_Int32 x ) throw(SQLException, RuntimeException) |
| { |
| setParameter(parameterIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setLong( sal_Int32 parameterIndex, sal_Int64 x ) throw(SQLException, RuntimeException) |
| { |
| setParameter(parameterIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setFloat( sal_Int32 parameterIndex, float x ) throw(SQLException, RuntimeException) |
| { |
| setParameter(parameterIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setDouble( sal_Int32 parameterIndex, double x ) throw(SQLException, RuntimeException) |
| { |
| setParameter(parameterIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setString( sal_Int32 parameterIndex, const ::rtl::OUString& x ) throw(SQLException, RuntimeException) |
| { |
| setParameter(parameterIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setBytes( sal_Int32 parameterIndex, const Sequence< sal_Int8 >& x ) throw(SQLException, RuntimeException) |
| { |
| setParameter(parameterIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setDate( sal_Int32 parameterIndex, const ::com::sun::star::util::Date& x ) throw(SQLException, RuntimeException) |
| { |
| setParameter(parameterIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setTime( sal_Int32 parameterIndex, const ::com::sun::star::util::Time& x ) throw(SQLException, RuntimeException) |
| { |
| setParameter(parameterIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setTimestamp( sal_Int32 parameterIndex, const ::com::sun::star::util::DateTime& x ) throw(SQLException, RuntimeException) |
| { |
| setParameter(parameterIndex,x); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setBinaryStream( sal_Int32 parameterIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( m_aColumnsMutex ); |
| ORowSetValue& rParamValue( getParameterStorage( parameterIndex ) ); |
| |
| try |
| { |
| Sequence <sal_Int8> aData; |
| x->readBytes(aData, length); |
| rParamValue = aData; |
| x->closeInput(); |
| } |
| catch( Exception& ) |
| { |
| throw SQLException(); |
| } |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setCharacterStream( sal_Int32 parameterIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( m_aColumnsMutex ); |
| ORowSetValue& rParamValue( getParameterStorage( parameterIndex ) ); |
| try |
| { |
| Sequence <sal_Int8> aData; |
| rtl::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 = rtl::OUString((sal_Unicode*)aData.getConstArray(), nSize / sizeof(sal_Unicode)); |
| rParamValue = aDataStr; |
| rParamValue.setTypeKind( DataType::LONGVARCHAR ); |
| x->closeInput(); |
| } |
| catch( Exception& ) |
| { |
| throw SQLException(); |
| } |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setObject( sal_Int32 parameterIndex, const Any& x ) throw(SQLException, RuntimeException) |
| { |
| if ( !::dbtools::implSetObject( this, parameterIndex, x ) ) |
| { // there is no other setXXX call which can handle the value in x |
| throw SQLException(); |
| } |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setObjectWithInfo( sal_Int32 parameterIndex, const Any& x, sal_Int32 targetSqlType, sal_Int32 /*scale*/ ) throw(SQLException, RuntimeException) |
| { |
| ::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*/ ) throw(SQLException, RuntimeException) |
| { |
| ::dbtools::throwFeatureNotImplementedException( "XParameters::setRef", *this ); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setBlob( sal_Int32 /*parameterIndex*/, const Reference< XBlob >& /*x*/ ) throw(SQLException, RuntimeException) |
| { |
| ::dbtools::throwFeatureNotImplementedException( "XParameters::setBlob", *this ); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setClob( sal_Int32 /*parameterIndex*/, const Reference< XClob >& /*x*/ ) throw(SQLException, RuntimeException) |
| { |
| ::dbtools::throwFeatureNotImplementedException( "XParameters::setClob", *this ); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::setArray( sal_Int32 /*parameterIndex*/, const Reference< XArray >& /*x*/ ) throw(SQLException, RuntimeException) |
| { |
| ::dbtools::throwFeatureNotImplementedException( "XParameters::setArray", *this ); |
| } |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::clearParameters( ) throw(SQLException, RuntimeException) |
| { |
| ::connectivity::checkDisposed(ORowSet_BASE1::rBHelper.bDisposed); |
| |
| ::osl::MutexGuard aGuard( m_aColumnsMutex ); |
| |
| size_t nParamCount( m_pParameters.is() ? m_pParameters->size() : m_aPrematureParamValues.get().size() ); |
| for ( size_t i=1; i<=nParamCount; ++i ) |
| getParameterStorage( (sal_Int32)i ).setNull(); |
| m_aParametersSet.clear(); |
| } |
| |
| // ------------------------------------------------------------------------- |
| Any SAL_CALL ORowSet::getWarnings( ) throw (SQLException, RuntimeException) |
| { |
| return m_aWarnings.getWarnings(); |
| } |
| |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::clearWarnings( ) throw (SQLException, RuntimeException) |
| { |
| m_aWarnings.clearWarnings(); |
| } |
| // ----------------------------------------------------------------------------- |
| void ORowSet::doCancelModification( ) |
| { |
| //OSL_ENSURE( isModification(), "ORowSet::doCancelModification: invalid call (no cache!)!" ); |
| if ( isModification() ) |
| { |
| // read-only flag restored |
| impl_restoreDataColumnsWriteable_throw(); |
| m_pCache->cancelRowModification(); |
| } |
| m_bModified = sal_False; |
| m_bIsInsertRow = sal_False; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| sal_Bool ORowSet::isModification( ) |
| { |
| return isNew(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| sal_Bool ORowSet::isModified( ) |
| { |
| return m_bModified; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| sal_Bool ORowSet::isNew( ) |
| { |
| return m_bNew; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ORowSet::checkUpdateIterator() |
| { |
| if(!m_bIsInsertRow) |
| { |
| m_pCache->setUpdateIterator(m_aCurrentRow); |
| m_aCurrentRow = m_pCache->m_aInsertRow; |
| m_bIsInsertRow = sal_True; |
| } |
| } |
| // ----------------------------------------------------------------------------- |
| void ORowSet::checkUpdateConditions(sal_Int32 columnIndex) |
| { |
| checkCache(); |
| if ( m_nResultSetConcurrency == ResultSetConcurrency::READ_ONLY) |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_RESULT_IS_READONLY ), SQL_GENERAL_ERROR, *this ); |
| |
| if ( rowDeleted() ) |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_ROW_ALREADY_DELETED ), SQL_INVALID_CURSOR_POSITION, *this ); |
| |
| if ( m_aCurrentRow.isNull() ) |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_INVALID_CURSOR_STATE ), SQL_INVALID_CURSOR_STATE, *this ); |
| |
| if ( columnIndex <= 0 || sal_Int32((*m_aCurrentRow)->get().size()) <= columnIndex ) |
| ::dbtools::throwSQLException( DBACORE_RESSTRING( RID_STR_INVALID_INDEX ), SQL_INVALID_DESCRIPTOR_INDEX, *this ); |
| } |
| // ----------------------------------------------------------------------------- |
| void SAL_CALL ORowSet::refreshRow( ) throw(SQLException, RuntimeException) |
| { |
| |
| ORowSetNotifier aNotifier( this ); |
| // this will call cancelRowModification on the cache if necessary |
| |
| // notification order: |
| if ( m_bModified && m_pCache ) |
| implCancelRowUpdates( sal_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_aWarnings.setExternalWarnings( Reference< XWarningsSupplier >( xResultSet, UNO_QUERY ) ); |
| m_pCache->reset(xResultSet); |
| notifyAllListeners(_rGuard); |
| } |
| // *********************************************************** |
| // ORowSetClone |
| // *********************************************************** |
| DBG_NAME(ORowSetClone); |
| //-------------------------------------------------------------------------- |
| ORowSetClone::ORowSetClone( const ::comphelper::ComponentContext& _rContext, ORowSet& rParent, ::osl::Mutex* _pMutex ) |
| :OSubComponent(m_aMutex, rParent) |
| ,ORowSetBase( _rContext, OComponentHelper::rBHelper, _pMutex ) |
| ,m_pParent(&rParent) |
| ,m_nFetchDirection(rParent.m_nFetchDirection) |
| ,m_nFetchSize(rParent.m_nFetchSize) |
| ,m_bIsBookmarable(sal_True) |
| { |
| DBG_CTOR(ORowSetClone, NULL); |
| |
| m_nResultSetType = rParent.m_nResultSetType; |
| m_nResultSetConcurrency = ResultSetConcurrency::READ_ONLY; |
| m_pMySelf = this; |
| m_bClone = sal_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(); |
| |
| ::vos::ORef< ::connectivity::OSQLColumns> aColumns = new ::connectivity::OSQLColumns(); |
| ::std::vector< ::rtl::OUString> aNames; |
| |
| ::rtl::OUString aDescription; |
| // ConfigManager* pConfigMgr = ConfigManager::GetConfigManager(); |
| // Locale aLocale; |
| // pConfigMgr->GetDirectConfigProperty(ConfigManager::LOCALE) >>= aLocale; |
| Locale aLocale = SvtSysLocale().GetLocaleData().getLocale(); |
| |
| if ( rParent.m_pColumns ) |
| { |
| Sequence< ::rtl::OUString> aSeq = rParent.m_pColumns->getElementNames(); |
| const ::rtl::OUString* pIter = aSeq.getConstArray(); |
| const ::rtl::OUString* pEnd = pIter + aSeq.getLength(); |
| aColumns->get().reserve(aSeq.getLength()+1); |
| for(sal_Int32 i=1;pIter != pEnd ;++pIter,++i) |
| { |
| Reference<XPropertySet> xColumn; |
| rParent.m_pColumns->getByName(*pIter) >>= xColumn; |
| if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_DESCRIPTION)) |
| aDescription = comphelper::getString(xColumn->getPropertyValue(PROPERTY_DESCRIPTION)); |
| |
| ::rtl::OUString sParseLabel; |
| xColumn->getPropertyValue(PROPERTY_LABEL) >>= sParseLabel; |
| ORowSetColumn* pColumn = new ORowSetColumn( rParent.getMetaData(), |
| this, |
| i, |
| rParent.m_xActiveConnection->getMetaData(), |
| aDescription, |
| sParseLabel, |
| m_aCurrentRow); |
| aColumns->get().push_back(pColumn); |
| pColumn->setName(*pIter); |
| aNames.push_back(*pIter); |
| m_aDataColumns.push_back(pColumn); |
| |
| 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,makeAny(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)); |
| |
| } // for(sal_Int32 i=1;pIter != pEnd ;++pIter,++i) |
| } |
| Reference<XDatabaseMetaData> xMeta = rParent.m_xActiveConnection->getMetaData(); |
| m_pColumns = new ORowSetDataColumns(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers(), |
| aColumns,*this,m_aMutex,aNames); |
| |
| sal_Int32 nRT = PropertyAttribute::READONLY | PropertyAttribute::TRANSIENT; |
| |
| // sdb.RowSet Properties |
| // registerProperty(PROPERTY_CURSORNAME, PROPERTY_ID_CURSORNAME, PropertyAttribute::READONLY, &m_aDataSourceName, ::getCppuType(reinterpret_cast< ::rtl::OUString*>(NULL))); |
| registerMayBeVoidProperty(PROPERTY_ACTIVE_CONNECTION,PROPERTY_ID_ACTIVE_CONNECTION, PropertyAttribute::MAYBEVOID|PropertyAttribute::READONLY, &rParent.m_aActiveConnection, ::getCppuType(reinterpret_cast< Reference< XConnection >* >(NULL))); |
| registerProperty(PROPERTY_RESULTSETCONCURRENCY, PROPERTY_ID_RESULTSETCONCURRENCY, PropertyAttribute::READONLY, &m_nResultSetConcurrency,::getCppuType(reinterpret_cast< sal_Int32*>(NULL))); |
| registerProperty(PROPERTY_RESULTSETTYPE, PROPERTY_ID_RESULTSETTYPE, PropertyAttribute::READONLY, &m_nResultSetType, ::getCppuType(reinterpret_cast< sal_Int32*>(NULL))); |
| registerProperty(PROPERTY_FETCHDIRECTION, PROPERTY_ID_FETCHDIRECTION, PropertyAttribute::TRANSIENT, &m_nFetchDirection, ::getCppuType(reinterpret_cast< sal_Int32*>(NULL))); |
| registerProperty(PROPERTY_FETCHSIZE, PROPERTY_ID_FETCHSIZE, PropertyAttribute::TRANSIENT, &m_nFetchSize, ::getCppuType(reinterpret_cast< sal_Int32*>(NULL))); |
| registerProperty(PROPERTY_ISBOOKMARKABLE, PROPERTY_ID_ISBOOKMARKABLE, nRT, &m_bIsBookmarable, ::getBooleanCppuType()); |
| } |
| |
| //-------------------------------------------------------------------------- |
| ORowSetClone::~ORowSetClone() |
| { |
| DBG_DTOR(ORowSetClone, NULL); |
| } |
| // com::sun::star::XTypeProvider |
| //-------------------------------------------------------------------------- |
| Sequence< Type > ORowSetClone::getTypes() throw (RuntimeException) |
| { |
| return ::comphelper::concatSequences(OSubComponent::getTypes(),ORowSetBase::getTypes()); |
| } |
| // com::sun::star::XInterface |
| //-------------------------------------------------------------------------- |
| Any ORowSetClone::queryInterface( const Type & rType ) throw (RuntimeException) |
| { |
| Any aRet = ORowSetBase::queryInterface(rType); |
| if(!aRet.hasValue()) |
| aRet = OSubComponent::queryInterface(rType); |
| return aRet; |
| } |
| //------------------------------------------------------------------------------ |
| void ORowSetClone::acquire() throw() |
| { |
| OSubComponent::acquire(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void ORowSetClone::release() throw() |
| { |
| OSubComponent::release(); |
| } |
| |
| // XServiceInfo |
| //------------------------------------------------------------------------------ |
| rtl::OUString ORowSetClone::getImplementationName( ) throw(RuntimeException) |
| { |
| return rtl::OUString::createFromAscii("com.sun.star.sdb.ORowSetClone"); |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Bool ORowSetClone::supportsService( const ::rtl::OUString& _rServiceName ) throw (RuntimeException) |
| { |
| return ::comphelper::findValue(getSupportedServiceNames(), _rServiceName, sal_True).getLength() != 0; |
| } |
| |
| //------------------------------------------------------------------------------ |
| Sequence< ::rtl::OUString > ORowSetClone::getSupportedServiceNames( ) throw (RuntimeException) |
| { |
| Sequence< ::rtl::OUString > aSNS( 2 ); |
| aSNS[0] = SERVICE_SDBC_RESULTSET; |
| aSNS[1] = SERVICE_SDB_RESULTSET; |
| return aSNS; |
| } |
| |
| // OComponentHelper |
| //------------------------------------------------------------------------------ |
| void ORowSetClone::disposing() |
| { |
| MutexGuard aGuard( m_aMutex ); |
| ORowSetBase::disposing(); |
| |
| m_pParent = NULL; |
| m_pMutex = &m_aMutex; // this must be done here because someone could hold a ref to us and try to do something |
| OSubComponent::disposing(); |
| } |
| |
| // XCloseable |
| //------------------------------------------------------------------------------ |
| void ORowSetClone::close(void) throw( SQLException, RuntimeException ) |
| { |
| { |
| MutexGuard aGuard( m_aMutex ); |
| if (OComponentHelper::rBHelper.bDisposed) |
| throw DisposedException(); |
| } |
| 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() |
| { |
| typedef ::comphelper::OPropertyArrayUsageHelper<ORowSetClone> ORowSetClone_PROP; |
| return *ORowSetClone_PROP::getArrayHelper(); |
| } |
| // ------------------------------------------------------------------------- |
| //-------------------------------------------------------------------------- |
| Sequence< sal_Int8 > ORowSetClone::getUnoTunnelImplementationId() |
| { |
| static ::cppu::OImplementationId * pId = 0; |
| if (! pId) |
| { |
| ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() ); |
| if (! pId) |
| { |
| static ::cppu::OImplementationId aId; |
| pId = &aId; |
| } |
| } |
| return pId->getImplementationId(); |
| } |
| // ----------------------------------------------------------------------------- |
| // com::sun::star::XUnoTunnel |
| sal_Int64 SAL_CALL ORowSetClone::getSomething( const Sequence< sal_Int8 >& rId ) throw(RuntimeException) |
| { |
| if (rId.getLength() == 16 && 0 == rtl_compareMemory(getUnoTunnelImplementationId().getConstArray(), rId.getConstArray(), 16 ) ) |
| return reinterpret_cast<sal_Int64>(this); |
| |
| return 0; |
| } |
| // ----------------------------------------------------------------------------- |
| void SAL_CALL ORowSetClone::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue) throw (Exception) |
| { |
| if ( nHandle == PROPERTY_ID_FETCHSIZE ) |
| { |
| if ( m_pParent ) |
| m_pParent->setFastPropertyValue_NoBroadcast( nHandle, rValue ); |
| } |
| |
| OPropertyStateContainer::setFastPropertyValue_NoBroadcast(nHandle,rValue); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ORowSetClone::doCancelModification( ) |
| { |
| //OSL_ENSURE( sal_False, "ORowSetClone::doCancelModification: invalid call!" ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| sal_Bool ORowSetClone::isModification( ) |
| { |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| sal_Bool ORowSetClone::isModified( ) |
| { |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| sal_Bool ORowSetClone::isNew( ) |
| { |
| return sal_False; |
| } |
| |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSetClone::execute( ) throw(SQLException, RuntimeException) |
| { |
| throwFunctionNotSupportedException( "RowSetClone::XRowSet::execute", *this ); |
| } |
| |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSetClone::addRowSetListener( const Reference< XRowSetListener >& ) throw(RuntimeException) |
| { |
| throwFunctionNotSupportedException( "RowSetClone::XRowSet", *this ); |
| } |
| |
| // ------------------------------------------------------------------------- |
| void SAL_CALL ORowSetClone::removeRowSetListener( const Reference< XRowSetListener >& ) throw(RuntimeException) |
| { |
| throwFunctionNotSupportedException( "RowSetClone::XRowSet", *this ); |
| } |
| |
| } // dbaccess |