connectivity/source/drivers/odbc/OStatement.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
  21 #include <osl/diagnose.h>
  22 #include <odbc/OStatement.hxx>
  23 #include <odbc/OConnection.hxx>
  24 #include <odbc/OResultSet.hxx>
  25 #include <comphelper/property.hxx>
  26 #include <odbc/OTools.hxx>
  27 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
  28 #include <com/sun/star/sdbc/ResultSetType.hpp>
  29 #include <com/sun/star/sdbc/FetchDirection.hpp>
  30 #include <com/sun/star/lang/DisposedException.hpp>
  31 #include <comphelper/sequence.hxx>
  32 #include <cppuhelper/typeprovider.hxx>
  33 #include <cppuhelper/queryinterface.hxx>
  34 #include <comphelper/types.hxx>
  35 #include <rtl/strbuf.hxx>
  36 #include <algorithm>
  37 #include <strings.hrc>
  38 #include <connectivity/dbexception.hxx>
  39
  40 using namespace ::comphelper;
  41
  42 #define THROW_SQL(x) \
  43     OTools::ThrowException(m_pConnection.get(),x,m_aStatementHandle,SQL_HANDLE_STMT,*this)
  44
  45
  46 using namespace connectivity::odbc;
  47
  48 using namespace com::sun::star::uno;
  49 using namespace com::sun::star::lang;
  50 using namespace com::sun::star::beans;
  51 using namespace com::sun::star::sdbc;
  52 using namespace com::sun::star::sdbcx;
  53 using namespace com::sun::star::container;
  54 using namespace com::sun::star::io;
  55 using namespace com::sun::star::util;
  56
  57 OStatement_Base::OStatement_Base(OConnection* _pConnection )
  58     :OStatement_BASE(m_aMutex)
  59     ,OPropertySetHelper(OStatement_BASE::rBHelper)
  60     ,m_pConnection(_pConnection)
  61     ,m_aStatementHandle(SQL_NULL_HANDLE)
  62     ,m_pRowStatusArray(nullptr)
  63 {
  64     osl_atomic_increment( &m_refCount );
  65     m_aStatementHandle = m_pConnection->createStatementHandle();
  66
  67     //setMaxFieldSize(0);
  68     // Don't do this. By ODBC spec, "0" is the default for the SQL_ATTR_MAX_LENGTH attribute. We once introduced
  69     // this line since a PostgreSQL ODBC driver had a default other than 0. However, current drivers (at least 8.3
  70     // and later) have a proper default of 0, so there should be no need anymore.
  71     // On the other hand, the NotesSQL driver (IBM's ODBC driver for the Lotus Notes series) wrongly interprets
  72     // "0" as "0", whereas the ODBC spec says it should in fact mean "unlimited".
  73     // So, removing this line seems to be the best option for now.
  74     // If we ever again encounter an ODBC driver which needs this option, then we should introduce a data source
  75     // setting for it, instead of unconditionally doing it.
  76
  77     osl_atomic_decrement( &m_refCount );
  78 }
  79
  80 OStatement_Base::~OStatement_Base()
  81 {
  82     OSL_ENSURE(!m_aStatementHandle,"Sohould ne null here!");
  83 }
  84
  85 void OStatement_Base::disposeResultSet()
  86 {
  87     // free the cursor if alive
  88     Reference< XComponent > xComp(m_xResultSet.get(), UNO_QUERY);
  89     if (xComp.is())
  90         xComp->dispose();
  91     m_xResultSet.clear();
  92 }
  93
  94 void SAL_CALL OStatement_Base::disposing()
  95 {
  96     ::osl::MutexGuard aGuard(m_aMutex);
  97
  98     disposeResultSet();
  99     ::comphelper::disposeComponent(m_xGeneratedStatement);
 100
 101     OSL_ENSURE(m_aStatementHandle,"OStatement_BASE2::disposing: StatementHandle is null!");
 102     if (m_pConnection.is())
 103     {
 104         m_pConnection->freeStatementHandle(m_aStatementHandle);
 105         m_pConnection.clear();
 106     }
 107     OSL_ENSURE(!m_aStatementHandle,"Sohould ne null here!");
 108
 109     OStatement_BASE::disposing();
 110 }
 111
 112 void OStatement_BASE2::disposing()
 113 {
 114     ::osl::MutexGuard aGuard1(m_aMutex);
 115     OStatement_Base::disposing();
 116 }
 117
 118 Any SAL_CALL OStatement_Base::queryInterface( const Type & rType )
 119 {
 120     if ( m_pConnection.is() && !m_pConnection->isAutoRetrievingEnabled() && rType == cppu::UnoType<XGeneratedResultSet>::get())
 121         return Any();
 122     Any aRet = OStatement_BASE::queryInterface(rType);
 123     return aRet.hasValue() ? aRet : OPropertySetHelper::queryInterface(rType);
 124 }
 125
 126 Sequence< Type > SAL_CALL OStatement_Base::getTypes(  )
 127 {
 128     ::cppu::OTypeCollection aTypes( cppu::UnoType<XMultiPropertySet>::get(),
 129                                     cppu::UnoType<XFastPropertySet>::get(),
 130                                     cppu::UnoType<XPropertySet>::get());
 131     Sequence< Type > aOldTypes = OStatement_BASE::getTypes();
 132     if ( m_pConnection.is() && !m_pConnection->isAutoRetrievingEnabled() )
 133     {
 134         auto newEnd = std::remove(aOldTypes.begin(), aOldTypes.end(),
 135                                   cppu::UnoType<XGeneratedResultSet>::get());
 136         aOldTypes.realloc(std::distance(aOldTypes.begin(), newEnd));
 137     }
 138
 139     return ::comphelper::concatSequences(aTypes.getTypes(),aOldTypes);
 140 }
 141
 142 Reference< XResultSet > SAL_CALL OStatement_Base::getGeneratedValues(  )
 143 {
 144     OSL_ENSURE( m_pConnection.is() && m_pConnection->isAutoRetrievingEnabled(),"Illegal call here. isAutoRetrievingEnabled is false!");
 145     Reference< XResultSet > xRes;
 146     if ( m_pConnection.is() )
 147     {
 148         OUString sStmt = m_pConnection->getTransformedGeneratedStatement(m_sSqlStatement);
 149         if ( !sStmt.isEmpty() )
 150         {
 151             ::comphelper::disposeComponent(m_xGeneratedStatement);
 152             m_xGeneratedStatement = m_pConnection->createStatement();
 153             xRes = m_xGeneratedStatement->executeQuery(sStmt);
 154         }
 155     }
 156     return xRes;
 157 }
 158
 159 void SAL_CALL OStatement_Base::cancel(  )
 160 {
 161     ::osl::MutexGuard aGuard( m_aMutex );
 162     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 163
 164     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 165     N3SQLCancel(m_aStatementHandle);
 166 }
 167
 168
 169 void SAL_CALL OStatement_Base::close(  )
 170 {
 171     {
 172         ::osl::MutexGuard aGuard( m_aMutex );
 173         checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 174
 175     }
 176     dispose();
 177 }
 178
 179
 180 void SAL_CALL OStatement::clearBatch(  )
 181 {
 182
 183 }
 184
 185 void OStatement_Base::reset()
 186 {
 187     ::osl::MutexGuard aGuard( m_aMutex );
 188     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 189
 190
 191     clearWarnings ();
 192
 193     if (m_xResultSet.get().is())
 194     {
 195         clearMyResultSet();
 196     }
 197     if(m_aStatementHandle)
 198     {
 199         THROW_SQL(N3SQLFreeStmt(m_aStatementHandle, SQL_CLOSE));
 200     }
 201 }
 202
 203 // clearMyResultSet
 204 // If a ResultSet was created for this Statement, close it
 205 void OStatement_Base::clearMyResultSet()
 206 {
 207     ::osl::MutexGuard aGuard( m_aMutex );
 208     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 209
 210     try
 211     {
 212         Reference<XCloseable> xCloseable(
 213             m_xResultSet.get(), css::uno::UNO_QUERY);
 214         if ( xCloseable.is() )
 215             xCloseable->close();
 216     }
 217     catch( const DisposedException& ) { }
 218
 219     m_xResultSet.clear();
 220 }
 221
 222 SQLLEN OStatement_Base::getRowCount()
 223 {
 224     ::osl::MutexGuard aGuard( m_aMutex );
 225     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 226
 227
 228     SQLLEN numRows = 0;
 229
 230     try {
 231         THROW_SQL(N3SQLRowCount(m_aStatementHandle,&numRows));
 232     }
 233     catch (const SQLException&)
 234     {
 235     }
 236     return numRows;
 237 }
 238
 239 // lockIfNecessary
 240 // If the given SQL statement contains a 'FOR UPDATE' clause, change
 241 // the concurrency to lock so that the row can then be updated.  Returns
 242 // true if the concurrency has been changed
 243 bool OStatement_Base::lockIfNecessary (const OUString& sql)
 244 {
 245     bool rc = false;
 246
 247     // First, convert the statement to upper case
 248
 249     OUString sqlStatement = sql.toAsciiUpperCase ();
 250
 251     // Now, look for the FOR UPDATE keywords.  If there is any extra white
 252     // space between the FOR and UPDATE, this will fail.
 253
 254     sal_Int32 index = sqlStatement.indexOf(" FOR UPDATE");
 255
 256     // We found it.  Change our concurrency level to ensure that the
 257     // row can be updated.
 258
 259     if (index > 0)
 260     {
 261         OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 262         try
 263         {
 264             THROW_SQL((setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CONCURRENCY, SQL_CONCUR_LOCK)));
 265         }
 266         catch (const SQLWarning& warn)
 267         {
 268             // Catch any warnings and place on the warning stack
 269             setWarning (warn);
 270         }
 271         rc = true;
 272     }
 273
 274     return rc;
 275 }
 276
 277 // setWarning
 278 // Sets the warning
 279
 280
 281 void OStatement_Base::setWarning (const SQLWarning &ex)
 282 {
 283     ::osl::MutexGuard aGuard( m_aMutex );
 284     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 285
 286
 287     m_aLastWarning = ex;
 288 }
 289
 290
 291 // getColumnCount
 292 // Return the number of columns in the ResultSet
 293 sal_Int32 OStatement_Base::getColumnCount()
 294 {
 295     ::osl::MutexGuard aGuard( m_aMutex );
 296     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 297
 298
 299     sal_Int16   numCols = 0;
 300     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 301
 302     try {
 303         THROW_SQL(N3SQLNumResultCols(m_aStatementHandle,&numCols));
 304     }
 305     catch (const SQLException&)
 306     {
 307     }
 308     return numCols;
 309 }
 310
 311
 312 sal_Bool SAL_CALL OStatement_Base::execute( const OUString& sql )
 313 {
 314     ::osl::MutexGuard aGuard( m_aMutex );
 315     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 316     m_sSqlStatement = sql;
 317
 318
 319     OString aSql(OUStringToOString(sql,getOwnConnection()->getTextEncoding()));
 320
 321     bool hasResultSet = false;
 322
 323     // Reset the statement handle and warning
 324
 325     reset();
 326
 327     // Check for a 'FOR UPDATE' statement.  If present, change
 328     // the concurrency to lock
 329
 330     lockIfNecessary (sql);
 331
 332     // Call SQLExecDirect
 333     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 334
 335     try {
 336         THROW_SQL(N3SQLExecDirect(m_aStatementHandle, reinterpret_cast<SDB_ODBC_CHAR *>(const_cast<char *>(aSql.getStr())), aSql.getLength()));
 337     }
 338     catch (const SQLWarning&) {
 339
 340         //TODO: Save pointer to warning and save with ResultSet
 341         // object once it is created.
 342     }
 343
 344     // Now determine if there is a result set associated with
 345     // the SQL statement that was executed.  Get the column
 346     // count, and if it is not zero, there is a result set.
 347
 348     if (getColumnCount () > 0)
 349     {
 350         hasResultSet = true;
 351     }
 352
 353     return hasResultSet;
 354 }
 355
 356 // getResultSet
 357 // getResultSet returns the current result as a ResultSet.  It
 358 // returns NULL if the current result is not a ResultSet.
 359
 360 Reference< XResultSet > OStatement_Base::getResultSet(bool checkCount)
 361 {
 362     ::osl::MutexGuard aGuard( m_aMutex );
 363     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 364
 365
 366     if (m_xResultSet.get().is())  // if resultset already retrieved,
 367     {
 368         // throw exception to avoid sequence error
 369         ::dbtools::throwFunctionSequenceException(*this);
 370     }
 371
 372     rtl::Reference<OResultSet> pRs;
 373     sal_Int32 numCols = 1;
 374
 375     // If we already know we have result columns, checkCount
 376     // is false.  This is an optimization to prevent unneeded
 377     // calls to getColumnCount
 378
 379     if (checkCount)
 380         numCols = getColumnCount ();
 381
 382     // Only return a result set if there are result columns
 383
 384     if (numCols > 0)
 385     {
 386         OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 387         pRs = createResultSet();
 388         pRs->construct();
 389
 390         // Save a copy of our last result set
 391         // Changed to save copy at getResultSet.
 392         //m_xResultSet = rs;
 393     }
 394     else
 395         clearMyResultSet ();
 396
 397     return pRs;
 398 }
 399
 400 // getStmtOption
 401 // Invoke SQLGetStmtOption with the given option.
 402
 403
 404 template < typename T, SQLINTEGER BufferLength > T OStatement_Base::getStmtOption (SQLINTEGER fOption) const
 405 {
 406     T result (0);
 407     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 408     N3SQLGetStmtAttr(m_aStatementHandle, fOption, &result, BufferLength, nullptr);
 409     return result;
 410 }
 411 template < typename T, SQLINTEGER BufferLength > SQLRETURN OStatement_Base::setStmtOption (SQLINTEGER fOption, T value) const
 412 {
 413     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 414     SQLPOINTER sv = reinterpret_cast<SQLPOINTER>(value);
 415     return N3SQLSetStmtAttr(m_aStatementHandle, fOption, sv, BufferLength);
 416 }
 417
 418
 419 Reference< XResultSet > SAL_CALL OStatement_Base::executeQuery( const OUString& sql )
 420 {
 421     ::osl::MutexGuard aGuard( m_aMutex );
 422     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 423
 424
 425     Reference< XResultSet > xRS;
 426
 427     // Execute the statement.  If execute returns true, a result
 428     // set exists.
 429
 430     if (execute (sql))
 431     {
 432         xRS = getResultSet (false);
 433         m_xResultSet = xRS;
 434     }
 435     else
 436     {
 437         // No ResultSet was produced.  Raise an exception
 438         m_pConnection->throwGenericSQLException(STR_NO_RESULTSET,*this);
 439     }
 440     return xRS;
 441 }
 442
 443
 444 Reference< XConnection > SAL_CALL OStatement_Base::getConnection(  )
 445 {
 446     ::osl::MutexGuard aGuard( m_aMutex );
 447     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 448
 449     return m_pConnection;
 450 }
 451
 452
 453 Any SAL_CALL OStatement::queryInterface( const Type & rType )
 454 {
 455     Any aRet = ::cppu::queryInterface(rType,static_cast< XBatchExecution*> (this));
 456     return aRet.hasValue() ? aRet : OStatement_Base::queryInterface(rType);
 457 }
 458
 459
 460 void SAL_CALL OStatement::addBatch( const OUString& sql )
 461 {
 462     ::osl::MutexGuard aGuard( m_aMutex );
 463     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 464
 465
 466     m_aBatchVector.push_back(sql);
 467 }
 468
 469 Sequence< sal_Int32 > SAL_CALL OStatement::executeBatch(  )
 470 {
 471     ::osl::MutexGuard aGuard( m_aMutex );
 472     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 473
 474     OStringBuffer aBatchSql;
 475     sal_Int32 nLen = m_aBatchVector.size();
 476
 477     for (auto const& elem : m_aBatchVector)
 478     {
 479         aBatchSql.append(OUStringToOString(elem,getOwnConnection()->getTextEncoding()));
 480         aBatchSql.append(";");
 481     }
 482
 483     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 484     auto s = aBatchSql.makeStringAndClear();
 485     THROW_SQL(N3SQLExecDirect(m_aStatementHandle, reinterpret_cast<SDB_ODBC_CHAR *>(const_cast<char *>(s.getStr())), s.getLength()));
 486
 487     Sequence< sal_Int32 > aRet(nLen);
 488     sal_Int32* pArray = aRet.getArray();
 489     for(sal_Int32 j=0;j<nLen;++j)
 490     {
 491         SQLRETURN nError = N3SQLMoreResults(m_aStatementHandle);
 492         if(nError == SQL_SUCCESS)
 493         {
 494             SQLLEN nRowCount=0;
 495             N3SQLRowCount(m_aStatementHandle,&nRowCount);
 496             pArray[j] = nRowCount;
 497         }
 498     }
 499     return aRet;
 500 }
 501
 502
 503 sal_Int32 SAL_CALL OStatement_Base::executeUpdate( const OUString& sql )
 504 {
 505     ::osl::MutexGuard aGuard( m_aMutex );
 506     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 507
 508
 509     sal_Int32 numRows = -1;
 510
 511     // Execute the statement.  If execute returns false, a
 512     // row count exists.
 513
 514     if (!execute (sql)) {
 515         numRows = getUpdateCount();
 516     }
 517     else {
 518
 519         // No update count was produced (a ResultSet was).  Raise
 520         // an exception
 521
 522         ::connectivity::SharedResources aResources;
 523         const OUString sError( aResources.getResourceString(STR_NO_ROWCOUNT));
 524         throw SQLException (sError, *this,OUString(),0,Any());
 525     }
 526     return numRows;
 527
 528 }
 529
 530
 531 Reference< XResultSet > SAL_CALL OStatement_Base::getResultSet(  )
 532 {
 533     ::osl::MutexGuard aGuard( m_aMutex );
 534     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 535
 536
 537     m_xResultSet = getResultSet(true);
 538     return m_xResultSet;
 539 }
 540
 541
 542 sal_Int32 SAL_CALL OStatement_Base::getUpdateCount(  )
 543 {
 544     ::osl::MutexGuard aGuard( m_aMutex );
 545     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 546
 547
 548     sal_Int32 rowCount = -1;
 549
 550     // Only return a row count for SQL statements that did not
 551     // return a result set.
 552
 553     if (getColumnCount () == 0)
 554         rowCount = getRowCount ();
 555
 556     return rowCount;
 557 }
 558
 559
 560 sal_Bool SAL_CALL OStatement_Base::getMoreResults(  )
 561 {
 562     ::osl::MutexGuard aGuard( m_aMutex );
 563     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 564
 565
 566     SQLWarning  warning;
 567     bool hasResultSet = false;
 568
 569     // clear previous warnings
 570
 571     clearWarnings ();
 572
 573     // Call SQLMoreResults
 574     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 575
 576     try {
 577         hasResultSet = N3SQLMoreResults(m_aStatementHandle) == SQL_SUCCESS;
 578     }
 579     catch (const SQLWarning &ex) {
 580
 581         // Save pointer to warning and save with ResultSet
 582         // object once it is created.
 583
 584         warning = ex;
 585     }
 586
 587     // There are more results (it may not be a result set, though)
 588
 589     if (hasResultSet)
 590     {
 591
 592         // Now determine if there is a result set associated
 593         // with the SQL statement that was executed.  Get the
 594         // column count, and if it is zero, there is not a
 595         // result set.
 596
 597         if (getColumnCount () == 0)
 598             hasResultSet = false;
 599     }
 600
 601     // Set the warning for the statement, if one was generated
 602
 603     setWarning (warning);
 604
 605     // Return the result set indicator
 606
 607     return hasResultSet;
 608 }
 609
 610
 611 Any SAL_CALL OStatement_Base::getWarnings(  )
 612 {
 613     ::osl::MutexGuard aGuard( m_aMutex );
 614     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 615
 616
 617     return makeAny(m_aLastWarning);
 618 }
 619
 620
 621 void SAL_CALL OStatement_Base::clearWarnings(  )
 622 {
 623     ::osl::MutexGuard aGuard( m_aMutex );
 624     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 625
 626
 627     m_aLastWarning = SQLWarning();
 628 }
 629
 630
 631 sal_Int64 OStatement_Base::getQueryTimeOut() const
 632 {
 633     return getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_QUERY_TIMEOUT);
 634 }
 635
 636 sal_Int64 OStatement_Base::getMaxRows() const
 637 {
 638     return getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_MAX_ROWS);
 639 }
 640
 641 sal_Int32 OStatement_Base::getResultSetConcurrency() const
 642 {
 643     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 644     SQLULEN nValue (getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CONCURRENCY));
 645     if(nValue == SQL_CONCUR_READ_ONLY)
 646         nValue = ResultSetConcurrency::READ_ONLY;
 647     else
 648         nValue = ResultSetConcurrency::UPDATABLE;
 649     return nValue;
 650 }
 651
 652 sal_Int32 OStatement_Base::getResultSetType() const
 653 {
 654     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 655     SQLULEN nValue (getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_TYPE));
 656     switch(nValue)
 657     {
 658         case SQL_CURSOR_FORWARD_ONLY:
 659             nValue = ResultSetType::FORWARD_ONLY;
 660             break;
 661         case SQL_CURSOR_KEYSET_DRIVEN:
 662         case SQL_CURSOR_STATIC:
 663             nValue = ResultSetType::SCROLL_INSENSITIVE;
 664             break;
 665         case SQL_CURSOR_DYNAMIC:
 666             nValue = ResultSetType::SCROLL_SENSITIVE;
 667             break;
 668         default:
 669             OSL_FAIL("Unknown ODBC Cursor Type");
 670     }
 671
 672     return nValue;
 673 }
 674
 675 sal_Int32 OStatement_Base::getFetchDirection() const
 676 {
 677     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 678     SQLULEN nValue (getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_SCROLLABLE));
 679     switch(nValue)
 680     {
 681         case SQL_SCROLLABLE:
 682             nValue = FetchDirection::REVERSE;
 683             break;
 684         default:
 685             nValue = FetchDirection::FORWARD;
 686             break;
 687     }
 688
 689     return nValue;
 690 }
 691
 692 sal_Int32 OStatement_Base::getFetchSize() const
 693 {
 694     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 695     return getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_ROW_ARRAY_SIZE);
 696 }
 697
 698 sal_Int64 OStatement_Base::getMaxFieldSize() const
 699 {
 700     return getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_MAX_LENGTH);
 701 }
 702
 703 OUString OStatement_Base::getCursorName() const
 704 {
 705     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 706     SQLCHAR pName[258];
 707     SQLSMALLINT nRealLen = 0;
 708     N3SQLGetCursorName(m_aStatementHandle,pName,256,&nRealLen);
 709     return OUString::createFromAscii(reinterpret_cast<char*>(pName));
 710 }
 711
 712 void OStatement_Base::setQueryTimeOut(sal_Int64 seconds)
 713 {
 714     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 715     setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_QUERY_TIMEOUT,seconds);
 716 }
 717
 718 void OStatement_Base::setMaxRows(sal_Int64 _par0)
 719 {
 720     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 721     setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_MAX_ROWS, _par0);
 722 }
 723
 724 void OStatement_Base::setResultSetConcurrency(sal_Int32 _par0)
 725 {
 726     SQLULEN nSet;
 727     if(_par0 == ResultSetConcurrency::READ_ONLY)
 728         nSet = SQL_CONCUR_READ_ONLY;
 729     else
 730         nSet = SQL_CONCUR_VALUES;
 731
 732     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 733     setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CONCURRENCY, nSet);
 734 }
 735
 736 void OStatement_Base::setResultSetType(sal_Int32 _par0)
 737 {
 738
 739     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 740     setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_ROW_BIND_TYPE, SQL_BIND_BY_COLUMN);
 741
 742     bool bUseBookmark = isUsingBookmarks();
 743     SQLULEN nSet( SQL_UNSPECIFIED );
 744     switch(_par0)
 745     {
 746         case ResultSetType::FORWARD_ONLY:
 747             nSet =  SQL_UNSPECIFIED;
 748             break;
 749         case ResultSetType::SCROLL_INSENSITIVE:
 750             nSet =  SQL_INSENSITIVE;
 751             setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_TYPE, SQL_CURSOR_KEYSET_DRIVEN);
 752             break;
 753         case ResultSetType::SCROLL_SENSITIVE:
 754             if(bUseBookmark)
 755             {
 756                 SQLUINTEGER nCurProp = getCursorProperties(SQL_CURSOR_DYNAMIC,true);
 757                 if((nCurProp & SQL_CA1_BOOKMARK) != SQL_CA1_BOOKMARK) // check if bookmark for this type isn't supported
 758                 { // we have to test the next one
 759                     nCurProp = getCursorProperties(SQL_CURSOR_KEYSET_DRIVEN,true);
 760                     bool bNotBookmarks = ((nCurProp & SQL_CA1_BOOKMARK) != SQL_CA1_BOOKMARK);
 761                     nCurProp = getCursorProperties(SQL_CURSOR_KEYSET_DRIVEN,false);
 762                     nSet = SQL_CURSOR_KEYSET_DRIVEN;
 763                     if( bNotBookmarks ||
 764                         ((nCurProp & SQL_CA2_SENSITIVITY_DELETIONS) != SQL_CA2_SENSITIVITY_DELETIONS) ||
 765                         ((nCurProp & SQL_CA2_SENSITIVITY_ADDITIONS) != SQL_CA2_SENSITIVITY_ADDITIONS))
 766                     {
 767                         // bookmarks for keyset isn't supported so reset bookmark setting
 768                         setUsingBookmarks(false);
 769                         nSet = SQL_CURSOR_DYNAMIC;
 770                     }
 771                 }
 772                 else
 773                     nSet = SQL_CURSOR_DYNAMIC;
 774             }
 775             else
 776                 nSet = SQL_CURSOR_DYNAMIC;
 777             if( setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_TYPE, nSet) != SQL_SUCCESS )
 778             {
 779                 setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_TYPE, SQL_CURSOR_KEYSET_DRIVEN);
 780             }
 781             nSet =  SQL_SENSITIVE;
 782             break;
 783         default:
 784             OSL_FAIL( "OStatement_Base::setResultSetType: invalid result set type!" );
 785             break;
 786     }
 787
 788
 789     setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_SENSITIVITY, nSet);
 790 }
 791
 792 void OStatement_Base::setEscapeProcessing( const bool _bEscapeProc )
 793 {
 794     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 795     SQLULEN nEscapeProc( _bEscapeProc ? SQL_NOSCAN_OFF : SQL_NOSCAN_ON );
 796     setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_NOSCAN, nEscapeProc);
 797 }
 798
 799
 800 void OStatement_Base::setFetchDirection(sal_Int32 _par0)
 801 {
 802     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 803     if(_par0 == FetchDirection::FORWARD)
 804     {
 805         setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_SCROLLABLE, SQL_NONSCROLLABLE);
 806     }
 807     else if(_par0 == FetchDirection::REVERSE)
 808     {
 809         setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_CURSOR_SCROLLABLE, SQL_SCROLLABLE);
 810     }
 811 }
 812
 813 void OStatement_Base::setFetchSize(sal_Int32 _par0)
 814 {
 815     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 816     OSL_ENSURE(_par0>0,"Illegal fetch size!");
 817     if ( _par0 > 0 )
 818     {
 819         setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_ROW_ARRAY_SIZE, _par0);
 820
 821         delete[] m_pRowStatusArray;
 822         m_pRowStatusArray = new SQLUSMALLINT[_par0];
 823         setStmtOption<SQLUSMALLINT*, SQL_IS_POINTER>(SQL_ATTR_ROW_STATUS_PTR, m_pRowStatusArray);
 824     }
 825 }
 826
 827 void OStatement_Base::setMaxFieldSize(sal_Int64 _par0)
 828 {
 829     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 830     setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_MAX_LENGTH, _par0);
 831 }
 832
 833 void OStatement_Base::setCursorName(std::u16string_view _par0)
 834 {
 835     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 836     OString aName(OUStringToOString(_par0,getOwnConnection()->getTextEncoding()));
 837     N3SQLSetCursorName(m_aStatementHandle, reinterpret_cast<SDB_ODBC_CHAR *>(const_cast<char *>(aName.getStr())), static_cast<SQLSMALLINT>(aName.getLength()));
 838 }
 839
 840 bool OStatement_Base::isUsingBookmarks() const
 841 {
 842     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 843     return SQL_UB_OFF != getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_USE_BOOKMARKS);
 844 }
 845
 846 bool OStatement_Base::getEscapeProcessing() const
 847 {
 848     OSL_ENSURE( m_aStatementHandle, "StatementHandle is null!" );
 849     return SQL_NOSCAN_OFF == getStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_USE_BOOKMARKS);
 850 }
 851
 852 void OStatement_Base::setUsingBookmarks(bool _bUseBookmark)
 853 {
 854     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 855     SQLULEN nValue = _bUseBookmark ? SQL_UB_VARIABLE : SQL_UB_OFF;
 856     setStmtOption<SQLULEN, SQL_IS_UINTEGER>(SQL_ATTR_USE_BOOKMARKS, nValue);
 857 }
 858
 859 ::cppu::IPropertyArrayHelper* OStatement_Base::createArrayHelper( ) const
 860 {
 861     Sequence< Property > aProps(10);
 862     Property* pProperties = aProps.getArray();
 863     sal_Int32 nPos = 0;
 864     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CURSORNAME),
 865         PROPERTY_ID_CURSORNAME, cppu::UnoType<OUString>::get(), 0);
 866     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ESCAPEPROCESSING),
 867         PROPERTY_ID_ESCAPEPROCESSING, cppu::UnoType<bool>::get(), 0);
 868     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHDIRECTION),
 869         PROPERTY_ID_FETCHDIRECTION, cppu::UnoType<sal_Int32>::get(), 0);
 870     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHSIZE),
 871         PROPERTY_ID_FETCHSIZE, cppu::UnoType<sal_Int32>::get(), 0);
 872     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_MAXFIELDSIZE),
 873         PROPERTY_ID_MAXFIELDSIZE, cppu::UnoType<sal_Int32>::get(), 0);
 874     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_MAXROWS),
 875         PROPERTY_ID_MAXROWS, cppu::UnoType<sal_Int32>::get(), 0);
 876     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_QUERYTIMEOUT),
 877         PROPERTY_ID_QUERYTIMEOUT, cppu::UnoType<sal_Int32>::get(), 0);
 878     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETCONCURRENCY),
 879         PROPERTY_ID_RESULTSETCONCURRENCY, cppu::UnoType<sal_Int32>::get(), 0);
 880     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETTYPE),
 881         PROPERTY_ID_RESULTSETTYPE, cppu::UnoType<sal_Int32>::get(), 0);
 882     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_USEBOOKMARKS),
 883         PROPERTY_ID_USEBOOKMARKS, cppu::UnoType<bool>::get(), 0);
 884
 885     return new ::cppu::OPropertyArrayHelper(aProps);
 886 }
 887
 888
 889 ::cppu::IPropertyArrayHelper & OStatement_Base::getInfoHelper()
 890 {
 891     return *getArrayHelper();
 892 }
 893
 894 sal_Bool OStatement_Base::convertFastPropertyValue(
 895                             Any & rConvertedValue,
 896                             Any & rOldValue,
 897                             sal_Int32 nHandle,
 898                             const Any& rValue )
 899 {
 900     bool bConverted = false;
 901     try
 902     {
 903         switch(nHandle)
 904         {
 905             case PROPERTY_ID_QUERYTIMEOUT:
 906                 bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getQueryTimeOut());
 907                 break;
 908
 909             case PROPERTY_ID_MAXFIELDSIZE:
 910                 bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getMaxFieldSize());
 911                 break;
 912
 913             case PROPERTY_ID_MAXROWS:
 914                 bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getMaxRows());
 915                 break;
 916
 917             case PROPERTY_ID_CURSORNAME:
 918                 bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getCursorName());
 919                 break;
 920
 921             case PROPERTY_ID_RESULTSETCONCURRENCY:
 922                 bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getResultSetConcurrency());
 923                 break;
 924
 925             case PROPERTY_ID_RESULTSETTYPE:
 926                 bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getResultSetType());
 927                 break;
 928
 929             case PROPERTY_ID_FETCHDIRECTION:
 930                 bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchDirection());
 931                 break;
 932
 933             case PROPERTY_ID_FETCHSIZE:
 934                 bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchSize());
 935                 break;
 936
 937             case PROPERTY_ID_USEBOOKMARKS:
 938                 bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, isUsingBookmarks());
 939                 break;
 940
 941             case PROPERTY_ID_ESCAPEPROCESSING:
 942                 bConverted = ::comphelper::tryPropertyValue( rConvertedValue, rOldValue, rValue, getEscapeProcessing() );
 943                 break;
 944
 945         }
 946     }
 947     catch(const SQLException&)
 948     {
 949         //  throw Exception(e.Message,*this);
 950     }
 951     return bConverted;
 952 }
 953
 954 void OStatement_Base::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue)
 955 {
 956     try
 957     {
 958         switch(nHandle)
 959         {
 960             case PROPERTY_ID_QUERYTIMEOUT:
 961                 setQueryTimeOut(comphelper::getINT64(rValue));
 962                 break;
 963             case PROPERTY_ID_MAXFIELDSIZE:
 964                 setMaxFieldSize(comphelper::getINT64(rValue));
 965                 break;
 966             case PROPERTY_ID_MAXROWS:
 967                 setMaxRows(comphelper::getINT64(rValue));
 968                 break;
 969             case PROPERTY_ID_CURSORNAME:
 970                 setCursorName(comphelper::getString(rValue));
 971                 break;
 972             case PROPERTY_ID_RESULTSETCONCURRENCY:
 973                 setResultSetConcurrency(comphelper::getINT32(rValue));
 974                 break;
 975             case PROPERTY_ID_RESULTSETTYPE:
 976                 setResultSetType(comphelper::getINT32(rValue));
 977                 break;
 978             case PROPERTY_ID_FETCHDIRECTION:
 979                 setFetchDirection(comphelper::getINT32(rValue));
 980                 break;
 981             case PROPERTY_ID_FETCHSIZE:
 982                 setFetchSize(comphelper::getINT32(rValue));
 983                 break;
 984             case PROPERTY_ID_USEBOOKMARKS:
 985                 setUsingBookmarks(comphelper::getBOOL(rValue));
 986                 break;
 987             case PROPERTY_ID_ESCAPEPROCESSING:
 988                 setEscapeProcessing( ::comphelper::getBOOL( rValue ) );
 989                 break;
 990             default:
 991                 OSL_FAIL( "OStatement_Base::setFastPropertyValue_NoBroadcast: what property?" );
 992                 break;
 993         }
 994     }
 995     catch(const SQLException& )
 996     {
 997         //  throw Exception(e.Message,*this);
 998     }
 999 }
