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