strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/dbaccess/source/core/api/resultset.cxx
Jens-Heiner Rechtien b97fb0c560 INTEGRATION: CWS dba23c (1.18.114); FILE MERGED 
2007/07/18 09:41:12 fs 1.18.114.2: assertion for the case just fixed
2007/07/18 06:32:04 oj 1.18.114.1: #147849# check bookmark a little bit more
2007-07-31 13:01:15 +00:00

1084 lines
39 KiB
C++
Raw Blame History

/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: resultset.cxx,v $
*
* $Revision: 1.19 $
*
* last change: $Author: hr $ $Date: 2007-07-31 14:01:15 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_dbaccess.hxx"
#ifndef _DBA_COREAPI_RESULTSET_HXX_
#include <resultset.hxx>
#endif
#ifndef DBACCESS_SHARED_DBASTRINGS_HRC
#include "dbastrings.hrc"
#endif
#ifndef _DBASHARED_APITOOLS_HXX_
#include "apitools.hxx"
#endif
#ifndef _COM_SUN_STAR_LANG_DISPOSEDEXCEPTION_HPP_
#include <com/sun/star/lang/DisposedException.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBC_RESULTSETTYPE_HPP_
#include <com/sun/star/sdbc/ResultSetType.hpp>
#endif
#ifndef _CPPUHELPER_TYPEPROVIDER_HXX_
#include <cppuhelper/typeprovider.hxx>
#endif
#ifndef _COMPHELPER_PROPERTY_HXX_
#include <comphelper/property.hxx>
#endif
#ifndef _COMPHELPER_SEQUENCE_HXX_
#include <comphelper/sequence.hxx>
#endif
#ifndef _COMPHELPER_TYPES_HXX_
#include <comphelper/types.hxx>
#endif
#ifndef _TOOLS_DEBUG_HXX //autogen
#include <tools/debug.hxx>
#endif
#ifndef TOOLS_DIAGNOSE_EX_H
#include <tools/diagnose_ex.h>
#endif
#ifndef _DBA_COREAPI_DATACOLUMN_HXX_
#include <datacolumn.hxx>
#endif
#ifndef _COM_SUN_STAR_BEANS_PROPERTYATTRIBUTE_HPP_
#include <com/sun/star/beans/PropertyAttribute.hpp>
#endif
#ifndef _DBHELPER_DBEXCEPTION_HXX_
#include <connectivity/dbexception.hxx>
#endif
#ifndef _CPPUHELPER_EXC_HLP_HXX_
#include <cppuhelper/exc_hlp.hxx>
#endif
#ifndef _OSL_THREAD_H_
#include <osl/thread.h>
#endif
using namespace ::com::sun::star::sdbc;
using namespace ::com::sun::star::sdbcx;
//using namespace ::com::sun::star::sdb;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::cppu;
using namespace ::osl;
using namespace dbaccess;
using namespace dbtools;
DBG_NAME(OResultSet)
//--------------------------------------------------------------------------
OResultSet::OResultSet(const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XResultSet >& _xResultSet,
const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& _xStatement,
sal_Bool _bCaseSensitive)
:OResultSetBase(m_aMutex)
,OPropertySetHelper(OResultSetBase::rBHelper)
,m_xDelegatorResultSet(_xResultSet)
,m_aWarnings( Reference< XWarningsSupplier >( _xResultSet, UNO_QUERY ) )
,m_bIsBookmarkable(sal_False)
{
DBG_CTOR(OResultSet, NULL);
m_pColumns = new OColumns(*this, m_aMutex, _bCaseSensitive, ::std::vector< ::rtl::OUString>(), NULL,NULL);
try
{
m_aStatement = _xStatement;
m_xDelegatorResultSetUpdate = m_xDelegatorResultSetUpdate.query( m_xDelegatorResultSet );
m_xDelegatorRow = m_xDelegatorRow.query( m_xDelegatorResultSet );
m_xDelegatorRowUpdate = m_xDelegatorRowUpdate.query( m_xDelegatorResultSet );
Reference< XPropertySet > xSet(m_xDelegatorResultSet, UNO_QUERY);
xSet->getPropertyValue(PROPERTY_RESULTSETTYPE) >>= m_nResultSetType;
xSet->getPropertyValue(PROPERTY_RESULTSETCONCURRENCY) >>= m_nResultSetConcurrency;
// test for Bookmarks
if (ResultSetType::FORWARD_ONLY != m_nResultSetType)
{
Reference <XPropertySetInfo > xInfo(xSet->getPropertySetInfo());
if (xInfo->hasPropertyByName(PROPERTY_ISBOOKMARKABLE))
{
m_bIsBookmarkable = ::comphelper::getBOOL(xSet->getPropertyValue(PROPERTY_ISBOOKMARKABLE));
OSL_ENSURE( !m_bIsBookmarkable || Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY).is(),
"OResultSet::OResultSet: aggregate is inconsistent in it's bookmarkable attribute!" );
m_bIsBookmarkable = m_bIsBookmarkable && Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY).is();
}
}
}
catch(Exception&)
{
}
}
//--------------------------------------------------------------------------
OResultSet::~OResultSet()
{
m_pColumns->acquire();
m_pColumns->disposing();
delete m_pColumns;
DBG_DTOR(OResultSet, NULL);
}
// com::sun::star::lang::XTypeProvider
//--------------------------------------------------------------------------
Sequence< Type > OResultSet::getTypes() throw (RuntimeException)
{
OTypeCollection aTypes(::getCppuType( (const Reference< XPropertySet > *)0 ),
OResultSetBase::getTypes());
return aTypes.getTypes();
}
//--------------------------------------------------------------------------
Sequence< sal_Int8 > OResultSet::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::uno::XInterface
//--------------------------------------------------------------------------
Any OResultSet::queryInterface( const Type & rType ) throw (RuntimeException)
{
Any aIface = OResultSetBase::queryInterface( rType );
if (!aIface.hasValue())
aIface = ::cppu::queryInterface(
rType,
static_cast< XPropertySet * >( this ));
return aIface;
}
//--------------------------------------------------------------------------
void OResultSet::acquire() throw ()
{
OResultSetBase::acquire();
}
//--------------------------------------------------------------------------
void OResultSet::release() throw ()
{
OResultSetBase::release();
}
// OResultSetBase
//------------------------------------------------------------------------------
void OResultSet::disposing()
{
OPropertySetHelper::disposing();
MutexGuard aGuard(m_aMutex);
// free the columns
m_pColumns->disposing();
// close the pending result set
Reference< XCloseable > (m_xDelegatorResultSet, UNO_QUERY)->close();
m_xDelegatorResultSet = NULL;
m_xDelegatorRow = NULL;
m_xDelegatorRowUpdate = NULL;
m_aStatement = Reference< XInterface >();
}
// XCloseable
//------------------------------------------------------------------------------
void OResultSet::close(void) throw( SQLException, RuntimeException )
{
{
MutexGuard aGuard( m_aMutex );
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
}
dispose();
}
// XServiceInfo
//------------------------------------------------------------------------------
rtl::OUString OResultSet::getImplementationName( ) throw(RuntimeException)
{
return rtl::OUString::createFromAscii("com.sun.star.sdb.OResultSet");
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::supportsService( const ::rtl::OUString& _rServiceName ) throw (RuntimeException)
{
return ::comphelper::findValue(getSupportedServiceNames(), _rServiceName, sal_True).getLength() != 0;
}
//------------------------------------------------------------------------------
Sequence< ::rtl::OUString > OResultSet::getSupportedServiceNames( ) throw (RuntimeException)
{
Sequence< ::rtl::OUString > aSNS( 2 );
aSNS[0] = SERVICE_SDBC_RESULTSET;
aSNS[1] = SERVICE_SDB_RESULTSET;
return aSNS;
}
// com::sun::star::beans::XPropertySet
//------------------------------------------------------------------------------
Reference< XPropertySetInfo > OResultSet::getPropertySetInfo() throw (RuntimeException)
{
return createPropertySetInfo( getInfoHelper() ) ;
}
// comphelper::OPropertyArrayUsageHelper
//------------------------------------------------------------------------------
::cppu::IPropertyArrayHelper* OResultSet::createArrayHelper( ) const
{
BEGIN_PROPERTY_HELPER(6)
DECL_PROP1(CURSORNAME, ::rtl::OUString, READONLY);
DECL_PROP0(FETCHDIRECTION, sal_Int32);
DECL_PROP0(FETCHSIZE, sal_Int32);
DECL_PROP1_BOOL(ISBOOKMARKABLE, READONLY);
DECL_PROP1(RESULTSETCONCURRENCY, sal_Int32, READONLY);
DECL_PROP1(RESULTSETTYPE, sal_Int32, READONLY);
END_PROPERTY_HELPER();
}
// cppu::OPropertySetHelper
//------------------------------------------------------------------------------
::cppu::IPropertyArrayHelper& OResultSet::getInfoHelper()
{
return *getArrayHelper();
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::convertFastPropertyValue(Any & rConvertedValue, Any & rOldValue, sal_Int32 nHandle, const Any& rValue ) throw( IllegalArgumentException )
{
// be lazy ...
rConvertedValue = rValue;
getFastPropertyValue( rOldValue, nHandle );
return sal_True;
}
//------------------------------------------------------------------------------
void OResultSet::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const Any& rValue ) throw (Exception)
{
// set it for the driver result set
Reference< XPropertySet > xSet(m_xDelegatorResultSet, UNO_QUERY);
switch (nHandle)
{
case PROPERTY_ID_FETCHDIRECTION:
xSet->setPropertyValue(PROPERTY_FETCHDIRECTION, rValue);
break;
case PROPERTY_ID_FETCHSIZE:
xSet->setPropertyValue(PROPERTY_FETCHSIZE, rValue);
break;
default:
DBG_ERROR("unknown Property");
}
}
//------------------------------------------------------------------------------
void OResultSet::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
{
switch (nHandle)
{
case PROPERTY_ID_ISBOOKMARKABLE:
{
sal_Bool bVal = m_bIsBookmarkable;
rValue.setValue(&bVal, getBooleanCppuType());
} break;
default:
{
// get the property name
::rtl::OUString aPropName;
sal_Int16 nAttributes;
const_cast<OResultSet*>(this)->getInfoHelper().
fillPropertyMembersByHandle(&aPropName, &nAttributes, nHandle);
OSL_ENSURE(aPropName.getLength(), "property not found?");
// now read the value
rValue = Reference< XPropertySet >(m_xDelegatorResultSet, UNO_QUERY)->getPropertyValue(aPropName);
}
}
}
// XWarningsSupplier
//------------------------------------------------------------------------------
Any OResultSet::getWarnings(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_aWarnings.getWarnings();
}
//------------------------------------------------------------------------------
void OResultSet::clearWarnings(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
m_aWarnings.clearWarnings();
}
// ::com::sun::star::sdbc::XResultSetMetaDataSupplier
//------------------------------------------------------------------------------
Reference< XResultSetMetaData > OResultSet::getMetaData(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return Reference< XResultSetMetaDataSupplier >(m_xDelegatorResultSet, UNO_QUERY)->getMetaData();
}
// ::com::sun::star::sdbc::XColumnLocate
//------------------------------------------------------------------------------
sal_Int32 OResultSet::findColumn(const rtl::OUString& columnName) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return Reference< XColumnLocate >(m_xDelegatorResultSet, UNO_QUERY)->findColumn(columnName);
}
//------------------------------------------------------------------------------
namespace
{
static Reference< XDatabaseMetaData > lcl_getDBMetaDataFromStatement_nothrow( const Reference< XInterface >& _rxStatement )
{
Reference< XDatabaseMetaData > xDBMetaData;
try
{
Reference< XStatement > xStatement( _rxStatement, UNO_QUERY );
Reference< XPreparedStatement > xPreparedStatement( _rxStatement, UNO_QUERY );
Reference< XConnection > xConn;
if ( xStatement.is() )
xConn = xStatement->getConnection();
else if ( xPreparedStatement.is() )
xConn = xPreparedStatement->getConnection();
if ( xConn.is() )
xDBMetaData = xConn->getMetaData();
}
catch( const Exception& )
{
DBG_UNHANDLED_EXCEPTION();
}
return xDBMetaData;
}
}
// ::com::sun::star::sdbcx::XColumnsSupplier
//------------------------------------------------------------------------------
Reference< ::com::sun::star::container::XNameAccess > OResultSet::getColumns(void) throw( RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
// do we have to populate the columns
if (!m_pColumns->isInitialized())
{
// get the metadata
Reference< XResultSetMetaData > xMetaData = Reference< XResultSetMetaDataSupplier >(m_xDelegatorResultSet, UNO_QUERY)->getMetaData();
// do we have columns
try
{
Reference< XDatabaseMetaData > xDBMetaData( lcl_getDBMetaDataFromStatement_nothrow( getStatement() ) );
for (sal_Int32 i = 0, nCount = xMetaData->getColumnCount(); i < nCount; ++i)
{
// retrieve the name of the column
rtl::OUString aName = xMetaData->getColumnName(i + 1);
ODataColumn* pColumn = new ODataColumn(xMetaData, m_xDelegatorRow, m_xDelegatorRowUpdate, i + 1, xDBMetaData);
m_pColumns->append(aName, pColumn);
}
}
catch (SQLException)
{
}
m_pColumns->setInitialized();
}
return m_pColumns;
}
// ::com::sun::star::sdbc::XRow
//------------------------------------------------------------------------------
sal_Bool OResultSet::wasNull(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->wasNull();
}
//------------------------------------------------------------------------------
rtl::OUString OResultSet::getString(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getString(columnIndex);
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::getBoolean(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getBoolean(columnIndex);
}
//------------------------------------------------------------------------------
sal_Int8 OResultSet::getByte(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getByte(columnIndex);
}
//------------------------------------------------------------------------------
sal_Int16 OResultSet::getShort(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getShort(columnIndex);
}
//------------------------------------------------------------------------------
sal_Int32 OResultSet::getInt(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getInt(columnIndex);
}
//------------------------------------------------------------------------------
sal_Int64 OResultSet::getLong(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getLong(columnIndex);
}
//------------------------------------------------------------------------------
float OResultSet::getFloat(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getFloat(columnIndex);
}
//------------------------------------------------------------------------------
double OResultSet::getDouble(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getDouble(columnIndex);
}
//------------------------------------------------------------------------------
Sequence< sal_Int8 > OResultSet::getBytes(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getBytes(columnIndex);
}
//------------------------------------------------------------------------------
::com::sun::star::util::Date OResultSet::getDate(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getDate(columnIndex);
}
//------------------------------------------------------------------------------
::com::sun::star::util::Time OResultSet::getTime(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getTime(columnIndex);
}
//------------------------------------------------------------------------------
::com::sun::star::util::DateTime OResultSet::getTimestamp(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getTimestamp(columnIndex);
}
//------------------------------------------------------------------------------
Reference< ::com::sun::star::io::XInputStream > OResultSet::getBinaryStream(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getBinaryStream(columnIndex);
}
//------------------------------------------------------------------------------
Reference< ::com::sun::star::io::XInputStream > OResultSet::getCharacterStream(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getCharacterStream(columnIndex);
}
//------------------------------------------------------------------------------
Any OResultSet::getObject(sal_Int32 columnIndex, const Reference< ::com::sun::star::container::XNameAccess > & typeMap) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getObject(columnIndex, typeMap);
}
//------------------------------------------------------------------------------
Reference< XRef > OResultSet::getRef(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getRef(columnIndex);
}
//------------------------------------------------------------------------------
Reference< XBlob > OResultSet::getBlob(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getBlob(columnIndex);
}
//------------------------------------------------------------------------------
Reference< XClob > OResultSet::getClob(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getClob(columnIndex);
}
//------------------------------------------------------------------------------
Reference< XArray > OResultSet::getArray(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorRow->getArray(columnIndex);
}
// ::com::sun::star::sdbc::XRowUpdate
//------------------------------------------------------------------------------
void OResultSet::updateNull(sal_Int32 columnIndex) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateNull(columnIndex);
}
//------------------------------------------------------------------------------
void OResultSet::updateBoolean(sal_Int32 columnIndex, sal_Bool x) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateBoolean(columnIndex, x);
}
//------------------------------------------------------------------------------
void OResultSet::updateByte(sal_Int32 columnIndex, sal_Int8 x) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateByte(columnIndex, x);
}
//------------------------------------------------------------------------------
void OResultSet::updateShort(sal_Int32 columnIndex, sal_Int16 x) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateShort(columnIndex, x);
}
//------------------------------------------------------------------------------
void OResultSet::updateInt(sal_Int32 columnIndex, sal_Int32 x) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateInt(columnIndex, x);
}
//------------------------------------------------------------------------------
void OResultSet::updateLong(sal_Int32 columnIndex, sal_Int64 x) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateLong(columnIndex, x);
}
//------------------------------------------------------------------------------
void OResultSet::updateFloat(sal_Int32 columnIndex, float x) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateFloat(columnIndex, x);
}
//------------------------------------------------------------------------------
void OResultSet::updateDouble(sal_Int32 columnIndex, double x) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateDouble(columnIndex, x);
}
//------------------------------------------------------------------------------
void OResultSet::updateString(sal_Int32 columnIndex, const rtl::OUString& x) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateString(columnIndex, x);
}
//------------------------------------------------------------------------------
void OResultSet::updateBytes(sal_Int32 columnIndex, const Sequence< sal_Int8 >& x) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateBytes(columnIndex, x);
}
//------------------------------------------------------------------------------
void OResultSet::updateDate(sal_Int32 columnIndex, const ::com::sun::star::util::Date& x) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateDate(columnIndex, x);
}
//------------------------------------------------------------------------------
void OResultSet::updateTime(sal_Int32 columnIndex, const ::com::sun::star::util::Time& x) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateTime(columnIndex, x);
}
//------------------------------------------------------------------------------
void OResultSet::updateTimestamp(sal_Int32 columnIndex, const ::com::sun::star::util::DateTime& x) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateTimestamp(columnIndex, x);
}
//------------------------------------------------------------------------------
void OResultSet::updateBinaryStream(sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream > & x, sal_Int32 length) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateBinaryStream(columnIndex, x, length);
}
//------------------------------------------------------------------------------
void OResultSet::updateCharacterStream(sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream > & x, sal_Int32 length) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateCharacterStream(columnIndex, x, length);
}
//------------------------------------------------------------------------------
void OResultSet::updateNumericObject(sal_Int32 columnIndex, const Any& x, sal_Int32 scale) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateNumericObject(columnIndex, x, scale);
}
//------------------------------------------------------------------------------
void OResultSet::updateObject(sal_Int32 columnIndex, const Any& x) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorRowUpdate->updateObject(columnIndex, x);
}
// ::com::sun::star::sdbc::XResultSet
//------------------------------------------------------------------------------
sal_Bool OResultSet::next(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorResultSet->next();
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::isBeforeFirst(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorResultSet->isBeforeFirst();
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::isAfterLast(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorResultSet->isAfterLast();
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::isFirst(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorResultSet->isFirst();
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::isLast(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorResultSet->isLast();
}
//------------------------------------------------------------------------------
void OResultSet::beforeFirst(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
m_xDelegatorResultSet->beforeFirst();
}
//------------------------------------------------------------------------------
void OResultSet::afterLast(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
m_xDelegatorResultSet->afterLast();
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::first(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorResultSet->first();
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::last(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorResultSet->last();
}
//------------------------------------------------------------------------------
sal_Int32 OResultSet::getRow(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorResultSet->getRow();
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::absolute(sal_Int32 row) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorResultSet->absolute(row);
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::relative(sal_Int32 rows) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorResultSet->relative(rows);
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::previous(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorResultSet->previous();
}
//------------------------------------------------------------------------------
void OResultSet::refreshRow(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
m_xDelegatorResultSet->refreshRow();
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::rowUpdated(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorResultSet->rowUpdated();
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::rowInserted(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorResultSet->rowInserted();
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::rowDeleted(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_xDelegatorResultSet->rowDeleted();
}
//------------------------------------------------------------------------------
Reference< XInterface > OResultSet::getStatement(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
return m_aStatement;
}
// ::com::sun::star::sdbcx::XRowLocate
//------------------------------------------------------------------------------
Any OResultSet::getBookmark(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkBookmarkable();
return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->getBookmark();
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::moveToBookmark(const Any& bookmark) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkBookmarkable();
return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->moveToBookmark(bookmark);
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::moveRelativeToBookmark(const Any& bookmark, sal_Int32 rows) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkBookmarkable();
return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->moveRelativeToBookmark(bookmark, rows);
}
//------------------------------------------------------------------------------
sal_Int32 OResultSet::compareBookmarks(const Any& _first, const Any& _second) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkBookmarkable();
return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->compareBookmarks(_first, _second);
}
//------------------------------------------------------------------------------
sal_Bool OResultSet::hasOrderedBookmarks(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkBookmarkable();
return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->hasOrderedBookmarks();
}
//------------------------------------------------------------------------------
sal_Int32 OResultSet::hashBookmark(const Any& bookmark) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkBookmarkable();
return Reference< XRowLocate >(m_xDelegatorResultSet, UNO_QUERY)->hashBookmark(bookmark);
}
// ::com::sun::star::sdbc::XResultSetUpdate
//------------------------------------------------------------------------------
void OResultSet::insertRow(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorResultSetUpdate->insertRow();
}
//------------------------------------------------------------------------------
void OResultSet::updateRow(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorResultSetUpdate->updateRow();
}
//------------------------------------------------------------------------------
void OResultSet::deleteRow(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorResultSetUpdate->deleteRow();
}
//------------------------------------------------------------------------------
void OResultSet::cancelRowUpdates(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorResultSetUpdate->cancelRowUpdates();
}
//------------------------------------------------------------------------------
void OResultSet::moveToInsertRow(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorResultSetUpdate->moveToInsertRow();
}
//------------------------------------------------------------------------------
void OResultSet::moveToCurrentRow(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OResultSetBase::rBHelper.bDisposed);
checkReadOnly();
m_xDelegatorResultSetUpdate->moveToCurrentRow();
}
// -----------------------------------------------------------------------------
void OResultSet::checkReadOnly() const
{
if ( ( m_nResultSetConcurrency == ResultSetConcurrency::READ_ONLY )
|| !m_xDelegatorResultSetUpdate.is()
)
throwSQLException( "The result set is read-only.", SQL_GENERAL_ERROR, *const_cast< OResultSet* >( this ) );
}
// -----------------------------------------------------------------------------
void OResultSet::checkBookmarkable() const
{
if ( !m_bIsBookmarkable )
throwSQLException( "The result set does not have bookmark support.", SQL_GENERAL_ERROR, *const_cast< OResultSet* >( this ) );
}
// -----------------------------------------------------------------------------
Reference in a new issue View git blame Copy permalink