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 #include <rtl/ref.hxx>
  34
  35 #undef max
  36
  37 #include <algorithm>
  38 #include <numeric>
  39
  40 using namespace ::comphelper;
  41
  42 #define CHECK_RETURN(x)                                                 \
  43     if(!x)                                                              \
  44         ADOS::ThrowException(m_pConnection->getConnection(),*this);
  45
  46
  47 using namespace connectivity::ado;
  48
  49
  50 using namespace com::sun::star::uno;
  51 using namespace com::sun::star::lang;
  52 using namespace com::sun::star::beans;
  53 using namespace com::sun::star::sdbc;
  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({});
  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() noexcept
 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.set( _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     rtl::Reference<OResultSet> pSet = new OResultSet(aSet,this);
 309     pSet->construct();
 310
 311     m_xResultSet = WeakReference<XResultSet>(pSet);
 312
 313     return pSet;
 314 }
 315
 316
 317 Reference< XConnection > SAL_CALL OStatement_Base::getConnection(  )
 318 {
 319     ::osl::MutexGuard aGuard( m_aMutex );
 320     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 321
 322
 323     return static_cast<Reference< XConnection >>(m_pConnection);
 324 }
 325
 326
 327 Any SAL_CALL OStatement::queryInterface( const Type & rType )
 328 {
 329     Any aRet = ::cppu::queryInterface(rType,static_cast< XBatchExecution*> (this));
 330     return aRet.hasValue() ? aRet : OStatement_Base::queryInterface(rType);
 331 }
 332
 333
 334 void SAL_CALL OStatement::addBatch( const OUString& sql )
 335 {
 336     ::osl::MutexGuard aGuard( m_aMutex );
 337     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 338
 339
 340     m_aBatchVector.push_back(sql);
 341 }
 342
 343 Sequence< sal_Int32 > SAL_CALL OStatement::executeBatch(  )
 344 {
 345     ::osl::MutexGuard aGuard( m_aMutex );
 346     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 347
 348
 349     reset();
 350
 351     OUString aBatchSql = std::accumulate(m_aBatchVector.begin(), m_aBatchVector.end(), OUString(),
 352         [](const OUString& rRes, const OUString& rStr) { return rRes + rStr + ";"; });
 353     sal_Int32 nLen = m_aBatchVector.size();
 354
 355
 356     if ( m_RecordSet.IsValid() )
 357         m_RecordSet.PutRefDataSource( nullptr );
 358     m_RecordSet.clear();
 359     m_RecordSet.Create();
 360
 361     CHECK_RETURN(m_Command.put_CommandText(aBatchSql))
 362     if ( m_RecordSet.IsValid() )
 363         m_RecordSet.PutRefDataSource(static_cast<IDispatch*>(m_Command));
 364
 365     CHECK_RETURN(m_RecordSet.UpdateBatch(adAffectAll))
 366
 367     ADORecordset* pSet=nullptr;
 368     Sequence< sal_Int32 > aRet(nLen);
 369     sal_Int32* pArray = aRet.getArray();
 370     for(sal_Int32 j=0;j<nLen;++j)
 371     {
 372         pSet = nullptr;
 373         OLEVariant aRecordsAffected;
 374         if(m_RecordSet.NextRecordset(aRecordsAffected,&pSet) && pSet)
 375         {
 376             assignRecordSet( pSet );
 377
 378             ADO_LONGPTR nValue;
 379             if(m_RecordSet.get_RecordCount(nValue))
 380                 pArray[j] = nValue;
 381         }
 382     }
 383     return aRet;
 384 }
 385
 386
 387 sal_Int32 SAL_CALL OStatement_Base::executeUpdate( const OUString& sql )
 388 {
 389     ::osl::MutexGuard aGuard( m_aMutex );
 390     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 391
 392
 393     reset();
 394
 395     try {
 396         ADORecordset* pSet = nullptr;
 397         CHECK_RETURN(m_Command.put_CommandText(sql))
 398         CHECK_RETURN(m_Command.Execute(m_RecordsAffected,m_Parameters,long(adCmdText)|long(adExecuteNoRecords),&pSet))
 399     }
 400     catch (SQLWarning& ex) {
 401
 402         // Save pointer to warning and save with ResultSet
 403         // object once it is created.
 404
 405         m_aLastWarning = ex;
 406     }
 407     if(!m_RecordsAffected.isEmpty() && !m_RecordsAffected.isNull() && m_RecordsAffected.getType() != VT_ERROR)
 408         return m_RecordsAffected.getInt32();
 409
 410     return 0;
 411 }
 412
 413
 414 Reference< XResultSet > SAL_CALL OStatement_Base::getResultSet(  )
 415 {
 416     ::osl::MutexGuard aGuard( m_aMutex );
 417     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 418
 419
 420     return m_xResultSet;
 421 }
 422
 423
 424 sal_Int32 SAL_CALL OStatement_Base::getUpdateCount(  )
 425 {
 426     ::osl::MutexGuard aGuard( m_aMutex );
 427     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 428
 429
 430     ADO_LONGPTR nRet;
 431     if(m_RecordSet.IsValid() && m_RecordSet.get_RecordCount(nRet))
 432         return nRet;
 433     return -1;
 434 }
 435
 436
 437 sal_Bool SAL_CALL OStatement_Base::getMoreResults(  )
 438 {
 439     ::osl::MutexGuard aGuard( m_aMutex );
 440     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 441
 442
 443     // clear previous warnings
 444
 445     clearWarnings ();
 446
 447     // Call SQLMoreResults
 448
 449     try
 450     {
 451         ADORecordset* pSet=nullptr;
 452         OLEVariant aRecordsAffected;
 453         if(m_RecordSet.IsValid() && m_RecordSet.NextRecordset(aRecordsAffected,&pSet) && pSet)
 454             assignRecordSet( pSet );
 455     }
 456     catch (SQLWarning &)
 457     {
 458
 459         //TODO: Save pointer to warning and save with ResultSet
 460         // object once it is created.
 461     }
 462     return m_RecordSet.IsValid();
 463 }
 464
 465
 466 Any SAL_CALL OStatement_Base::getWarnings(  )
 467 {
 468     ::osl::MutexGuard aGuard( m_aMutex );
 469     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 470
 471
 472     return Any(m_aLastWarning);
 473 }
 474
 475
 476 void SAL_CALL OStatement_Base::clearWarnings(  )
 477 {
 478     ::osl::MutexGuard aGuard( m_aMutex );
 479     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 480
 481
 482     m_aLastWarning = SQLWarning();
 483 }
 484
 485
 486 sal_Int32 OStatement_Base::getQueryTimeOut() const
 487 {
 488     return m_Command.get_CommandTimeout();
 489 }
 490
 491 sal_Int32 OStatement_Base::getMaxRows() const
 492 {
 493     ADO_LONGPTR nRet=-1;
 494     if(!(m_RecordSet.IsValid() && m_RecordSet.get_MaxRecords(nRet)))
 495         ::dbtools::throwFunctionSequenceException(nullptr);
 496     return nRet;
 497 }
 498
 499 sal_Int32 OStatement_Base::getResultSetConcurrency() const
 500 {
 501     sal_Int32 nValue;
 502
 503     switch(m_eLockType)
 504     {
 505         case adLockReadOnly:
 506             nValue = ResultSetConcurrency::READ_ONLY;
 507             break;
 508         default:
 509             nValue = ResultSetConcurrency::UPDATABLE;
 510             break;
 511     }
 512
 513     return nValue;
 514 }
 515
 516 sal_Int32 OStatement_Base::getResultSetType() const
 517 {
 518     sal_Int32 nValue=0;
 519     switch(m_eCursorType)
 520     {
 521         case adOpenUnspecified:
 522         case adOpenForwardOnly:
 523             nValue = ResultSetType::FORWARD_ONLY;
 524             break;
 525         case adOpenStatic:
 526         case adOpenKeyset:
 527             nValue = ResultSetType::SCROLL_INSENSITIVE;
 528             break;
 529         case adOpenDynamic:
 530             nValue = ResultSetType::SCROLL_SENSITIVE;
 531             break;
 532     }
 533     return nValue;
 534 }
 535
 536 sal_Int32 OStatement_Base::getFetchDirection()
 537 {
 538     return FetchDirection::FORWARD;
 539 }
 540
 541 sal_Int32 OStatement_Base::getFetchSize() const
 542 {
 543     return m_nFetchSize;
 544 }
 545
 546 sal_Int32 OStatement_Base::getMaxFieldSize()
 547 {
 548     return 0;
 549 }
 550
 551 OUString OStatement_Base::getCursorName() const
 552 {
 553     return m_Command.GetName();
 554 }
 555
 556 void OStatement_Base::setQueryTimeOut(sal_Int32 seconds)
 557 {
 558     ::osl::MutexGuard aGuard( m_aMutex );
 559     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 560
 561
 562     m_Command.put_CommandTimeout(seconds);
 563 }
 564
 565 void OStatement_Base::setMaxRows(sal_Int32 _par0)
 566 {
 567     ::osl::MutexGuard aGuard( m_aMutex );
 568     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 569
 570     m_nMaxRows = _par0;
 571 }
 572
 573 void OStatement_Base::setResultSetConcurrency(sal_Int32 _par0)
 574 {
 575     ::osl::MutexGuard aGuard( m_aMutex );
 576     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 577
 578     switch(_par0)
 579     {
 580         case ResultSetConcurrency::READ_ONLY:
 581             m_eLockType = adLockReadOnly;
 582             break;
 583         default:
 584             m_eLockType = adLockOptimistic;
 585             break;
 586     }
 587 }
 588
 589 void OStatement_Base::setResultSetType(sal_Int32 _par0)
 590 {
 591     ::osl::MutexGuard aGuard( m_aMutex );
 592     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 593
 594
 595     switch(_par0)
 596     {
 597         case ResultSetType::FORWARD_ONLY:
 598             m_eCursorType = adOpenForwardOnly;
 599             break;
 600         case ResultSetType::SCROLL_INSENSITIVE:
 601             m_eCursorType = adOpenKeyset;
 602             break;
 603         case ResultSetType::SCROLL_SENSITIVE:
 604             m_eCursorType = adOpenDynamic;
 605             break;
 606     }
 607 }
 608
 609 void OStatement_Base::setFetchDirection(sal_Int32 /*_par0*/)
 610 {
 611     ::osl::MutexGuard aGuard( m_aMutex );
 612     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 613     ::dbtools::throwFeatureNotImplementedSQLException( "Statement::FetchDirection", *this );
 614 }
 615
 616 void OStatement_Base::setFetchSize(sal_Int32 _par0)
 617 {
 618     ::osl::MutexGuard aGuard( m_aMutex );
 619     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 620
 621
 622     m_nFetchSize = _par0;
 623 }
 624
 625 void OStatement_Base::setMaxFieldSize(sal_Int32 /*_par0*/)
 626 {
 627     ::osl::MutexGuard aGuard( m_aMutex );
 628     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 629     ::dbtools::throwFeatureNotImplementedSQLException( "Statement::MaxFieldSize", *this );
 630 }
 631
 632 void OStatement_Base::setCursorName(std::u16string_view _par0)
 633 {
 634     ::osl::MutexGuard aGuard( m_aMutex );
 635     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 636
 637     m_Command.put_Name(_par0);
 638 }
 639
 640
 641 ::cppu::IPropertyArrayHelper* OStatement_Base::createArrayHelper( ) const
 642 {
 643     return new ::cppu::OPropertyArrayHelper
 644     {
 645         {
 646             {
 647                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CURSORNAME),
 648                 PROPERTY_ID_CURSORNAME,
 649                 cppu::UnoType<OUString>::get(),
 650                 0
 651             },
 652             {
 653                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ESCAPEPROCESSING),
 654                 PROPERTY_ID_ESCAPEPROCESSING,
 655                 cppu::UnoType<bool>::get(),
 656                 0
 657             },
 658             {
 659                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHDIRECTION),
 660                 PROPERTY_ID_FETCHDIRECTION,
 661                 cppu::UnoType<sal_Int32>::get(),
 662                 0
 663             },
 664             {
 665                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHSIZE),
 666                 PROPERTY_ID_FETCHSIZE,
 667                 cppu::UnoType<sal_Int32>::get(),
 668                 0
 669             },
 670             {
 671                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_MAXFIELDSIZE),
 672                 PROPERTY_ID_MAXFIELDSIZE,
 673                 cppu::UnoType<sal_Int32>::get(),
 674                 0
 675             },
 676             {
 677                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_MAXROWS),
 678                 PROPERTY_ID_MAXROWS,
 679                 cppu::UnoType<sal_Int32>::get(),
 680                 0
 681             },
 682             {
 683                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_QUERYTIMEOUT),
 684                 PROPERTY_ID_QUERYTIMEOUT,
 685                 cppu::UnoType<sal_Int32>::get(),
 686                 0
 687             },
 688             {
 689                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETCONCURRENCY),
 690                 PROPERTY_ID_RESULTSETCONCURRENCY,
 691                 cppu::UnoType<sal_Int32>::get(),
 692                 0
 693             },
 694             {
 695                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETTYPE),
 696                 PROPERTY_ID_RESULTSETTYPE,
 697                 cppu::UnoType<sal_Int32>::get(),
 698                 0
 699             },
 700             {
 701                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_USEBOOKMARKS),
 702                 PROPERTY_ID_USEBOOKMARKS,
 703                 cppu::UnoType<bool>::get(),
 704                 0
 705             }
 706         }
 707     };
 708 }
 709
 710
 711 ::cppu::IPropertyArrayHelper & OStatement_Base::getInfoHelper()
 712 {
 713     return *getArrayHelper();
 714 }
 715
 716 sal_Bool OStatement_Base::convertFastPropertyValue(
 717                             Any & rConvertedValue,
 718                             Any & rOldValue,
 719                             sal_Int32 nHandle,
 720                             const Any& rValue )
 721 {
 722     bool bModified = false;
 723
 724     bool bValidAdoRS = m_RecordSet.IsValid();
 725         // some of the properties below, when set, are remembered in a member, and applied in the next execute
 726         // For these properties, the record set does not need to be valid to allow setting them.
 727         // For all others (where the values are forwarded to the ADO RS directly), the recordset must be valid.
 728
 729     try
 730     {
 731         switch(nHandle)
 732         {
 733             case PROPERTY_ID_MAXROWS:
 734                 bModified = ::comphelper::tryPropertyValue( rConvertedValue, rOldValue, rValue, bValidAdoRS ? getMaxRows() : m_nMaxRows );
 735                 break;
 736
 737             case PROPERTY_ID_RESULTSETTYPE:
 738                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getResultSetType());
 739                 break;
 740             case PROPERTY_ID_FETCHSIZE:
 741                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchSize());
 742                 break;
 743             case PROPERTY_ID_RESULTSETCONCURRENCY:
 744                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getResultSetConcurrency());
 745                 break;
 746             case PROPERTY_ID_QUERYTIMEOUT:
 747                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getQueryTimeOut());
 748                 break;
 749             case PROPERTY_ID_MAXFIELDSIZE:
 750                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getMaxFieldSize());
 751                 break;
 752             case PROPERTY_ID_CURSORNAME:
 753                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getCursorName());
 754                 break;
 755             case PROPERTY_ID_FETCHDIRECTION:
 756                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchDirection());
 757                 break;
 758         }
 759     }
 760     catch( const Exception& )
 761     {
 762         bModified = true;   // will ensure that the property is set
 763         OSL_FAIL( "OStatement_Base::convertFastPropertyValue: caught something strange!" );
 764     }
 765     return bModified;
 766 }
 767
 768 void OStatement_Base::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue)
 769 {
 770     switch(nHandle)
 771     {
 772         case PROPERTY_ID_QUERYTIMEOUT:
 773             setQueryTimeOut(comphelper::getINT32(rValue));
 774             break;
 775         case PROPERTY_ID_MAXFIELDSIZE:
 776             setMaxFieldSize(comphelper::getINT32(rValue));
 777             break;
 778         case PROPERTY_ID_MAXROWS:
 779             setMaxRows(comphelper::getINT32(rValue));
 780             break;
 781         case PROPERTY_ID_CURSORNAME:
 782             setCursorName(comphelper::getString(rValue));
 783             break;
 784         case PROPERTY_ID_RESULTSETCONCURRENCY:
 785             setResultSetConcurrency(comphelper::getINT32(rValue));
 786             break;
 787         case PROPERTY_ID_RESULTSETTYPE:
 788             setResultSetType(comphelper::getINT32(rValue));
 789             break;
 790         case PROPERTY_ID_FETCHDIRECTION:
 791             setFetchDirection(comphelper::getINT32(rValue));
 792             break;
 793         case PROPERTY_ID_FETCHSIZE:
 794             setFetchSize(comphelper::getINT32(rValue));
 795             break;
 796         case PROPERTY_ID_ESCAPEPROCESSING:
 797             //  return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_bAsLink);
 798         case PROPERTY_ID_USEBOOKMARKS:
 799             //  return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_bAsLink);
 800         default:
 801             ;
 802     }
 803 }
 804
 805 void OStatement_Base::getFastPropertyValue(Any& rValue,sal_Int32 nHandle) const
 806 {
 807     switch(nHandle)
 808     {
 809         case PROPERTY_ID_QUERYTIMEOUT:
 810             rValue <<= getQueryTimeOut();
 811             break;
 812         case PROPERTY_ID_MAXFIELDSIZE:
 813             rValue <<= getMaxFieldSize();
 814             break;
 815         case PROPERTY_ID_MAXROWS:
 816             rValue <<= getMaxRows();
 817             break;
 818         case PROPERTY_ID_CURSORNAME:
 819             rValue <<= getCursorName();
 820             break;
 821         case PROPERTY_ID_RESULTSETCONCURRENCY:
 822             rValue <<= getResultSetConcurrency();
 823             break;
 824         case PROPERTY_ID_RESULTSETTYPE:
 825             rValue <<= getResultSetType();
 826             break;
 827         case PROPERTY_ID_FETCHDIRECTION:
 828             rValue <<= getFetchDirection();
 829             break;
 830         case PROPERTY_ID_FETCHSIZE:
 831             rValue <<= getFetchSize();
 832             break;
 833         case PROPERTY_ID_ESCAPEPROCESSING:
 834             rValue <<= true;
 835             break;
 836         case PROPERTY_ID_USEBOOKMARKS:
 837         default:
 838             ;
 839     }
 840 }
 841
 842 OStatement::~OStatement()
 843 {
 844 }
 845 IMPLEMENT_SERVICE_INFO(OStatement,"com.sun.star.sdbcx.AStatement","com.sun.star.sdbc.Statement");
 846
 847 void SAL_CALL OStatement_Base::acquire() noexcept
 848 {
 849     OStatement_BASE::acquire();
 850 }
 851
 852 void SAL_CALL OStatement::acquire() noexcept
 853 {
 854     OStatement_Base::acquire();
 855 }
 856
 857 void SAL_CALL OStatement::release() noexcept
 858 {
 859     OStatement_Base::release();
 860 }
 861
 862 css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL OStatement_Base::getPropertySetInfo(  )
 863 {
 864     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 865 }
 866
 867 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */