connectivity/source/drivers/odbcbase/OStatement.cxx

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