strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/dbaccess/source/core/api/statement.cxx
Jens-Heiner Rechtien 9332266194 INTEGRATION: CWS warnings01 (1.13.50); FILE MERGED 
2006/03/24 15:35:50 fs 1.13.50.1: #i57457# warning-free code (unxlngi6/.pro + unxsoli4.pro)
2006-06-20 01:41:32 +00:00

573 lines
21 KiB
C++
Raw Blame History

/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: statement.cxx,v $
*
* $Revision: 1.14 $
*
* last change: $Author: hr $ $Date: 2006-06-20 02:41:32 $
*
* 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
*
************************************************************************/
#ifndef _DBA_COREAPI_STATEMENT_HXX_
#include <statement.hxx>
#endif
#ifndef _DBA_COREAPI_RESULTSET_HXX_
#include <resultset.hxx>
#endif
#ifndef DBACCESS_SHARED_DBASTRINGS_HRC
#include "dbastrings.hrc"
#endif
#ifndef _COM_SUN_STAR_LANG_DISPOSEDEXCEPTION_HPP_
#include <com/sun/star/lang/DisposedException.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBC_XDATABASEMETADATA_HPP_
#include <com/sun/star/sdbc/XDatabaseMetaData.hpp>
#endif
#ifndef _COMPHELPER_SEQUENCE_HXX_
#include <comphelper/sequence.hxx>
#endif
#ifndef _CPPUHELPER_TYPEPROVIDER_HXX_
#include <cppuhelper/typeprovider.hxx>
#endif
#ifndef _COMPHELPER_PROPERTY_HXX_
#include <comphelper/property.hxx>
#endif
#ifndef _COMPHELPER_TYPES_HXX_
#include <comphelper/types.hxx>
#endif
#ifndef _TOOLS_DEBUG_HXX //autogen
#include <tools/debug.hxx>
#endif
#ifndef _DBHELPER_DBEXCEPTION_HXX_
#include <connectivity/dbexception.hxx>
#endif
using namespace ::com::sun::star::sdbc;
//using namespace ::com::sun::star::sdbcx;
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(OStatementBase)
//--------------------------------------------------------------------------
OStatementBase::OStatementBase(const Reference< XConnection > & _xConn,
const Reference< XInterface > & _xStatement)
:OSubComponent(m_aMutex, _xConn)
,OPropertySetHelper(OComponentHelper::rBHelper)
,m_bUseBookmarks(sal_False)
{
DBG_CTOR(OStatementBase, NULL);
OSL_ENSURE(_xStatement.is() ,"Statement is NULL!");
m_xAggregateAsSet.set(_xStatement,UNO_QUERY);
m_xAggregateAsCancellable = Reference< ::com::sun::star::util::XCancellable > (m_xAggregateAsSet, UNO_QUERY);
}
//--------------------------------------------------------------------------
OStatementBase::~OStatementBase()
{
DBG_DTOR(OStatementBase, NULL);
}
// com::sun::star::lang::XTypeProvider
//--------------------------------------------------------------------------
Sequence< Type > OStatementBase::getTypes() throw (RuntimeException)
{
OTypeCollection aTypes(::getCppuType( (const Reference< XPropertySet > *)0 ),
::getCppuType( (const Reference< XWarningsSupplier > *)0 ),
::getCppuType( (const Reference< XCloseable > *)0 ),
::getCppuType( (const Reference< XMultipleResults > *)0 ),
::getCppuType( (const Reference< XPreparedBatchExecution > *)0 ),
::getCppuType( (const Reference< ::com::sun::star::util::XCancellable > *)0 ),
OSubComponent::getTypes() );
Reference< XGeneratedResultSet > xGRes(m_xAggregateAsSet, UNO_QUERY);
if ( xGRes.is() )
aTypes = OTypeCollection(::getCppuType( (const Reference< XGeneratedResultSet > *)0 ),aTypes.getTypes());
return aTypes.getTypes();
}
// com::sun::star::uno::XInterface
//--------------------------------------------------------------------------
Any OStatementBase::queryInterface( const Type & rType ) throw (RuntimeException)
{
Any aIface = OSubComponent::queryInterface( rType );
if (!aIface.hasValue())
{
aIface = ::cppu::queryInterface(
rType,
static_cast< XPropertySet * >( this ),
static_cast< XWarningsSupplier * >( this ),
static_cast< XCloseable * >( this ),
static_cast< XPreparedBatchExecution * >( this ),
static_cast< XMultipleResults * >( this ),
static_cast< ::com::sun::star::util::XCancellable * >( this ));
if ( !aIface.hasValue() )
{
Reference< XGeneratedResultSet > xGRes(m_xAggregateAsSet, UNO_QUERY);
if ( ::getCppuType( (const Reference< XGeneratedResultSet > *)0 ) == rType && xGRes.is() )
aIface = ::cppu::queryInterface(rType,static_cast< XGeneratedResultSet * >( this ));
}
}
return aIface;
}
//--------------------------------------------------------------------------
void OStatementBase::acquire() throw ()
{
OSubComponent::acquire();
}
//--------------------------------------------------------------------------
void OStatementBase::release() throw ()
{
OSubComponent::release();
}
//------------------------------------------------------------------------------
void OStatementBase::disposeResultSet()
{
// free the cursor if alive
Reference< XComponent > xComp(m_aResultSet.get(), UNO_QUERY);
if (xComp.is())
xComp->dispose();
m_aResultSet = NULL;
}
// OComponentHelper
//------------------------------------------------------------------------------
void OStatementBase::disposing()
{
OPropertySetHelper::disposing();
MutexGuard aGuard(m_aMutex);
// free pending results
disposeResultSet();
// free the original statement
{
MutexGuard aCancelGuard(m_aCancelMutex);
m_xAggregateAsCancellable = NULL;
}
if ( m_xAggregateAsSet.is() )
{
try
{
Reference< XCloseable > (m_xAggregateAsSet, UNO_QUERY)->close();
}
catch(DisposedException& )
{// don't care for anymore
}
catch(RuntimeException& )
{// don't care for anymore
}
}
m_xAggregateAsSet = NULL;
// free the parent at last
OSubComponent::disposing();
}
// XCloseable
//------------------------------------------------------------------------------
void OStatementBase::close(void) throw( SQLException, RuntimeException )
{
{
MutexGuard aGuard( m_aMutex );
::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
}
dispose();
}
// OPropertySetHelper
//------------------------------------------------------------------------------
Reference< XPropertySetInfo > OStatementBase::getPropertySetInfo() throw (RuntimeException)
{
return createPropertySetInfo( getInfoHelper() ) ;
}
// comphelper::OPropertyArrayUsageHelper
//------------------------------------------------------------------------------
::cppu::IPropertyArrayHelper* OStatementBase::createArrayHelper( ) const
{
BEGIN_PROPERTY_HELPER(10)
DECL_PROP0(CURSORNAME, ::rtl::OUString);
DECL_PROP0_BOOL(USE_ESCAPE_PROCESSING);
DECL_PROP0(FETCHDIRECTION, sal_Int32);
DECL_PROP0(FETCHSIZE, sal_Int32);
DECL_PROP0(MAXFIELDSIZE, sal_Int32);
DECL_PROP0(MAXROWS, sal_Int32);
DECL_PROP0(QUERYTIMEOUT, sal_Int32);
DECL_PROP0(RESULTSETCONCURRENCY, sal_Int32);
DECL_PROP0(RESULTSETTYPE, sal_Int32);
DECL_PROP0_BOOL(USEBOOKMARKS);
END_PROPERTY_HELPER();
}
// cppu::OPropertySetHelper
//------------------------------------------------------------------------------
::cppu::IPropertyArrayHelper& OStatementBase::getInfoHelper()
{
return *getArrayHelper();
}
//------------------------------------------------------------------------------
sal_Bool OStatementBase::convertFastPropertyValue( Any & rConvertedValue, Any & rOldValue, sal_Int32 nHandle, const Any& rValue ) throw( IllegalArgumentException )
{
sal_Bool bModified(sal_False);
switch (nHandle)
{
case PROPERTY_ID_USEBOOKMARKS:
if ( m_xAggregateAsSet.is() )
{
bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_bUseBookmarks);
if (bModified && m_xAggregateAsSet->getPropertySetInfo()->hasPropertyByName(PROPERTY_USEBOOKMARKS))
m_xAggregateAsSet->setPropertyValue(PROPERTY_USEBOOKMARKS, rConvertedValue);
}
break;
default:
{
// get the property name
::rtl::OUString aPropName;
sal_Int16 nAttributes;
getInfoHelper().fillPropertyMembersByHandle(&aPropName, &nAttributes, nHandle);
OSL_ENSURE(aPropName.getLength(), "property not found?");
// now set the value
if ( m_xAggregateAsSet.is() )
m_xAggregateAsSet->setPropertyValue(aPropName, rValue);
}
}
return bModified;
}
//------------------------------------------------------------------------------
void OStatementBase::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const Any& rValue ) throw (Exception)
{
switch (nHandle)
{
// the other properties are set in convertFast...
case PROPERTY_ID_USEBOOKMARKS:
{
m_bUseBookmarks = ::comphelper::getBOOL(rValue);
} break;
}
}
//------------------------------------------------------------------------------
void OStatementBase::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
{
switch (nHandle)
{
case PROPERTY_ID_USEBOOKMARKS:
rValue.setValue(&m_bUseBookmarks, getBooleanCppuType());
break;
default:
{
// get the property name
::rtl::OUString aPropName;
sal_Int16 nAttributes;
const_cast<OStatementBase*>(this)->getInfoHelper().
fillPropertyMembersByHandle(&aPropName, &nAttributes, nHandle);
OSL_ENSURE(aPropName.getLength(), "property not found?");
// now read the value
if ( m_xAggregateAsSet.is() )
rValue = m_xAggregateAsSet->getPropertyValue(aPropName);
}
}
}
// XWarningsSupplier
//------------------------------------------------------------------------------
Any OStatementBase::getWarnings(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
return Reference< XWarningsSupplier >(m_xAggregateAsSet, UNO_QUERY)->getWarnings();
}
//------------------------------------------------------------------------------
void OStatementBase::clearWarnings(void) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
Reference< XWarningsSupplier >(m_xAggregateAsSet, UNO_QUERY)->clearWarnings();
}
// ::com::sun::star::util::XCancellable
//------------------------------------------------------------------------------
void OStatementBase::cancel(void) throw( RuntimeException )
{
// no blocking as cancel is typically called from a different thread
ClearableMutexGuard aCancelGuard(m_aCancelMutex);
if (m_xAggregateAsCancellable.is())
m_xAggregateAsCancellable->cancel();
// else do nothing
}
// XMultipleResults
//------------------------------------------------------------------------------
Reference< XResultSet > SAL_CALL OStatementBase::getResultSet( ) throw(SQLException, RuntimeException)
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
// first check the meta data
Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
if (!xMeta.is() && !xMeta->supportsMultipleResultSets())
throwFunctionSequenceException(*this);
return Reference< XMultipleResults >(m_xAggregateAsSet, UNO_QUERY)->getResultSet();
}
//------------------------------------------------------------------------------
sal_Int32 SAL_CALL OStatementBase::getUpdateCount( ) throw(SQLException, RuntimeException)
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
// first check the meta data
Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
if (!xMeta.is() && !xMeta->supportsMultipleResultSets())
throwFunctionSequenceException(*this);
return Reference< XMultipleResults >(m_xAggregateAsSet, UNO_QUERY)->getUpdateCount();
}
//------------------------------------------------------------------------------
sal_Bool SAL_CALL OStatementBase::getMoreResults( ) throw(SQLException, RuntimeException)
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
// first check the meta data
Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
if (!xMeta.is() && !xMeta->supportsMultipleResultSets())
throwFunctionSequenceException(*this);
throwFunctionSequenceException(*this);
// free the previous results
disposeResultSet();
return Reference< XMultipleResults >(m_xAggregateAsSet, UNO_QUERY)->getMoreResults();
}
// XPreparedBatchExecution
//------------------------------------------------------------------------------
void SAL_CALL OStatementBase::addBatch( ) throw(SQLException, RuntimeException)
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
// first check the meta data
Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
if (!xMeta.is() && !xMeta->supportsBatchUpdates())
throwFunctionSequenceException(*this);
Reference< XPreparedBatchExecution >(m_xAggregateAsSet, UNO_QUERY)->addBatch();
}
//------------------------------------------------------------------------------
void SAL_CALL OStatementBase::clearBatch( ) throw(SQLException, RuntimeException)
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
// first check the meta data
Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
if (!xMeta.is() && !xMeta->supportsBatchUpdates())
throwFunctionSequenceException(*this);
Reference< XPreparedBatchExecution >(m_xAggregateAsSet, UNO_QUERY)->clearBatch();
}
//------------------------------------------------------------------------------
Sequence< sal_Int32 > SAL_CALL OStatementBase::executeBatch( ) throw(SQLException, RuntimeException)
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
// first check the meta data
Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
if (!xMeta.is() && !xMeta->supportsBatchUpdates())
throwFunctionSequenceException(*this);
// free the previous results
disposeResultSet();
return Reference< XPreparedBatchExecution >(m_xAggregateAsSet, UNO_QUERY)->executeBatch();
}
// -----------------------------------------------------------------------------
Reference< XResultSet > SAL_CALL OStatementBase::getGeneratedValues( ) throw (SQLException, RuntimeException)
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
Reference< XGeneratedResultSet > xGRes(m_xAggregateAsSet, UNO_QUERY);
if ( xGRes.is() )
return xGRes->getGeneratedValues( );
return Reference< XResultSet >();
}
//************************************************************
// OStatement
//************************************************************
// com::sun::star::lang::XTypeProvider
//--------------------------------------------------------------------------
Sequence< Type > OStatement::getTypes() throw (RuntimeException)
{
OTypeCollection aTypes(::getCppuType( (const Reference< XServiceInfo > *)0 ),
::getCppuType( (const Reference< XStatement > *)0 ),
OStatementBase::getTypes() );
return aTypes.getTypes();
}
//--------------------------------------------------------------------------
Sequence< sal_Int8 > OStatement::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 OStatement::queryInterface( const Type & rType ) throw (RuntimeException)
{
Any aIface = OStatementBase::queryInterface( rType );
if (!aIface.hasValue())
aIface = ::cppu::queryInterface(
rType,
static_cast< XServiceInfo * >( this ),
static_cast< XStatement * >( this ));
return aIface;
}
//--------------------------------------------------------------------------
void OStatement::acquire() throw ()
{
OStatementBase::acquire();
}
//--------------------------------------------------------------------------
void OStatement::release() throw ()
{
OStatementBase::release();
}
// XServiceInfo
//------------------------------------------------------------------------------
rtl::OUString OStatement::getImplementationName( ) throw(RuntimeException)
{
return rtl::OUString::createFromAscii("com.sun.star.sdb.OStatement");
}
//------------------------------------------------------------------------------
sal_Bool OStatement::supportsService( const ::rtl::OUString& _rServiceName ) throw (RuntimeException)
{
return ::comphelper::findValue(getSupportedServiceNames(), _rServiceName, sal_True).getLength() != 0;
}
//------------------------------------------------------------------------------
Sequence< ::rtl::OUString > OStatement::getSupportedServiceNames( ) throw (RuntimeException)
{
Sequence< ::rtl::OUString > aSNS( 2 );
aSNS.getArray()[0] = SERVICE_SDBC_STATEMENT;
aSNS.getArray()[1] = SERVICE_SDB_STATEMENT;
return aSNS;
}
// XStatement
//------------------------------------------------------------------------------
Reference< XResultSet > OStatement::executeQuery(const rtl::OUString& sql) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
disposeResultSet();
Reference< XResultSet > xResultSet;
Reference< XResultSet > xDrvResultSet = Reference< XStatement >(m_xAggregateAsSet, UNO_QUERY)->executeQuery(sql);
if (xDrvResultSet.is())
{
Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
sal_Bool bCaseSensitive = xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers();
xResultSet = new OResultSet(xDrvResultSet, *this, bCaseSensitive);
// keep the resultset weak
m_aResultSet = xResultSet;
}
return xResultSet;
}
//------------------------------------------------------------------------------
sal_Int32 OStatement::executeUpdate(const rtl::OUString& sql) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
disposeResultSet();
return Reference< XStatement >(m_xAggregateAsSet, UNO_QUERY)->executeUpdate(sql);
}
//------------------------------------------------------------------------------
sal_Bool OStatement::execute(const rtl::OUString& sql) throw( SQLException, RuntimeException )
{
MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
disposeResultSet();
return Reference< XStatement >(m_xAggregateAsSet, UNO_QUERY)->execute(sql);
}
//------------------------------------------------------------------------------
Reference< XConnection > OStatement::getConnection(void) throw( SQLException, RuntimeException )
{
return Reference< XConnection > (m_xParent, UNO_QUERY);
}
// -----------------------------------------------------------------------------
Reference in a new issue View git blame Copy permalink