1000
1001 void OStatement_Base::getFastPropertyValue(Any& rValue,sal_Int32 nHandle) const
1002 {
1003     switch(nHandle)
1004     {
1005         case PROPERTY_ID_QUERYTIMEOUT:
1006             rValue <<= getQueryTimeOut();
1007             break;
1008         case PROPERTY_ID_MAXFIELDSIZE:
1009             rValue <<= getMaxFieldSize();
1010             break;
1011         case PROPERTY_ID_MAXROWS:
1012             rValue <<= getMaxRows();
1013             break;
1014         case PROPERTY_ID_CURSORNAME:
1015             rValue <<= getCursorName();
1016             break;
1017         case PROPERTY_ID_RESULTSETCONCURRENCY:
1018             rValue <<= getResultSetConcurrency();
1019             break;
1020         case PROPERTY_ID_RESULTSETTYPE:
1021             rValue <<= getResultSetType();
1022             break;
1023         case PROPERTY_ID_FETCHDIRECTION:
1024             rValue <<= getFetchDirection();
1025             break;
1026         case PROPERTY_ID_FETCHSIZE:
1027             rValue <<= getFetchSize();
1028             break;
1029         case PROPERTY_ID_USEBOOKMARKS:
1030             rValue <<= isUsingBookmarks();
1031             break;
1032         case PROPERTY_ID_ESCAPEPROCESSING:
1033             rValue <<= getEscapeProcessing();
1034             break;
1035         default:
1036             OSL_FAIL( "OStatement_Base::getFastPropertyValue: what property?" );
1037             break;
1038     }
1039 }
1040
1041 IMPLEMENT_SERVICE_INFO(OStatement,"com.sun.star.sdbcx.OStatement","com.sun.star.sdbc.Statement");
1042
1043 void SAL_CALL OStatement_Base::acquire() noexcept
1044 {
1045     OStatement_BASE::acquire();
1046 }
1047
1048 void SAL_CALL OStatement_Base::release() noexcept
1049 {
1050     OStatement_BASE::release();
1051 }
1052
1053 void SAL_CALL OStatement::acquire() noexcept
1054 {
1055     OStatement_BASE2::acquire();
1056 }
1057
1058 void SAL_CALL OStatement::release() noexcept
1059 {
1060     OStatement_BASE2::release();
1061 }
1062
1063 rtl::Reference<OResultSet> OStatement_Base::createResultSet()
1064 {
1065     return new OResultSet(m_aStatementHandle,this);
1066 }
1067
1068 Reference< css::beans::XPropertySetInfo > SAL_CALL OStatement_Base::getPropertySetInfo(  )
1069 {
1070     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
1071 }
1072
1073 SQLUINTEGER OStatement_Base::getCursorProperties(SQLINTEGER _nCursorType, bool bFirst)
1074 {
1075     SQLUINTEGER nValueLen = 0;
1076     try
1077     {
1078         SQLUSMALLINT nAskFor = SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2;
1079         if(SQL_CURSOR_KEYSET_DRIVEN == _nCursorType)
1080             nAskFor = bFirst ? SQL_KEYSET_CURSOR_ATTRIBUTES1 : SQL_KEYSET_CURSOR_ATTRIBUTES2;
1081         else if(SQL_CURSOR_STATIC  == _nCursorType)
1082             nAskFor = bFirst ? SQL_STATIC_CURSOR_ATTRIBUTES1 : SQL_STATIC_CURSOR_ATTRIBUTES2;
1083         else if(SQL_CURSOR_FORWARD_ONLY == _nCursorType)
1084             nAskFor = bFirst ? SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1 : SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2;
1085         else if(SQL_CURSOR_DYNAMIC == _nCursorType)
1086             nAskFor = bFirst ? SQL_DYNAMIC_CURSOR_ATTRIBUTES1 : SQL_DYNAMIC_CURSOR_ATTRIBUTES2;
1087
1088
1089         OTools::GetInfo(getOwnConnection(),getConnectionHandle(),nAskFor,nValueLen,nullptr);
1090     }
1091     catch(const Exception&)
1092     { // we don't want our result destroy here
1093         nValueLen = 0;
1094     }
1095     return nValueLen;
1096 }
1097
1098
1099 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */