dbaccess/source/core/api/statement.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <statement.hxx>
  21 #include <resultset.hxx>
  22 #include "dbastrings.hrc"
  23 #include <com/sun/star/lang/DisposedException.hpp>
  24 #include <com/sun/star/sdbc/XDatabaseMetaData.hpp>
  25 #include <comphelper/sequence.hxx>
  26 #include <cppuhelper/queryinterface.hxx>
  27 #include <cppuhelper/supportsservice.hxx>
  28 #include <cppuhelper/typeprovider.hxx>
  29 #include <comphelper/property.hxx>
  30 #include <comphelper/types.hxx>
  31 #include <tools/debug.hxx>
  32 #include <tools/diagnose_ex.h>
  33 #include <connectivity/dbexception.hxx>
  34
  35 using namespace ::com::sun::star::sdb;
  36 using namespace ::com::sun::star::sdbc;
  37 using namespace ::com::sun::star::beans;
  38 using namespace ::com::sun::star::uno;
  39 using namespace ::com::sun::star::lang;
  40 using namespace ::cppu;
  41 using namespace ::osl;
  42 using namespace dbaccess;
  43 using namespace dbtools;
  44
  45
  46 OStatementBase::OStatementBase(const Reference< XConnection > & _xConn,
  47                                const Reference< XInterface > & _xStatement)
  48     :OSubComponent(m_aMutex, _xConn)
  49     ,OPropertySetHelper(OComponentHelper::rBHelper)
  50     ,m_bUseBookmarks( false )
  51     ,m_bEscapeProcessing( true )
  52
  53 {
  54     OSL_ENSURE(_xStatement.is() ,"Statement is NULL!");
  55     m_xAggregateAsSet.set(_xStatement,UNO_QUERY);
  56     m_xAggregateAsCancellable = Reference< ::com::sun::star::util::XCancellable > (m_xAggregateAsSet, UNO_QUERY);
  57 }
  58
  59 OStatementBase::~OStatementBase()
  60 {
  61 }
  62
  63 // com::sun::star::lang::XTypeProvider
  64 Sequence< Type > OStatementBase::getTypes() throw (RuntimeException, std::exception)
  65 {
  66     OTypeCollection aTypes(cppu::UnoType<XPropertySet>::get(),
  67                            cppu::UnoType<XWarningsSupplier>::get(),
  68                            cppu::UnoType<XCloseable>::get(),
  69                            cppu::UnoType<XMultipleResults>::get(),
  70                            cppu::UnoType<com::sun::star::util::XCancellable>::get(),
  71                             OSubComponent::getTypes() );
  72     Reference< XGeneratedResultSet > xGRes(m_xAggregateAsSet, UNO_QUERY);
  73     if ( xGRes.is() )
  74         aTypes = OTypeCollection(cppu::UnoType<XGeneratedResultSet>::get(),aTypes.getTypes());
  75     Reference< XPreparedBatchExecution > xPreparedBatchExecution(m_xAggregateAsSet, UNO_QUERY);
  76     if ( xPreparedBatchExecution.is() )
  77         aTypes = OTypeCollection(cppu::UnoType<XPreparedBatchExecution>::get(),aTypes.getTypes());
  78
  79     return aTypes.getTypes();
  80 }
  81
  82 // com::sun::star::uno::XInterface
  83 Any OStatementBase::queryInterface( const Type & rType ) throw (RuntimeException, std::exception)
  84 {
  85     Any aIface = OSubComponent::queryInterface( rType );
  86     if (!aIface.hasValue())
  87     {
  88         aIface = ::cppu::queryInterface(
  89                     rType,
  90                     static_cast< XPropertySet * >( this ),
  91                     static_cast< XWarningsSupplier * >( this ),
  92                     static_cast< XCloseable * >( this ),
  93                     static_cast< XMultipleResults * >( this ),
  94                     static_cast< ::com::sun::star::util::XCancellable * >( this ));
  95         if ( !aIface.hasValue() )
  96         {
  97             Reference< XGeneratedResultSet > xGRes(m_xAggregateAsSet, UNO_QUERY);
  98             if ( cppu::UnoType<XGeneratedResultSet>::get()== rType && xGRes.is() )
  99                 aIface = ::cppu::queryInterface(rType,static_cast< XGeneratedResultSet * >( this ));
 100         }
 101         if ( !aIface.hasValue() )
 102         {
 103             Reference< XPreparedBatchExecution > xGRes(m_xAggregateAsSet, UNO_QUERY);
 104             if ( cppu::UnoType<XPreparedBatchExecution>::get()== rType && xGRes.is() )
 105                 aIface = ::cppu::queryInterface(rType,static_cast< XPreparedBatchExecution * >( this ));
 106         }
 107     }
 108     return aIface;
 109 }
 110
 111 void OStatementBase::acquire() throw ()
 112 {
 113     OSubComponent::acquire();
 114 }
 115
 116 void OStatementBase::release() throw ()
 117 {
 118     OSubComponent::release();
 119 }
 120
 121 void OStatementBase::disposeResultSet()
 122 {
 123     // free the cursor if alive
 124     Reference< XComponent > xComp(m_aResultSet.get(), UNO_QUERY);
 125     if (xComp.is())
 126         xComp->dispose();
 127     m_aResultSet = NULL;
 128 }
 129
 130 // OComponentHelper
 131 void OStatementBase::disposing()
 132 {
 133     OPropertySetHelper::disposing();
 134
 135     MutexGuard aGuard(m_aMutex);
 136
 137     // free pending results
 138     disposeResultSet();
 139
 140     // free the original statement
 141     {
 142         MutexGuard aCancelGuard(m_aCancelMutex);
 143         m_xAggregateAsCancellable = NULL;
 144     }
 145
 146     if ( m_xAggregateAsSet.is() )
 147     {
 148         try
 149         {
 150             Reference< XCloseable > (m_xAggregateAsSet, UNO_QUERY)->close();
 151         }
 152         catch(RuntimeException& )
 153         {// don't care for anymore
 154         }
 155     }
 156     m_xAggregateAsSet = NULL;
 157
 158     // free the parent at last
 159     OSubComponent::disposing();
 160 }
 161
 162 // XCloseable
 163 void OStatementBase::close() throw( SQLException, RuntimeException, std::exception )
 164 {
 165     {
 166         MutexGuard aGuard( m_aMutex );
 167         ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 168     }
 169     dispose();
 170 }
 171
 172 // OPropertySetHelper
 173 Reference< XPropertySetInfo > OStatementBase::getPropertySetInfo() throw (RuntimeException, std::exception)
 174 {
 175     return createPropertySetInfo( getInfoHelper() ) ;
 176 }
 177
 178 // comphelper::OPropertyArrayUsageHelper
 179 ::cppu::IPropertyArrayHelper* OStatementBase::createArrayHelper( ) const
 180 {
 181     BEGIN_PROPERTY_HELPER(10)
 182         DECL_PROP0(CURSORNAME,              OUString);
 183         DECL_PROP0_BOOL(ESCAPE_PROCESSING);
 184         DECL_PROP0(FETCHDIRECTION,          sal_Int32);
 185         DECL_PROP0(FETCHSIZE,               sal_Int32);
 186         DECL_PROP0(MAXFIELDSIZE,            sal_Int32);
 187         DECL_PROP0(MAXROWS,                 sal_Int32);
 188         DECL_PROP0(QUERYTIMEOUT,            sal_Int32);
 189         DECL_PROP0(RESULTSETCONCURRENCY,    sal_Int32);
 190         DECL_PROP0(RESULTSETTYPE,           sal_Int32);
 191         DECL_PROP0_BOOL(USEBOOKMARKS);
 192     END_PROPERTY_HELPER();
 193 }
 194
 195 // cppu::OPropertySetHelper
 196 ::cppu::IPropertyArrayHelper& OStatementBase::getInfoHelper()
 197 {
 198     return *getArrayHelper();
 199 }
 200
 201 sal_Bool OStatementBase::convertFastPropertyValue( Any & rConvertedValue, Any & rOldValue, sal_Int32 nHandle, const Any& rValue ) throw( IllegalArgumentException  )
 202 {
 203     bool bModified(false);
 204     switch (nHandle)
 205     {
 206         case PROPERTY_ID_USEBOOKMARKS:
 207             bModified = ::comphelper::tryPropertyValue( rConvertedValue, rOldValue, rValue, m_bUseBookmarks );
 208             break;
 209
 210         case PROPERTY_ID_ESCAPE_PROCESSING:
 211             bModified = ::comphelper::tryPropertyValue( rConvertedValue, rOldValue, rValue, m_bEscapeProcessing );
 212             break;
 213
 214         default:
 215             if ( m_xAggregateAsSet.is() )
 216             {
 217                 // get the property name
 218                 OUString sPropName;
 219                 getInfoHelper().fillPropertyMembersByHandle( &sPropName, NULL, nHandle );
 220
 221                 // now set the value
 222                 Any aCurrentValue = m_xAggregateAsSet->getPropertyValue( sPropName );
 223                 if ( aCurrentValue != rValue )
 224                 {
 225                     rOldValue = aCurrentValue;
 226                     rConvertedValue = rValue;
 227                     bModified = true;
 228                 }
 229             }
 230             break;
 231     }
 232     return bModified;
 233 }
 234
 235 void OStatementBase::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const Any& rValue ) throw (Exception, std::exception)
 236 {
 237     switch ( nHandle )
 238     {
 239         case PROPERTY_ID_USEBOOKMARKS:
 240         {
 241             m_bUseBookmarks = ::comphelper::getBOOL( rValue );
 242             if ( m_xAggregateAsSet.is() && m_xAggregateAsSet->getPropertySetInfo()->hasPropertyByName( PROPERTY_USEBOOKMARKS ) )
 243                 m_xAggregateAsSet->setPropertyValue( PROPERTY_USEBOOKMARKS, rValue );
 244         }
 245         break;
 246
 247         case PROPERTY_ID_ESCAPE_PROCESSING:
 248             m_bEscapeProcessing = ::comphelper::getBOOL( rValue );
 249             if ( m_xAggregateAsSet.is() )
 250                 m_xAggregateAsSet->setPropertyValue( PROPERTY_ESCAPE_PROCESSING, rValue );
 251             break;
 252
 253         default:
 254             if ( m_xAggregateAsSet.is() )
 255             {
 256                 OUString sPropName;
 257                 getInfoHelper().fillPropertyMembersByHandle( &sPropName, NULL, nHandle );
 258                 m_xAggregateAsSet->setPropertyValue( sPropName, rValue );
 259             }
 260             break;
 261     }
 262 }
 263
 264 void OStatementBase::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
 265 {
 266     switch (nHandle)
 267     {
 268         case PROPERTY_ID_USEBOOKMARKS:
 269             rValue <<= m_bUseBookmarks;
 270             break;
 271
 272         case PROPERTY_ID_ESCAPE_PROCESSING:
 273             // don't rely on our aggregate - if it implements this wrong, and always returns
 274             // TRUE here, then we would loop in impl_doEscapeProcessing_nothrow
 275             rValue <<= m_bEscapeProcessing;
 276             break;
 277
 278         default:
 279             if ( m_xAggregateAsSet.is() )
 280             {
 281                 OUString sPropName;
 282                 const_cast< OStatementBase* >( this )->getInfoHelper().fillPropertyMembersByHandle( &sPropName, NULL, nHandle );
 283                 rValue = m_xAggregateAsSet->getPropertyValue( sPropName );
 284             }
 285             break;
 286     }
 287 }
 288
 289 // XWarningsSupplier
 290 Any OStatementBase::getWarnings() throw( SQLException, RuntimeException, std::exception )
 291 {
 292     MutexGuard aGuard(m_aMutex);
 293     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 294
 295     return Reference< XWarningsSupplier >(m_xAggregateAsSet, UNO_QUERY)->getWarnings();
 296 }
 297
 298 void OStatementBase::clearWarnings() throw( SQLException, RuntimeException, std::exception )
 299 {
 300     MutexGuard aGuard(m_aMutex);
 301     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 302
 303     Reference< XWarningsSupplier >(m_xAggregateAsSet, UNO_QUERY)->clearWarnings();
 304 }
 305
 306 // ::com::sun::star::util::XCancellable
 307 void OStatementBase::cancel() throw( RuntimeException, std::exception )
 308 {
 309     // no blocking as cancel is typically called from a different thread
 310     ClearableMutexGuard aCancelGuard(m_aCancelMutex);
 311     if (m_xAggregateAsCancellable.is())
 312         m_xAggregateAsCancellable->cancel();
 313     // else do nothing
 314 }
 315
 316 // XMultipleResults
 317 Reference< XResultSet > SAL_CALL OStatementBase::getResultSet(  ) throw(SQLException, RuntimeException, std::exception)
 318 {
 319     MutexGuard aGuard(m_aMutex);
 320     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 321
 322     // first check the meta data
 323     Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
 324     if (!xMeta.is() && !xMeta->supportsMultipleResultSets())
 325         throwFunctionSequenceException(*this);
 326
 327     return Reference< XMultipleResults >(m_xAggregateAsSet, UNO_QUERY)->getResultSet();
 328 }
 329
 330 sal_Int32 SAL_CALL OStatementBase::getUpdateCount(  ) throw(SQLException, RuntimeException, std::exception)
 331 {
 332     MutexGuard aGuard(m_aMutex);
 333     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 334
 335     // first check the meta data
 336     Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
 337     if (!xMeta.is() && !xMeta->supportsMultipleResultSets())
 338         throwFunctionSequenceException(*this);
 339
 340     return Reference< XMultipleResults >(m_xAggregateAsSet, UNO_QUERY)->getUpdateCount();
 341 }
 342
 343 sal_Bool SAL_CALL OStatementBase::getMoreResults(  ) throw(SQLException, RuntimeException, std::exception)
 344 {
 345     MutexGuard aGuard(m_aMutex);
 346     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 347
 348     // first check the meta data
 349     Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
 350     if (!xMeta.is() && !xMeta->supportsMultipleResultSets())
 351         throwFunctionSequenceException(*this);
 352
 353     // free the previous results
 354     disposeResultSet();
 355
 356     return Reference< XMultipleResults >(m_xAggregateAsSet, UNO_QUERY)->getMoreResults();
 357 }
 358
 359 // XPreparedBatchExecution
 360 void SAL_CALL OStatementBase::addBatch(  ) throw(SQLException, RuntimeException, std::exception)
 361 {
 362     MutexGuard aGuard(m_aMutex);
 363     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 364
 365     // first check the meta data
 366     Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
 367     if (!xMeta.is() && !xMeta->supportsBatchUpdates())
 368         throwFunctionSequenceException(*this);
 369
 370     Reference< XPreparedBatchExecution >(m_xAggregateAsSet, UNO_QUERY)->addBatch();
 371 }
 372
 373 void SAL_CALL OStatementBase::clearBatch(  ) throw(SQLException, RuntimeException, std::exception)
 374 {
 375     MutexGuard aGuard(m_aMutex);
 376     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 377
 378     // first check the meta data
 379     Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
 380     if (!xMeta.is() && !xMeta->supportsBatchUpdates())
 381         throwFunctionSequenceException(*this);
 382
 383     Reference< XPreparedBatchExecution >(m_xAggregateAsSet, UNO_QUERY)->clearBatch();
 384 }
 385
 386 Sequence< sal_Int32 > SAL_CALL OStatementBase::executeBatch(  ) throw(SQLException, RuntimeException, std::exception)
 387 {
 388     MutexGuard aGuard(m_aMutex);
 389     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 390
 391     // first check the meta data
 392     Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
 393     if (!xMeta.is() && !xMeta->supportsBatchUpdates())
 394         throwFunctionSequenceException(*this);
 395
 396     // free the previous results
 397     disposeResultSet();
 398
 399     return Reference< XPreparedBatchExecution >(m_xAggregateAsSet, UNO_QUERY)->executeBatch();
 400 }
 401
 402 Reference< XResultSet > SAL_CALL OStatementBase::getGeneratedValues(  ) throw (SQLException, RuntimeException, std::exception)
 403 {
 404     MutexGuard aGuard(m_aMutex);
 405     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 406     Reference< XGeneratedResultSet > xGRes(m_xAggregateAsSet, UNO_QUERY);
 407
 408     if ( xGRes.is() )
 409         return xGRes->getGeneratedValues(  );
 410     return Reference< XResultSet >();
 411 }
 412
 413
 414 //  OStatement
 415
 416 OStatement::OStatement( const Reference< XConnection >& _xConn, const Reference< XInterface > & _xStatement )
 417     :OStatementBase( _xConn, _xStatement )
 418     ,m_bAttemptedComposerCreation( false )
 419 {
 420     m_xAggregateStatement.set( _xStatement, UNO_QUERY_THROW );
 421 }
 422
 423 IMPLEMENT_FORWARD_XINTERFACE2( OStatement, OStatementBase, OStatement_IFACE );
 424 IMPLEMENT_FORWARD_XTYPEPROVIDER2( OStatement, OStatementBase, OStatement_IFACE );
 425
 426 // XServiceInfo
 427 OUString OStatement::getImplementationName(  ) throw(RuntimeException, std::exception)
 428 {
 429     return OUString("com.sun.star.sdb.OStatement");
 430 }
 431
 432 sal_Bool OStatement::supportsService( const OUString& _rServiceName ) throw (RuntimeException, std::exception)
 433 {
 434     return cppu::supportsService(this, _rServiceName);
 435 }
 436
 437 Sequence< OUString > OStatement::getSupportedServiceNames(  ) throw (RuntimeException, std::exception)
 438 {
 439     Sequence< OUString > aSNS( 1 );
 440     aSNS.getArray()[0] = SERVICE_SDBC_STATEMENT;
 441     return aSNS;
 442 }
 443
 444 // XStatement
 445 Reference< XResultSet > OStatement::executeQuery( const OUString& _rSQL ) throw( SQLException, RuntimeException, std::exception )
 446 {
 447     MutexGuard aGuard(m_aMutex);
 448     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 449
 450     disposeResultSet();
 451     Reference< XResultSet > xResultSet;
 452
 453     OUString sSQL( impl_doEscapeProcessing_nothrow( _rSQL ) );
 454
 455     Reference< XResultSet > xInnerResultSet = m_xAggregateStatement->executeQuery( sSQL );
 456     Reference< XConnection > xConnection( m_xParent, UNO_QUERY_THROW );
 457
 458     if ( xInnerResultSet.is() )
 459     {
 460         Reference< XDatabaseMetaData > xMeta = xConnection->getMetaData();
 461         bool bCaseSensitive = xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers();
 462         xResultSet = new OResultSet( xInnerResultSet, *this, bCaseSensitive );
 463
 464         // keep the resultset weak
 465         m_aResultSet = xResultSet;
 466     }
 467
 468     return xResultSet;
 469 }
 470
 471 sal_Int32 OStatement::executeUpdate( const OUString& _rSQL ) throw( SQLException, RuntimeException, std::exception )
 472 {
 473     MutexGuard aGuard(m_aMutex);
 474     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 475
 476     disposeResultSet();
 477
 478     OUString sSQL( impl_doEscapeProcessing_nothrow( _rSQL ) );
 479     return m_xAggregateStatement->executeUpdate( sSQL );
 480 }
 481
 482 sal_Bool OStatement::execute( const OUString& _rSQL ) throw( SQLException, RuntimeException, std::exception )
 483 {
 484     MutexGuard aGuard(m_aMutex);
 485     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 486
 487     disposeResultSet();
 488
 489     OUString sSQL( impl_doEscapeProcessing_nothrow( _rSQL ) );
 490     return m_xAggregateStatement->execute( sSQL );
 491 }
 492
 493 void OStatement::addBatch( const OUString& _rSQL ) throw( SQLException, RuntimeException, std::exception )
 494 {
 495     MutexGuard aGuard(m_aMutex);
 496     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 497
 498     // first check the meta data
 499     Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
 500     if (!xMeta.is() && !xMeta->supportsBatchUpdates())
 501         throwFunctionSequenceException(*this);
 502
 503     OUString sSQL( impl_doEscapeProcessing_nothrow( _rSQL ) );
 504     Reference< XBatchExecution >(m_xAggregateAsSet, UNO_QUERY)->addBatch( sSQL );
 505 }
 506
 507 void OStatement::clearBatch( ) throw( SQLException, RuntimeException, std::exception )
 508 {
 509     MutexGuard aGuard(m_aMutex);
 510     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 511     // first check the meta data
 512     Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
 513     if (!xMeta.is() && !xMeta->supportsBatchUpdates())
 514         throwFunctionSequenceException(*this);
 515
 516     Reference< XBatchExecution >(m_xAggregateAsSet, UNO_QUERY)->clearBatch();
 517 }
 518
 519 Sequence< sal_Int32 > OStatement::executeBatch( ) throw( SQLException, RuntimeException, std::exception )
 520 {
 521     MutexGuard aGuard(m_aMutex);
 522     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 523     // first check the meta data
 524     Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
 525     if (!xMeta.is() && !xMeta->supportsBatchUpdates())
 526         throwFunctionSequenceException(*this);
 527     return Reference< XBatchExecution >(m_xAggregateAsSet, UNO_QUERY)->executeBatch( );
 528 }
 529
 530
 531 Reference< XConnection > OStatement::getConnection() throw( SQLException, RuntimeException, std::exception )
 532 {
 533     return Reference< XConnection >( m_xParent, UNO_QUERY );
 534 }
 535
 536 void SAL_CALL OStatement::disposing()
 537 {
 538     OStatementBase::disposing();
 539     m_xComposer.clear();
 540     m_xAggregateStatement.clear();
 541 }
 542
 543 OUString OStatement::impl_doEscapeProcessing_nothrow( const OUString& _rSQL ) const
 544 {
 545     if ( !m_bEscapeProcessing )
 546         return _rSQL;
 547     try
 548     {
 549         if ( !impl_ensureComposer_nothrow() )
 550             return _rSQL;
 551
 552         bool bParseable = false;
 553         try { m_xComposer->setQuery( _rSQL ); bParseable = true; }
 554         catch( const SQLException& ) { }
 555
 556         if ( !bParseable )
 557             // if we cannot parse it, silently accept this. The driver is probably able to cope with it then
 558             return _rSQL;
 559
 560         OUString sLowLevelSQL = m_xComposer->getQueryWithSubstitution();
 561         return sLowLevelSQL;
 562     }
 563     catch( const Exception& )
 564     {
 565         DBG_UNHANDLED_EXCEPTION();
 566     }
 567
 568     return _rSQL;
 569 }
 570
 571 bool OStatement::impl_ensureComposer_nothrow() const
 572 {
 573     if ( m_bAttemptedComposerCreation )
 574         return m_xComposer.is();
 575
 576     const_cast< OStatement* >( this )->m_bAttemptedComposerCreation = true;
 577     try
 578     {
 579         Reference< XMultiServiceFactory > xFactory( m_xParent, UNO_QUERY_THROW );
 580         const_cast< OStatement* >( this )->m_xComposer.set( xFactory->createInstance( SERVICE_NAME_SINGLESELECTQUERYCOMPOSER ), UNO_QUERY_THROW );
 581     }
 582     catch( const Exception& )
 583     {
 584         DBG_UNHANDLED_EXCEPTION();
 585     }
 586
 587     return m_xComposer.is();
 588 }
 589
 590 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */