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