connectivity/source/drivers/ado/AStatement.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 "ado/AStatement.hxx"
  21 #include "ado/AConnection.hxx"
  22 #include "ado/AResultSet.hxx"
  23 #include <comphelper/property.hxx>
  24 #include <comphelper/uno3.hxx>
  25 #include <osl/thread.h>
  26 #include <cppuhelper/typeprovider.hxx>
  27 #include <comphelper/sequence.hxx>
  28 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
  29 #include <com/sun/star/sdbc/ResultSetType.hpp>
  30 #include <com/sun/star/sdbc/FetchDirection.hpp>
  31 #include "connectivity/dbexception.hxx"
  32 #include <comphelper/types.hxx>
  33
  34 #undef max
  35
  36 #include <algorithm>
  37
  38 using namespace ::comphelper;
  39
  40 #define CHECK_RETURN(x)                                                 \
  41     if(!x)                                                              \
  42         ADOS::ThrowException(*m_pConnection->getConnection(),*this);
  43
  44
  45
  46 using namespace connectivity::ado;
  47
  48 //------------------------------------------------------------------------------
  49 using namespace com::sun::star::uno;
  50 using namespace com::sun::star::lang;
  51 using namespace com::sun::star::beans;
  52 using namespace com::sun::star::sdbc;
  53 using namespace ::std;
  54 //------------------------------------------------------------------------------
  55 OStatement_Base::OStatement_Base(OConnection* _pConnection ) :  OStatement_BASE(m_aMutex)
  56                                                         ,OPropertySetHelper(OStatement_BASE::rBHelper)
  57                                                         ,OSubComponent<OStatement_Base, OStatement_BASE>((::cppu::OWeakObject*)_pConnection, this)
  58                                                         ,m_pConnection(_pConnection)
  59                                                         ,m_nMaxRows(0)
  60                                                         ,m_nFetchSize(1)
  61                                                         ,m_eLockType(adLockReadOnly)
  62                                                         ,m_eCursorType(adOpenForwardOnly)
  63 {
  64     osl_atomic_increment( &m_refCount );
  65
  66     m_Command.Create();
  67     if(m_Command.IsValid())
  68         m_Command.putref_ActiveConnection(m_pConnection->getConnection());
  69     else
  70         ADOS::ThrowException(*m_pConnection->getConnection(),*this);
  71
  72     m_RecordsAffected.setNoArg();
  73     m_Parameters.setNoArg();
  74
  75     m_pConnection->acquire();
  76
  77     osl_atomic_decrement( &m_refCount );
  78 }
  79 //------------------------------------------------------------------------------
  80 void OStatement_Base::disposeResultSet()
  81 {
  82     // free the cursor if alive
  83     Reference< XComponent > xComp(m_xResultSet.get(), UNO_QUERY);
  84     if (xComp.is())
  85         xComp->dispose();
  86     m_xResultSet = Reference< XResultSet>();
  87 }
  88
  89 //------------------------------------------------------------------------------
  90 void OStatement_Base::disposing()
  91 {
  92     ::osl::MutexGuard aGuard(m_aMutex);
  93
  94
  95     disposeResultSet();
  96
  97     if ( m_Command.IsValid() )
  98         m_Command.putref_ActiveConnection( NULL );
  99     m_Command.clear();
 100
 101     if ( m_RecordSet.IsValid() )
 102         m_RecordSet.PutRefDataSource( NULL );
 103     m_RecordSet.clear();
 104
 105     if (m_pConnection)
 106         m_pConnection->release();
 107
 108     dispose_ChildImpl();
 109     OStatement_BASE::disposing();
 110 }
 111 //-----------------------------------------------------------------------------
 112 void SAL_CALL OStatement_Base::release() throw()
 113 {
 114     relase_ChildImpl();
 115 }
 116 //-----------------------------------------------------------------------------
 117 Any SAL_CALL OStatement_Base::queryInterface( const Type & rType ) throw(RuntimeException)
 118 {
 119     Any aRet = OStatement_BASE::queryInterface(rType);
 120     return aRet.hasValue() ? aRet : OPropertySetHelper::queryInterface(rType);
 121 }
 122 // -------------------------------------------------------------------------
 123 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL OStatement_Base::getTypes(  ) throw(::com::sun::star::uno::RuntimeException)
 124 {
 125     ::cppu::OTypeCollection aTypes( ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XMultiPropertySet > *)0 ),
 126                                     ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XFastPropertySet > *)0 ),
 127                                     ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > *)0 ));
 128
 129     return ::comphelper::concatSequences(aTypes.getTypes(),OStatement_BASE::getTypes());
 130 }
 131
 132 // -------------------------------------------------------------------------
 133
 134 void SAL_CALL OStatement_Base::cancel(  ) throw(RuntimeException)
 135 {
 136     ::osl::MutexGuard aGuard( m_aMutex );
 137     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 138
 139
 140     CHECK_RETURN(m_Command.Cancel())
 141 }
 142 // -------------------------------------------------------------------------
 143
 144 void SAL_CALL OStatement_Base::close(  ) throw(SQLException, RuntimeException)
 145 {
 146     {
 147         ::osl::MutexGuard aGuard( m_aMutex );
 148         checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 149
 150     }
 151     dispose();
 152 }
 153 // -------------------------------------------------------------------------
 154
 155 void SAL_CALL OStatement::clearBatch(  ) throw(SQLException, RuntimeException)
 156 {
 157
 158 }
 159 // -------------------------------------------------------------------------
 160
 161 void OStatement_Base::reset() throw (SQLException)
 162 {
 163     ::osl::MutexGuard aGuard( m_aMutex );
 164     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 165
 166
 167     clearWarnings ();
 168
 169     if (m_xResultSet.get().is())
 170         clearMyResultSet();
 171 }
 172 //--------------------------------------------------------------------
 173 // clearMyResultSet
 174 // If a ResultSet was created for this Statement, close it
 175 //--------------------------------------------------------------------
 176
 177 void OStatement_Base::clearMyResultSet () throw (SQLException)
 178 {
 179     ::osl::MutexGuard aGuard( m_aMutex );
 180     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 181
 182     try
 183     {
 184         Reference<XCloseable> xCloseable;
 185         if ( ::comphelper::query_interface( m_xResultSet.get(), xCloseable ) )
 186             xCloseable->close();
 187     }
 188     catch( const DisposedException& ) { }
 189
 190     m_xResultSet = Reference< XResultSet >();
 191 }
 192 //--------------------------------------------------------------------
 193 sal_Int32 OStatement_Base::getRowCount () throw( SQLException)
 194 {
 195     ::osl::MutexGuard aGuard( m_aMutex );
 196     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 197
 198
 199     return m_RecordsAffected;
 200 }
 201 //--------------------------------------------------------------------
 202 // getPrecision
 203 // Given a SQL type, return the maximum precision for the column.
 204 // Returns -1 if not known
 205 //--------------------------------------------------------------------
 206
 207 sal_Int32 OStatement_Base::getPrecision ( sal_Int32 sqlType)
 208 {
 209     ::osl::MutexGuard aGuard( m_aMutex );
 210     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 211
 212
 213     sal_Int32 prec = -1;
 214     OTypeInfo aInfo;
 215     aInfo.nType = (sal_Int16)sqlType;
 216     if (!m_aTypeInfo.empty())
 217     {
 218         ::std::vector<OTypeInfo>::const_iterator aIter = ::std::find(m_aTypeInfo.begin(),m_aTypeInfo.end(),aInfo);
 219         for(;aIter != m_aTypeInfo.end();++aIter)
 220         {
 221             prec = ::std::max(prec,(*aIter).nPrecision);
 222         }
 223     }
 224
 225     return prec;
 226 }
 227 //--------------------------------------------------------------------
 228 // setWarning
 229 // Sets the warning
 230 //--------------------------------------------------------------------
 231
 232 void OStatement_Base::setWarning (const SQLWarning &ex) throw( SQLException)
 233 {
 234     ::osl::MutexGuard aGuard( m_aMutex );
 235     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 236
 237
 238     m_aLastWarning = ex;
 239 }
 240 // -------------------------------------------------------------------------
 241 void OStatement_Base::assignRecordSet( ADORecordset* _pRS )
 242 {
 243     WpADORecordset aOldRS( m_RecordSet );
 244     m_RecordSet = WpADORecordset( _pRS );
 245
 246     if ( aOldRS.IsValid() )
 247         aOldRS.PutRefDataSource( NULL );
 248
 249     if ( m_RecordSet.IsValid() )
 250         m_RecordSet.PutRefDataSource( (IDispatch*)m_Command );
 251 }
 252 // -------------------------------------------------------------------------
 253 sal_Bool SAL_CALL OStatement_Base::execute( const OUString& sql ) throw(SQLException, RuntimeException)
 254 {
 255     ::osl::MutexGuard aGuard( m_aMutex );
 256     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 257
 258
 259     // Reset the statement handle and warning
 260
 261     reset();
 262
 263     try
 264     {
 265         ADORecordset* pSet = NULL;
 266         CHECK_RETURN(m_Command.put_CommandText(sql))
 267         CHECK_RETURN(m_Command.Execute(m_RecordsAffected,m_Parameters,adCmdText,&pSet))
 268
 269         assignRecordSet( pSet );
 270     }
 271     catch (SQLWarning& ex)
 272     {
 273
 274         // Save pointer to warning and save with ResultSet
 275         // object once it is created.
 276
 277         m_aLastWarning = ex;
 278     }
 279
 280     return m_RecordSet.IsValid();
 281 }
 282 // -------------------------------------------------------------------------
 283 Reference< XResultSet > SAL_CALL OStatement_Base::executeQuery( const OUString& sql ) throw(SQLException, RuntimeException)
 284 {
 285     ::osl::MutexGuard aGuard( m_aMutex );
 286     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 287
 288
 289     reset();
 290
 291     m_xResultSet = WeakReference<XResultSet>(NULL);
 292
 293     WpADORecordset aSet;
 294     aSet.Create();
 295     CHECK_RETURN(m_Command.put_CommandText(sql))
 296     OLEVariant aCmd;
 297     aCmd.setIDispatch(m_Command);
 298     OLEVariant aCon;
 299     aCon.setNoArg();
 300     CHECK_RETURN(aSet.put_CacheSize(m_nFetchSize))
 301     CHECK_RETURN(aSet.put_MaxRecords(m_nMaxRows))
 302     CHECK_RETURN(aSet.Open(aCmd,aCon,m_eCursorType,m_eLockType,adOpenUnspecified))
 303
 304
 305     CHECK_RETURN(aSet.get_CacheSize(m_nFetchSize))
 306     CHECK_RETURN(aSet.get_MaxRecords(m_nMaxRows))
 307     CHECK_RETURN(aSet.get_CursorType(m_eCursorType))
 308     CHECK_RETURN(aSet.get_LockType(m_eLockType))
 309
 310     OResultSet* pSet = new OResultSet(aSet,this);
 311     Reference< XResultSet > xRs = pSet;
 312     pSet->construct();
 313
 314     m_xResultSet = WeakReference<XResultSet>(xRs);
 315
 316     return xRs;
 317 }
 318 // -------------------------------------------------------------------------
 319
 320 Reference< XConnection > SAL_CALL OStatement_Base::getConnection(  ) throw(SQLException, RuntimeException)
 321 {
 322     ::osl::MutexGuard aGuard( m_aMutex );
 323     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 324
 325
 326     return (Reference< XConnection >)m_pConnection;
 327 }
 328 // -------------------------------------------------------------------------
 329
 330 Any SAL_CALL OStatement::queryInterface( const Type & rType ) throw(RuntimeException)
 331 {
 332     Any aRet = ::cppu::queryInterface(rType,static_cast< XBatchExecution*> (this));
 333     return aRet.hasValue() ? aRet : OStatement_Base::queryInterface(rType);
 334 }
 335 // -------------------------------------------------------------------------
 336
 337 void SAL_CALL OStatement::addBatch( const OUString& sql ) throw(SQLException, RuntimeException)
 338 {
 339     ::osl::MutexGuard aGuard( m_aMutex );
 340     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 341
 342
 343     m_aBatchList.push_back(sql);
 344 }
 345 // -------------------------------------------------------------------------
 346 Sequence< sal_Int32 > SAL_CALL OStatement::executeBatch(  ) throw(SQLException, RuntimeException)
 347 {
 348     ::osl::MutexGuard aGuard( m_aMutex );
 349     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 350
 351
 352     reset();
 353
 354     OUString aBatchSql;
 355     sal_Int32 nLen = 0;
 356     for(::std::list< OUString>::const_iterator i=m_aBatchList.begin();i != m_aBatchList.end();++i,++nLen)
 357         aBatchSql = aBatchSql + *i + OUString(";");
 358
 359
 360     if ( m_RecordSet.IsValid() )
 361         m_RecordSet.PutRefDataSource( NULL );
 362     m_RecordSet.clear();
 363     m_RecordSet.Create();
 364
 365     CHECK_RETURN(m_Command.put_CommandText(aBatchSql))
 366     if ( m_RecordSet.IsValid() )
 367         m_RecordSet.PutRefDataSource((IDispatch*)m_Command);
 368
 369     CHECK_RETURN(m_RecordSet.UpdateBatch(adAffectAll))
 370
 371     ADORecordset* pSet=NULL;
 372     Sequence< sal_Int32 > aRet(nLen);
 373     sal_Int32* pArray = aRet.getArray();
 374     for(sal_Int32 j=0;j<nLen;++j)
 375     {
 376         pSet = NULL;
 377         OLEVariant aRecordsAffected;
 378         if(m_RecordSet.NextRecordset(aRecordsAffected,&pSet) && pSet)
 379         {
 380             assignRecordSet( pSet );
 381
 382             ADO_LONGPTR nValue;
 383             if(m_RecordSet.get_RecordCount(nValue))
 384                 pArray[j] = nValue;
 385         }
 386     }
 387     return aRet;
 388 }
 389 // -------------------------------------------------------------------------
 390
 391
 392 sal_Int32 SAL_CALL OStatement_Base::executeUpdate( const OUString& sql ) throw(SQLException, RuntimeException)
 393 {
 394     ::osl::MutexGuard aGuard( m_aMutex );
 395     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 396
 397
 398     reset();
 399
 400     try {
 401         ADORecordset* pSet = NULL;
 402         CHECK_RETURN(m_Command.put_CommandText(sql))
 403         CHECK_RETURN(m_Command.Execute(m_RecordsAffected,m_Parameters,adCmdText|adExecuteNoRecords,&pSet))
 404     }
 405     catch (SQLWarning& ex) {
 406
 407         // Save pointer to warning and save with ResultSet
 408         // object once it is created.
 409
 410         m_aLastWarning = ex;
 411     }
 412     if(!m_RecordsAffected.isEmpty() && !m_RecordsAffected.isNull() && m_RecordsAffected.getType() != VT_ERROR)
 413         return m_RecordsAffected;
 414
 415     return 0;
 416 }
 417 // -------------------------------------------------------------------------
 418
 419 Reference< XResultSet > SAL_CALL OStatement_Base::getResultSet(  ) throw(SQLException, RuntimeException)
 420 {
 421     ::osl::MutexGuard aGuard( m_aMutex );
 422     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 423
 424
 425     return m_xResultSet;
 426 }
 427 // -------------------------------------------------------------------------
 428
 429 sal_Int32 SAL_CALL OStatement_Base::getUpdateCount(  ) throw(SQLException, RuntimeException)
 430 {
 431     ::osl::MutexGuard aGuard( m_aMutex );
 432     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 433
 434
 435     ADO_LONGPTR nRet;
 436     if(m_RecordSet.IsValid() && m_RecordSet.get_RecordCount(nRet))
 437         return nRet;
 438     return -1;
 439 }
 440 // -------------------------------------------------------------------------
 441
 442 sal_Bool SAL_CALL OStatement_Base::getMoreResults(  ) throw(SQLException, RuntimeException)
 443 {
 444     ::osl::MutexGuard aGuard( m_aMutex );
 445     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 446
 447
 448     SQLWarning  warning;
 449
 450     // clear previous warnings
 451
 452     clearWarnings ();
 453
 454     // Call SQLMoreResults
 455
 456     try
 457     {
 458         ADORecordset* pSet=NULL;
 459         OLEVariant aRecordsAffected;
 460         if(m_RecordSet.IsValid() && m_RecordSet.NextRecordset(aRecordsAffected,&pSet) && pSet)
 461             assignRecordSet( pSet );
 462     }
 463     catch (SQLWarning &ex)
 464     {
 465
 466         // Save pointer to warning and save with ResultSet
 467         // object once it is created.
 468
 469         warning = ex;
 470     }
 471     return m_RecordSet.IsValid();
 472 }
 473 // -------------------------------------------------------------------------
 474
 475 // -------------------------------------------------------------------------
 476 Any SAL_CALL OStatement_Base::getWarnings(  ) throw(SQLException, RuntimeException)
 477 {
 478     ::osl::MutexGuard aGuard( m_aMutex );
 479     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 480
 481
 482     return makeAny(m_aLastWarning);
 483 }
 484 // -------------------------------------------------------------------------
 485
 486 // -------------------------------------------------------------------------
 487 void SAL_CALL OStatement_Base::clearWarnings(  ) throw(SQLException, RuntimeException)
 488 {
 489     ::osl::MutexGuard aGuard( m_aMutex );
 490     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 491
 492
 493     m_aLastWarning = SQLWarning();
 494 }
 495 // -------------------------------------------------------------------------
 496 //------------------------------------------------------------------------------
 497 sal_Int32 OStatement_Base::getQueryTimeOut() const  throw(SQLException, RuntimeException)
 498 {
 499     return m_Command.get_CommandTimeout();
 500 }
 501 //------------------------------------------------------------------------------
 502 sal_Int32 OStatement_Base::getMaxRows() const throw(SQLException, RuntimeException)
 503 {
 504     ADO_LONGPTR nRet=-1;
 505     if(!(m_RecordSet.IsValid() && m_RecordSet.get_MaxRecords(nRet)))
 506         ::dbtools::throwFunctionSequenceException(NULL);
 507     return nRet;
 508 }
 509 //------------------------------------------------------------------------------
 510 sal_Int32 OStatement_Base::getResultSetConcurrency() const throw(SQLException, RuntimeException)
 511 {
 512     sal_Int32 nValue;
 513
 514     switch(m_eLockType)
 515     {
 516         case adLockReadOnly:
 517             nValue = ResultSetConcurrency::READ_ONLY;
 518             break;
 519         default:
 520             nValue = ResultSetConcurrency::UPDATABLE;
 521             break;
 522     }
 523
 524     return nValue;
 525 }
 526 //------------------------------------------------------------------------------
 527 sal_Int32 OStatement_Base::getResultSetType() const throw(SQLException, RuntimeException)
 528 {
 529     sal_Int32 nValue=0;
 530     switch(m_eCursorType)
 531     {
 532         case adOpenUnspecified:
 533         case adOpenForwardOnly:
 534             nValue = ResultSetType::FORWARD_ONLY;
 535             break;
 536         case adOpenStatic:
 537         case adOpenKeyset:
 538             nValue = ResultSetType::SCROLL_INSENSITIVE;
 539             break;
 540         case adOpenDynamic:
 541             nValue = ResultSetType::SCROLL_SENSITIVE;
 542             break;
 543     }
 544     return nValue;
 545 }
 546 //------------------------------------------------------------------------------
 547 sal_Int32 OStatement_Base::getFetchDirection() const throw(SQLException, RuntimeException)
 548 {
 549     return FetchDirection::FORWARD;
 550 }
 551 //------------------------------------------------------------------------------
 552 sal_Int32 OStatement_Base::getFetchSize() const throw(SQLException, RuntimeException)
 553 {
 554     return m_nFetchSize;
 555 }
 556 //------------------------------------------------------------------------------
 557 sal_Int32 OStatement_Base::getMaxFieldSize() const throw(SQLException, RuntimeException)
 558 {
 559     return 0;
 560 }
 561 //------------------------------------------------------------------------------
 562 OUString OStatement_Base::getCursorName() const throw(SQLException, RuntimeException)
 563 {
 564     return m_Command.GetName();
 565 }
 566 //------------------------------------------------------------------------------
 567 void OStatement_Base::setQueryTimeOut(sal_Int32 seconds) throw(SQLException, RuntimeException)
 568 {
 569     ::osl::MutexGuard aGuard( m_aMutex );
 570     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 571
 572
 573     m_Command.put_CommandTimeout(seconds);
 574 }
 575 //------------------------------------------------------------------------------
 576 void OStatement_Base::setMaxRows(sal_Int32 _par0) throw(SQLException, RuntimeException)
 577 {
 578     ::osl::MutexGuard aGuard( m_aMutex );
 579     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 580
 581     m_nMaxRows = _par0;
 582 }
 583 //------------------------------------------------------------------------------
 584 void OStatement_Base::setResultSetConcurrency(sal_Int32 _par0) throw(SQLException, RuntimeException)
 585 {
 586     ::osl::MutexGuard aGuard( m_aMutex );
 587     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 588
 589     switch(_par0)
 590     {
 591         case ResultSetConcurrency::READ_ONLY:
 592             m_eLockType = adLockReadOnly;
 593             break;
 594         default:
 595             m_eLockType = adLockOptimistic;
 596             break;
 597     }
 598 }
 599 //------------------------------------------------------------------------------
 600 void OStatement_Base::setResultSetType(sal_Int32 _par0) throw(SQLException, RuntimeException)
 601 {
 602     ::osl::MutexGuard aGuard( m_aMutex );
 603     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 604
 605
 606     switch(_par0)
 607     {
 608         case ResultSetType::FORWARD_ONLY:
 609             m_eCursorType = adOpenForwardOnly;
 610             break;
 611         case ResultSetType::SCROLL_INSENSITIVE:
 612             m_eCursorType = adOpenKeyset;
 613             break;
 614         case ResultSetType::SCROLL_SENSITIVE:
 615             m_eCursorType = adOpenDynamic;
 616             break;
 617     }
 618 }
 619 //------------------------------------------------------------------------------
 620 void OStatement_Base::setFetchDirection(sal_Int32 /*_par0*/) throw(SQLException, RuntimeException)
 621 {
 622     ::osl::MutexGuard aGuard( m_aMutex );
 623     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 624     ::dbtools::throwFeatureNotImplementedException( "Statement::FetchDirection", *this );
 625 }
 626 //------------------------------------------------------------------------------
 627 void OStatement_Base::setFetchSize(sal_Int32 _par0) throw(SQLException, RuntimeException)
 628 {
 629     ::osl::MutexGuard aGuard( m_aMutex );
 630     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 631
 632
 633     m_nFetchSize = _par0;
 634 }
 635 //------------------------------------------------------------------------------
 636 void OStatement_Base::setMaxFieldSize(sal_Int32 /*_par0*/) throw(SQLException, RuntimeException)
 637 {
 638     ::osl::MutexGuard aGuard( m_aMutex );
 639     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 640     ::dbtools::throwFeatureNotImplementedException( "Statement::MaxFieldSize", *this );
 641 }
 642 //------------------------------------------------------------------------------
 643 void OStatement_Base::setCursorName(const OUString &_par0) throw(SQLException, RuntimeException)
 644 {
 645     ::osl::MutexGuard aGuard( m_aMutex );
 646     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 647
 648     m_Command.put_Name(_par0);
 649 }
 650
 651 // -------------------------------------------------------------------------
 652 ::cppu::IPropertyArrayHelper* OStatement_Base::createArrayHelper( ) const
 653 {
 654     Sequence< com::sun::star::beans::Property > aProps(10);
 655     com::sun::star::beans::Property* pProperties = aProps.getArray();
 656     sal_Int32 nPos = 0;
 657     DECL_PROP0(CURSORNAME,  OUString);
 658     DECL_BOOL_PROP0(ESCAPEPROCESSING);
 659     DECL_PROP0(FETCHDIRECTION,sal_Int32);
 660     DECL_PROP0(FETCHSIZE,   sal_Int32);
 661     DECL_PROP0(MAXFIELDSIZE,sal_Int32);
 662     DECL_PROP0(MAXROWS,     sal_Int32);
 663     DECL_PROP0(QUERYTIMEOUT,sal_Int32);
 664     DECL_PROP0(RESULTSETCONCURRENCY,sal_Int32);
 665     DECL_PROP0(RESULTSETTYPE,sal_Int32);
 666     DECL_BOOL_PROP0(USEBOOKMARKS);
 667
 668
 669     return new ::cppu::OPropertyArrayHelper(aProps);
 670 }
 671
 672 // -------------------------------------------------------------------------
 673 ::cppu::IPropertyArrayHelper & OStatement_Base::getInfoHelper()
 674 {
 675     return *const_cast<OStatement_Base*>(this)->getArrayHelper();
 676 }
 677 // -------------------------------------------------------------------------
 678 sal_Bool OStatement_Base::convertFastPropertyValue(
 679                             Any & rConvertedValue,
 680                             Any & rOldValue,
 681                             sal_Int32 nHandle,
 682                             const Any& rValue )
 683                                 throw (::com::sun::star::lang::IllegalArgumentException)
 684 {
 685     sal_Bool bModified = sal_False;
 686
 687     sal_Bool bValidAdoRS = m_RecordSet.IsValid();
 688         // some of the properties below, when set, are remembered in a member, and applied in the next execute
 689         // For these properties, the record set does not need to be valid to allow setting them.
 690         // For all others (where the values are forwarded to the ADO RS directly), the recordset must be valid.
 691
 692     try
 693     {
 694         switch(nHandle)
 695         {
 696             case PROPERTY_ID_MAXROWS:
 697                 bModified = ::comphelper::tryPropertyValue( rConvertedValue, rOldValue, rValue, bValidAdoRS ? getMaxRows() : m_nMaxRows );
 698                 break;
 699
 700             case PROPERTY_ID_RESULTSETTYPE:
 701                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getResultSetType());
 702                 break;
 703             case PROPERTY_ID_FETCHSIZE:
 704                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchSize());
 705                 break;
 706             case PROPERTY_ID_RESULTSETCONCURRENCY:
 707                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getResultSetConcurrency());
 708                 break;
 709             case PROPERTY_ID_QUERYTIMEOUT:
 710                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getQueryTimeOut());
 711                 break;
 712             case PROPERTY_ID_MAXFIELDSIZE:
 713                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getMaxFieldSize());
 714                 break;
 715             case PROPERTY_ID_CURSORNAME:
 716                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getCursorName());
 717                 break;
 718             case PROPERTY_ID_FETCHDIRECTION:
 719                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchDirection());
 720                 break;
 721         }
 722     }
 723     catch( const Exception& e )
 724     {
 725         bModified = sal_True;   // will ensure that the property is set
 726         OSL_FAIL( "OStatement_Base::convertFastPropertyValue: caught something strange!" );
 727         (void)e;
 728     }
 729     return bModified;
 730 }
 731 // -------------------------------------------------------------------------
 732 void OStatement_Base::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue) throw (Exception)
 733 {
 734     switch(nHandle)
 735     {
 736         case PROPERTY_ID_QUERYTIMEOUT:
 737             setQueryTimeOut(comphelper::getINT32(rValue));
 738             break;
 739         case PROPERTY_ID_MAXFIELDSIZE:
 740             setMaxFieldSize(comphelper::getINT32(rValue));
 741             break;
 742         case PROPERTY_ID_MAXROWS:
 743             setMaxRows(comphelper::getINT32(rValue));
 744             break;
 745         case PROPERTY_ID_CURSORNAME:
 746             setCursorName(comphelper::getString(rValue));
 747             break;
 748         case PROPERTY_ID_RESULTSETCONCURRENCY:
 749             setResultSetConcurrency(comphelper::getINT32(rValue));
 750             break;
 751         case PROPERTY_ID_RESULTSETTYPE:
 752             setResultSetType(comphelper::getINT32(rValue));
 753             break;
 754         case PROPERTY_ID_FETCHDIRECTION:
 755             setFetchDirection(comphelper::getINT32(rValue));
 756             break;
 757         case PROPERTY_ID_FETCHSIZE:
 758             setFetchSize(comphelper::getINT32(rValue));
 759             break;
 760         case PROPERTY_ID_ESCAPEPROCESSING:
 761             //  return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_bAsLink);
 762         case PROPERTY_ID_USEBOOKMARKS:
 763             //  return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_bAsLink);
 764         default:
 765             ;
 766     }
 767 }
 768 // -------------------------------------------------------------------------
 769 void OStatement_Base::getFastPropertyValue(Any& rValue,sal_Int32 nHandle) const
 770 {
 771     switch(nHandle)
 772     {
 773         case PROPERTY_ID_QUERYTIMEOUT:
 774             rValue <<= getQueryTimeOut();
 775             break;
 776         case PROPERTY_ID_MAXFIELDSIZE:
 777             rValue <<= getMaxFieldSize();
 778             break;
 779         case PROPERTY_ID_MAXROWS:
 780             rValue <<= getMaxRows();
 781             break;
 782         case PROPERTY_ID_CURSORNAME:
 783             rValue <<= getCursorName();
 784             break;
 785         case PROPERTY_ID_RESULTSETCONCURRENCY:
 786             rValue <<= getResultSetConcurrency();
 787             break;
 788         case PROPERTY_ID_RESULTSETTYPE:
 789             rValue <<= getResultSetType();
 790             break;
 791         case PROPERTY_ID_FETCHDIRECTION:
 792             rValue <<= getFetchDirection();
 793             break;
 794         case PROPERTY_ID_FETCHSIZE:
 795             rValue <<= getFetchSize();
 796             break;
 797         case PROPERTY_ID_ESCAPEPROCESSING:
 798             rValue <<= sal_True;
 799             break;
 800         case PROPERTY_ID_USEBOOKMARKS:
 801         default:
 802             ;
 803     }
 804 }
 805 // -------------------------------------------------------------------------
 806 OStatement::~OStatement()
 807 {
 808 }
 809 IMPLEMENT_SERVICE_INFO(OStatement,"com.sun.star.sdbcx.AStatement","com.sun.star.sdbc.Statement");
 810 // -----------------------------------------------------------------------------
 811 void SAL_CALL OStatement_Base::acquire() throw()
 812 {
 813     OStatement_BASE::acquire();
 814 }
 815 // -----------------------------------------------------------------------------
 816 void SAL_CALL OStatement::acquire() throw()
 817 {
 818     OStatement_Base::acquire();
 819 }
 820 // -----------------------------------------------------------------------------
 821 void SAL_CALL OStatement::release() throw()
 822 {
 823     OStatement_Base::release();
 824 }
 825 // -----------------------------------------------------------------------------
 826 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL OStatement_Base::getPropertySetInfo(  ) throw(::com::sun::star::uno::RuntimeException)
 827 {
 828     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 829 }
 830
 831 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */