connectivity/source/drivers/odbcbase/OPreparedStatement.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 <string.h>
  32 #include <osl/diagnose.h>
  33 #include "diagnose_ex.h"
  34 #include "odbc/OPreparedStatement.hxx"
  35 #include "odbc/OBoundParam.hxx"
  36 #include <com/sun/star/sdbc/DataType.hpp>
  37 #include "odbc/OTools.hxx"
  38 #include "odbc/ODriver.hxx"
  39 #include "odbc/OResultSet.hxx"
  40 #include "odbc/OResultSetMetaData.hxx"
  41 #include <cppuhelper/typeprovider.hxx>
  42 #include <comphelper/sequence.hxx>
  43 #include <com/sun/star/lang/DisposedException.hpp>
  44 #include "connectivity/dbtools.hxx"
  45 #include <comphelper/types.hxx>
  46 #include "connectivity/FValue.hxx"
  47 #include "resource/common_res.hrc"
  48 #include "connectivity/sqlparse.hxx"
  49
  50 using namespace ::comphelper;
  51 using namespace connectivity;
  52 using namespace connectivity::odbc;
  53 using namespace com::sun::star::uno;
  54 using namespace com::sun::star::lang;
  55 using namespace com::sun::star::beans;
  56 using namespace com::sun::star::sdbc;
  57 using namespace com::sun::star::sdbcx;
  58 using namespace com::sun::star::container;
  59 using namespace com::sun::star::io;
  60 using namespace com::sun::star::util;
  61
  62 IMPLEMENT_SERVICE_INFO(OPreparedStatement,"com.sun.star.sdbcx.OPreparedStatement","com.sun.star.sdbc.PreparedStatement");
  63
  64
  65 OPreparedStatement::OPreparedStatement( OConnection* _pConnection,const ::rtl::OUString& sql)
  66     :OStatement_BASE2(_pConnection)
  67     ,numParams(0)
  68     ,boundParams(NULL)
  69     ,m_bPrepared(sal_False)
  70 {
  71     m_sSqlStatement = sql;
  72     try
  73     {
  74         if(_pConnection->isParameterSubstitutionEnabled())
  75         {
  76             OSQLParser aParser(_pConnection->getDriver()->getORB());
  77             ::rtl::OUString sErrorMessage;
  78             ::rtl::OUString sNewSql;
  79             ::std::auto_ptr<OSQLParseNode> pNode( aParser.parseTree(sErrorMessage,sql) );
  80             if ( pNode.get() )
  81             {   // special handling for parameters
  82                 OSQLParseNode::substituteParameterNames(pNode.get());
  83                 pNode->parseNodeToStr( sNewSql, _pConnection );
  84                 m_sSqlStatement = sNewSql;
  85             }
  86         }
  87     }
  88     catch(Exception&)
  89     {
  90     }
  91 }
  92 // -----------------------------------------------------------------------------
  93 void SAL_CALL OPreparedStatement::acquire() throw()
  94 {
  95     OStatement_BASE2::acquire();
  96 }
  97 // -----------------------------------------------------------------------------
  98 void SAL_CALL OPreparedStatement::release() throw()
  99 {
 100     OStatement_BASE2::release();
 101 }
 102 // -----------------------------------------------------------------------------
 103 Any SAL_CALL OPreparedStatement::queryInterface( const Type & rType ) throw(RuntimeException)
 104 {
 105     Any aRet = OStatement_BASE2::queryInterface(rType);
 106     return aRet.hasValue() ? aRet : OPreparedStatement_BASE::queryInterface(rType);
 107 }
 108 // -------------------------------------------------------------------------
 109 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL OPreparedStatement::getTypes(  ) throw(::com::sun::star::uno::RuntimeException)
 110 {
 111     return ::comphelper::concatSequences(OPreparedStatement_BASE::getTypes(),OStatement_BASE2::getTypes());
 112 }
 113 // -------------------------------------------------------------------------
 114
 115 Reference< XResultSetMetaData > SAL_CALL OPreparedStatement::getMetaData(  ) throw(SQLException, RuntimeException)
 116 {
 117     ::osl::MutexGuard aGuard( m_aMutex );
 118     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 119
 120
 121     prepareStatement();
 122     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 123     if(!m_xMetaData.is())
 124         m_xMetaData = new OResultSetMetaData(getOwnConnection(),m_aStatementHandle);
 125     return m_xMetaData;
 126 }
 127 // -------------------------------------------------------------------------
 128
 129 void SAL_CALL OPreparedStatement::close(  ) throw(SQLException, RuntimeException)
 130 {
 131     ::osl::MutexGuard aGuard( m_aMutex );
 132     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 133
 134
 135     // Close/clear our result set
 136     clearMyResultSet ();
 137
 138     // Reset last warning message
 139
 140     try {
 141         clearWarnings ();
 142         OStatement_BASE2::close();
 143         FreeParams();
 144     }
 145     catch (SQLException &) {
 146         // If we get an error, ignore
 147     }
 148
 149     // Remove this Statement object from the Connection object's
 150     // list
 151 }
 152 // -------------------------------------------------------------------------
 153
 154 sal_Bool SAL_CALL OPreparedStatement::execute(  ) throw(SQLException, RuntimeException)
 155 {
 156     ::osl::MutexGuard aGuard( m_aMutex );
 157     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 158
 159
 160     sal_Bool needData = sal_False;
 161
 162     // Reset warnings
 163
 164     clearWarnings ();
 165
 166     // Reset the statement handle, warning and saved Resultset
 167
 168     reset();
 169
 170     // Call SQLExecute
 171     prepareStatement();
 172
 173     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 174     try
 175     {
 176         SQLRETURN nReturn = N3SQLExecute(m_aStatementHandle);
 177
 178         OTools::ThrowException(m_pConnection,nReturn,m_aStatementHandle,SQL_HANDLE_STMT,*this);
 179         needData = nReturn == SQL_NEED_DATA;
 180
 181         // Now loop while more data is needed (i.e. a data-at-
 182         // execution parameter was given).  For each parameter
 183         // that needs data, put the data from the input stream.
 184
 185         while (needData) {
 186
 187             // Get the parameter number that requires data
 188
 189             sal_Int32* paramIndex = 0;
 190             nReturn = N3SQLParamData(m_aStatementHandle,(SQLPOINTER*)&paramIndex);
 191
 192             // If the parameter index is -1, there is no
 193             // more data required
 194
 195             if ( !paramIndex || ( *paramIndex == -1 ) )
 196                 needData = sal_False;
 197             else
 198             {
 199                 // Now we have the proper parameter
 200                 // index, get the data from the input
 201                 // stream and do a SQLPutData
 202                 putParamData (*paramIndex);
 203             }
 204         }
 205
 206     }
 207     catch (const SQLWarning&)
 208     {
 209     }
 210
 211     // Now loop while more data is needed (i.e. a data-at-
 212     // execution parameter was given).  For each parameter
 213     // that needs data, put the data from the input stream.
 214
 215     while (needData) {
 216
 217         // Get the parameter number that requires data
 218
 219         sal_Int32* paramIndex = 0;
 220         N3SQLParamData (m_aStatementHandle,(SQLPOINTER*)&paramIndex);
 221
 222         // If the parameter index is -1, there is no more
 223         // data required
 224
 225         if (*paramIndex == -1) {
 226             needData = sal_False;
 227         }
 228         else {
 229             // Now we have the proper parameter index,
 230             // get the data from the input stream
 231             // and do a SQLPutData
 232             putParamData(*paramIndex);
 233         }
 234     }
 235
 236     // Now determine if there is a result set associated with
 237     // the SQL statement that was executed.  Get the column
 238     // count, and if it is not zero, there is a result set.
 239
 240
 241     return getColumnCount() > 0;
 242 }
 243 // -------------------------------------------------------------------------
 244
 245 sal_Int32 SAL_CALL OPreparedStatement::executeUpdate(  ) throw(SQLException, RuntimeException)
 246 {
 247     ::osl::MutexGuard aGuard( m_aMutex );
 248     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 249
 250     sal_Int32 numRows = -1;
 251
 252     prepareStatement();
 253     // Execute the statement.  If execute returns sal_False, a
 254     // row count exists.
 255
 256     if (!execute())
 257         numRows = getUpdateCount ();
 258     else
 259     {
 260         // No update count was produced (a ResultSet was).  Raise
 261         // an exception
 262         m_pConnection->throwGenericSQLException(STR_NO_ROWCOUNT,*this);
 263     }
 264     return numRows;
 265 }
 266 // -------------------------------------------------------------------------
 267
 268 void SAL_CALL OPreparedStatement::setString( sal_Int32 parameterIndex, const ::rtl::OUString& x ) throw(SQLException, RuntimeException)
 269 {
 270     ::rtl::OString aString(::rtl::OUStringToOString(x,getOwnConnection()->getTextEncoding()));
 271     setParameter(parameterIndex,DataType::CHAR,aString.getLength(),(void*)&x);
 272 }
 273 // -------------------------------------------------------------------------
 274
 275 Reference< XConnection > SAL_CALL OPreparedStatement::getConnection(  ) throw(SQLException, RuntimeException)
 276 {
 277     ::osl::MutexGuard aGuard( m_aMutex );
 278     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 279
 280     return (Reference< XConnection >)m_pConnection;
 281 }
 282 // -------------------------------------------------------------------------
 283
 284 Reference< XResultSet > SAL_CALL OPreparedStatement::executeQuery(  ) throw(SQLException, RuntimeException)
 285 {
 286     ::osl::MutexGuard aGuard( m_aMutex );
 287     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 288
 289     Reference< XResultSet > rs = NULL;
 290
 291     prepareStatement();
 292
 293     if (execute())
 294         rs = getResultSet(sal_False);
 295     else
 296     {
 297         // No ResultSet was produced.  Raise an exception
 298         m_pConnection->throwGenericSQLException(STR_NO_RESULTSET,*this);
 299     }
 300     return rs;
 301 }
 302 // -------------------------------------------------------------------------
 303
 304 void SAL_CALL OPreparedStatement::setBoolean( sal_Int32 parameterIndex, sal_Bool x ) throw(SQLException, RuntimeException)
 305 {
 306     ::osl::MutexGuard aGuard( m_aMutex );
 307     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 308
 309
 310     sal_Int32 value = 0;
 311
 312     // If the parameter is sal_True, set the value to 1
 313     if (x) {
 314         value = 1;
 315     }
 316
 317     // Set the parameter as if it were an integer
 318     setInt (parameterIndex, value);
 319 }
 320 // -------------------------------------------------------------------------
 321 void OPreparedStatement::setParameter(sal_Int32 parameterIndex,sal_Int32 _nType,sal_Int32 _nSize,void* _pData)
 322 {
 323     ::osl::MutexGuard aGuard( m_aMutex );
 324     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 325
 326     prepareStatement();
 327     // Allocate a buffer to be used in binding.  This will be
 328         // a 'permanent' buffer that the bridge will fill in with
 329         // the bound data in native format.
 330
 331
 332     checkParameterIndex(parameterIndex);
 333     sal_Int32 nRealSize = _nSize;
 334     SQLSMALLINT fSqlType = static_cast<SQLSMALLINT>(OTools::jdbcTypeToOdbc(_nType));
 335     switch(fSqlType)
 336     {
 337         case SQL_CHAR:
 338         case SQL_VARCHAR:
 339         case SQL_DECIMAL:
 340         case SQL_NUMERIC:
 341             ++nRealSize;
 342             break;
 343         case SQL_BINARY:
 344         case SQL_VARBINARY:
 345             nRealSize=1;    //dummy buffer, binary data isn't copied
 346             break;
 347         default:
 348             break;
 349     }
 350
 351     sal_Int8* bindBuf = allocBindBuf(parameterIndex, nRealSize);
 352
 353     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 354     OTools::bindParameter(  m_pConnection,
 355                             m_aStatementHandle,
 356                             parameterIndex,
 357                             bindBuf,
 358                             getLengthBuf(parameterIndex),
 359                             fSqlType,
 360                             sal_False,
 361                             m_pConnection->useOldDateFormat(),
 362                             _pData,
 363                             (Reference <XInterface>)*this,
 364                             getOwnConnection()->getTextEncoding());
 365 }
 366 // -----------------------------------------------------------------------------
 367 void SAL_CALL OPreparedStatement::setByte( sal_Int32 parameterIndex, sal_Int8 x ) throw(SQLException, RuntimeException)
 368 {
 369     setParameter(parameterIndex,DataType::TINYINT,sizeof(sal_Int8),&x);
 370 }
 371 // -------------------------------------------------------------------------
 372
 373 void SAL_CALL OPreparedStatement::setDate( sal_Int32 parameterIndex, const Date& aData ) throw(SQLException, RuntimeException)
 374 {
 375     DATE_STRUCT x = OTools::DateToOdbcDate(aData);
 376     setParameter(parameterIndex,DataType::DATE,sizeof(DATE_STRUCT),&x);
 377 }
 378 // -------------------------------------------------------------------------
 379
 380
 381 void SAL_CALL OPreparedStatement::setTime( sal_Int32 parameterIndex, const Time& aVal ) throw(SQLException, RuntimeException)
 382 {
 383     TIME_STRUCT x = OTools::TimeToOdbcTime(aVal);
 384     setParameter(parameterIndex,DataType::TIME,sizeof(TIME_STRUCT),&x);
 385 }
 386 // -------------------------------------------------------------------------
 387
 388 void SAL_CALL OPreparedStatement::setTimestamp( sal_Int32 parameterIndex, const DateTime& aVal ) throw(SQLException, RuntimeException)
 389 {
 390     TIMESTAMP_STRUCT x = OTools::DateTimeToTimestamp(aVal);
 391     setParameter(parameterIndex,DataType::TIMESTAMP,sizeof(TIMESTAMP_STRUCT),&x);
 392 }
 393 // -------------------------------------------------------------------------
 394
 395 void SAL_CALL OPreparedStatement::setDouble( sal_Int32 parameterIndex, double x ) throw(SQLException, RuntimeException)
 396 {
 397     setParameter(parameterIndex,DataType::DOUBLE,sizeof(double),&x);
 398 }
 399
 400 // -------------------------------------------------------------------------
 401
 402 void SAL_CALL OPreparedStatement::setFloat( sal_Int32 parameterIndex, float x ) throw(SQLException, RuntimeException)
 403 {
 404     setParameter(parameterIndex,DataType::FLOAT,sizeof(float),&x);
 405 }
 406 // -------------------------------------------------------------------------
 407
 408 void SAL_CALL OPreparedStatement::setInt( sal_Int32 parameterIndex, sal_Int32 x ) throw(SQLException, RuntimeException)
 409 {
 410     setParameter(parameterIndex,DataType::INTEGER,sizeof(sal_Int32),&x);
 411 }
 412 // -------------------------------------------------------------------------
 413
 414 void SAL_CALL OPreparedStatement::setLong( sal_Int32 parameterIndex, sal_Int64 x ) throw(SQLException, RuntimeException)
 415 {
 416     try
 417     {
 418         setParameter(parameterIndex,DataType::BIGINT,sizeof(sal_Int64),&x);
 419     }
 420     catch(SQLException&)
 421     {
 422         setString(parameterIndex,ORowSetValue(x));
 423     }
 424 }
 425 // -------------------------------------------------------------------------
 426
 427 void SAL_CALL OPreparedStatement::setNull( sal_Int32 parameterIndex, sal_Int32 sqlType ) throw(SQLException, RuntimeException)
 428 {
 429     ::osl::MutexGuard aGuard( m_aMutex );
 430     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 431
 432
 433     prepareStatement();
 434     // Get the buffer needed for the length
 435     checkParameterIndex(parameterIndex);
 436
 437     sal_Int8* lenBuf = getLengthBuf (parameterIndex);
 438     *(SQLLEN*)lenBuf = SQL_NULL_DATA;
 439
 440
 441     SQLLEN prec = 0;
 442     SQLULEN nColumnSize = 0;
 443     if (sqlType == SQL_CHAR || sqlType == SQL_VARCHAR || sqlType == SQL_LONGVARCHAR)
 444     {
 445         prec = 1;
 446         nColumnSize = 1;
 447     }
 448
 449     SQLSMALLINT fCType = 0;
 450     SQLSMALLINT fSqlType = 0;
 451
 452     SQLSMALLINT nDecimalDigits = 0;
 453     OTools::getBindTypes(   sal_False,
 454                             m_pConnection->useOldDateFormat(),
 455                             (SQLSMALLINT)sqlType,
 456                             fCType,
 457                             fSqlType);
 458
 459     SQLRETURN nReturn = N3SQLBindParameter( m_aStatementHandle,
 460                                             (SQLUSMALLINT)parameterIndex,
 461                                             (SQLSMALLINT)SQL_PARAM_INPUT,
 462                                             fCType,
 463                                             fSqlType,
 464                                             nColumnSize,
 465                                             nDecimalDigits,
 466                                             NULL,
 467                                             prec,
 468                                             (SQLLEN*)lenBuf
 469                                             );
 470     OTools::ThrowException(m_pConnection,nReturn,m_aStatementHandle,SQL_HANDLE_STMT,*this);
 471 }
 472 // -------------------------------------------------------------------------
 473
 474 void SAL_CALL OPreparedStatement::setClob( sal_Int32 parameterIndex, const Reference< XClob >& x ) throw(SQLException, RuntimeException)
 475 {
 476     if ( x.is() )
 477         setStream(parameterIndex, x->getCharacterStream(), (SQLLEN)x->length(), DataType::LONGVARCHAR);
 478 }
 479 // -------------------------------------------------------------------------
 480
 481 void SAL_CALL OPreparedStatement::setBlob( sal_Int32 parameterIndex, const Reference< XBlob >& x ) throw(SQLException, RuntimeException)
 482 {
 483     if ( x.is() )
 484         setStream(parameterIndex, x->getBinaryStream(), (SQLLEN)x->length(), DataType::LONGVARCHAR);
 485 }
 486 // -------------------------------------------------------------------------
 487
 488 void SAL_CALL OPreparedStatement::setArray( sal_Int32 /*parameterIndex*/, const Reference< XArray >& /*x*/ ) throw(SQLException, RuntimeException)
 489 {
 490     ::dbtools::throwFunctionNotSupportedException( "XParameters::setArray", *this );
 491 }
 492 // -------------------------------------------------------------------------
 493
 494 void SAL_CALL OPreparedStatement::setRef( sal_Int32 /*parameterIndex*/, const Reference< XRef >& /*x*/ ) throw(SQLException, RuntimeException)
 495 {
 496     ::dbtools::throwFunctionNotSupportedException( "XParameters::setRef", *this );
 497 }
 498 // -------------------------------------------------------------------------
 499 void OPreparedStatement::setDecimal( sal_Int32 parameterIndex, const ::rtl::OUString& x )
 500 {
 501     ::rtl::OString aString(::rtl::OUStringToOString(x,getOwnConnection()->getTextEncoding()));
 502     setParameter(parameterIndex,DataType::DECIMAL,aString.getLength(),(void*)&x);
 503 }
 504 // -------------------------------------------------------------------------
 505 void SAL_CALL OPreparedStatement::setObjectWithInfo( sal_Int32 parameterIndex, const Any& x, sal_Int32 sqlType, sal_Int32 scale ) throw(SQLException, RuntimeException)
 506 {
 507     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 508     ::osl::MutexGuard aGuard( m_aMutex );
 509
 510     prepareStatement();
 511     // For each known SQL Type, call the appropriate
 512         // set routine
 513
 514     switch (sqlType)
 515     {
 516         case DataType::VARCHAR:
 517         case DataType::LONGVARCHAR:
 518             if(x.hasValue())
 519             {
 520                 ::rtl::OUString sStr;
 521                 x >>= sStr;
 522                 ::rtl::OString aString(::rtl::OUStringToOString(sStr,getOwnConnection()->getTextEncoding()));
 523                 setParameter(parameterIndex,sqlType,aString.getLength(),&aString);
 524             }
 525             else
 526                 setNull(parameterIndex,sqlType);
 527             break;
 528         case DataType::DECIMAL:
 529             {
 530                 ORowSetValue aValue;
 531                 aValue.fill(x);
 532                 setDecimal(parameterIndex,aValue);
 533             }
 534             break;
 535         case DataType::NUMERIC:
 536             {
 537                 ORowSetValue aValue;
 538                 aValue.fill(x);
 539                 setString(parameterIndex,aValue);
 540             }
 541             break;
 542         default:
 543             ::dbtools::setObjectWithInfo(this,parameterIndex,x,sqlType,scale);
 544         }
 545 }
 546 // -------------------------------------------------------------------------
 547
 548 void SAL_CALL OPreparedStatement::setObjectNull( sal_Int32 parameterIndex, sal_Int32 sqlType, const ::rtl::OUString& /*typeName*/ ) throw(SQLException, RuntimeException)
 549 {
 550     ::osl::MutexGuard aGuard( m_aMutex );
 551     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 552
 553     setNull(parameterIndex,sqlType);
 554 }
 555 // -------------------------------------------------------------------------
 556
 557 void SAL_CALL OPreparedStatement::setObject( sal_Int32 parameterIndex, const Any& x ) throw(SQLException, RuntimeException)
 558 {
 559     if (!::dbtools::implSetObject(this, parameterIndex, x))
 560     {   // there is no other setXXX call which can handle the value in x
 561         throw SQLException();
 562     }
 563 }
 564 // -------------------------------------------------------------------------
 565
 566 void SAL_CALL OPreparedStatement::setShort( sal_Int32 parameterIndex, sal_Int16 x ) throw(SQLException, RuntimeException)
 567 {
 568     setParameter(parameterIndex,DataType::SMALLINT,sizeof(sal_Int16),&x);
 569 }
 570 // -------------------------------------------------------------------------
 571
 572 void SAL_CALL OPreparedStatement::setBytes( sal_Int32 parameterIndex, const Sequence< sal_Int8 >& x ) throw(SQLException, RuntimeException)
 573 {
 574     setParameter(parameterIndex,DataType::BINARY,x.getLength(),(void*)&x);
 575     boundParams[parameterIndex-1].setSequence(x); // this assures that the sequence stays alive
 576 }
 577 // -------------------------------------------------------------------------
 578
 579
 580 void SAL_CALL OPreparedStatement::setCharacterStream( sal_Int32 parameterIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
 581 {
 582     setStream(parameterIndex, x, length, DataType::LONGVARCHAR);
 583 }
 584 // -------------------------------------------------------------------------
 585
 586 void SAL_CALL OPreparedStatement::setBinaryStream( sal_Int32 parameterIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
 587 {
 588     setStream(parameterIndex, x, length, DataType::LONGVARBINARY);
 589 }
 590 // -------------------------------------------------------------------------
 591
 592 void SAL_CALL OPreparedStatement::clearParameters(  ) throw(SQLException, RuntimeException)
 593 {
 594     prepareStatement();
 595     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 596     SQLRETURN nRet = N3SQLFreeStmt (m_aStatementHandle, SQL_RESET_PARAMS);
 597     nRet = N3SQLFreeStmt (m_aStatementHandle, SQL_UNBIND);
 598     OSL_UNUSED(nRet);
 599 }
 600 // -------------------------------------------------------------------------
 601 void SAL_CALL OPreparedStatement::clearBatch(  ) throw(SQLException, RuntimeException)
 602 {
 603     //  clearParameters(  );
 604     //  m_aBatchList.erase();
 605 }
 606 // -------------------------------------------------------------------------
 607
 608 void SAL_CALL OPreparedStatement::addBatch( ) throw(SQLException, RuntimeException)
 609 {
 610 }
 611 // -------------------------------------------------------------------------
 612
 613 Sequence< sal_Int32 > SAL_CALL OPreparedStatement::executeBatch(  ) throw(SQLException, RuntimeException)
 614 {
 615     return Sequence< sal_Int32 > ();
 616 }
 617 // -------------------------------------------------------------------------
 618
 619 //====================================================================
 620 // methods
 621 //====================================================================
 622
 623 //--------------------------------------------------------------------
 624 // initBoundParam
 625 // Initialize the bound parameter objects
 626 //--------------------------------------------------------------------
 627
 628 void OPreparedStatement::initBoundParam () throw(SQLException)
 629 {
 630     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 631     // Get the number of parameters
 632     numParams = 0;
 633     N3SQLNumParams (m_aStatementHandle,&numParams);
 634
 635     // There are parameter markers, allocate the bound
 636     // parameter objects
 637
 638     if (numParams > 0)
 639     {
 640         // Allocate an array of bound parameter objects
 641
 642         boundParams = new OBoundParam[numParams];
 643
 644         // initialize each bound parameter
 645
 646         for (sal_Int32 i = 0; i < numParams; i++)
 647         {
 648             boundParams[i].initialize ();
 649         }
 650     }
 651 }
 652 // -------------------------------------------------------------------------
 653
 654 //--------------------------------------------------------------------
 655 // allocBindBuf
 656 // Allocate storage for the permanent data buffer for the bound
 657 // parameter.
 658 //--------------------------------------------------------------------
 659
 660 sal_Int8* OPreparedStatement::allocBindBuf( sal_Int32 index,sal_Int32 bufLen)
 661 {
 662     sal_Int8* b = NULL;
 663
 664     // Sanity check the parameter number
 665
 666     if ((index >= 1) &&
 667         (index <= numParams) && bufLen > 0 )
 668     {
 669         b = boundParams[index - 1].allocBindDataBuffer(bufLen);
 670     }
 671
 672     return b;
 673 }
 674 // -------------------------------------------------------------------------
 675
 676 //--------------------------------------------------------------------
 677 // getLengthBuf
 678 // Gets the length buffer for the given parameter index
 679 //--------------------------------------------------------------------
 680
 681 sal_Int8* OPreparedStatement::getLengthBuf (sal_Int32 index)
 682 {
 683     sal_Int8* b = NULL;
 684
 685     // Sanity check the parameter number
 686
 687     if ((index >= 1) &&
 688         (index <= numParams))
 689     {
 690         b = boundParams[index - 1].getBindLengthBuffer ();
 691     }
 692
 693     return b;
 694 }
 695 // -------------------------------------------------------------------------
 696
 697 //--------------------------------------------------------------------
 698 // putParamData
 699 // Puts parameter data from a previously bound input stream.  The
 700 // input stream was bound using SQL_LEN_DATA_AT_EXEC.
 701 //--------------------------------------------------------------------
 702
 703 void OPreparedStatement::putParamData (sal_Int32 index) throw(SQLException)
 704 {
 705     // Sanity check the parameter index
 706     if ((index < 1) ||
 707         (index > numParams))
 708     {
 709         return;
 710     }
 711
 712     // We'll transfer up to MAX_PUT_DATA_LENGTH at a time
 713     Sequence< sal_Int8 > buf( MAX_PUT_DATA_LENGTH );
 714
 715     // Get the information about the input stream
 716
 717     Reference< XInputStream> inputStream =  boundParams[index - 1].getInputStream ();
 718     if ( !inputStream.is() )
 719     {
 720         ::connectivity::SharedResources aResources;
 721         const ::rtl::OUString sError( aResources.getResourceString(STR_NO_INPUTSTREAM));
 722         throw SQLException (sError, *this,::rtl::OUString(),0,Any());
 723     }
 724
 725     sal_Int32 maxBytesLeft = boundParams[index - 1].getInputStreamLen ();
 726
 727     // Loop while more data from the input stream
 728     sal_Int32 haveRead = 0;
 729     try
 730     {
 731
 732         do
 733         {
 734             sal_Int32 toReadThisRound = ::std::min( MAX_PUT_DATA_LENGTH, maxBytesLeft );
 735
 736             // Read some data from the input stream
 737             haveRead = inputStream->readBytes( buf, toReadThisRound );
 738             OSL_ENSURE( haveRead == buf.getLength(), "OPreparedStatement::putParamData: inconsistency!" );
 739
 740             if ( !haveRead )
 741                 // no more data in the stream - the given stream length was a maximum which could not be
 742                 // fulfilled by the stream
 743                 break;
 744
 745             // Put the data
 746             OSL_ENSURE( m_aStatementHandle, "OPreparedStatement::putParamData: StatementHandle is null!" );
 747             N3SQLPutData ( m_aStatementHandle, buf.getArray(), buf.getLength() );
 748
 749             // decrement the number of bytes still needed
 750             maxBytesLeft -= haveRead;
 751         }
 752         while ( maxBytesLeft > 0 );
 753     }
 754     catch (const IOException& ex)
 755     {
 756
 757         // If an I/O exception was generated, turn
 758         // it into a SQLException
 759
 760         throw SQLException(ex.Message,*this,::rtl::OUString(),0,Any());
 761     }
 762 }
 763 // -------------------------------------------------------------------------
 764
 765 //--------------------------------------------------------------------
 766 // setStream
 767 // Sets an input stream as a parameter, using the given SQL type
 768 //--------------------------------------------------------------------
 769
 770 void OPreparedStatement::setStream(
 771                                     sal_Int32 ParameterIndex,
 772                                     const Reference< XInputStream>& x,
 773                                     SQLLEN length,
 774                                     sal_Int32 SQLtype)
 775                                     throw(SQLException)
 776 {
 777     ::osl::MutexGuard aGuard( m_aMutex );
 778     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
 779
 780
 781     prepareStatement();
 782
 783     checkParameterIndex(ParameterIndex);
 784     // Get the buffer needed for the length
 785
 786     sal_Int8* lenBuf = getLengthBuf(ParameterIndex);
 787
 788     // Allocate a new buffer for the parameter data.  This buffer
 789     // will be returned by SQLParamData (it is set to the parameter
 790     // number, a 4-sal_Int8 integer)
 791
 792     sal_Int8* dataBuf = allocBindBuf (ParameterIndex, 4);
 793
 794     // Bind the parameter with SQL_LEN_DATA_AT_EXEC
 795     SQLSMALLINT   Ctype = SQL_C_CHAR;
 796     SQLLEN  atExec = SQL_LEN_DATA_AT_EXEC (length);
 797     memcpy (dataBuf, &ParameterIndex, sizeof(ParameterIndex));
 798     memcpy (lenBuf, &atExec, sizeof (atExec));
 799
 800     if ((SQLtype == SQL_BINARY) || (SQLtype == SQL_VARBINARY) || (SQLtype == SQL_LONGVARBINARY))
 801         Ctype = SQL_C_BINARY;
 802
 803
 804     OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 805     N3SQLBindParameter(m_aStatementHandle,
 806                         (SQLUSMALLINT)ParameterIndex,
 807                         (SQLUSMALLINT)SQL_PARAM_INPUT,
 808                         Ctype,
 809                         (SQLSMALLINT)SQLtype,
 810                         (SQLULEN)length,
 811                         0,
 812                         dataBuf,
 813                         sizeof(ParameterIndex),
 814                         (SQLLEN*)lenBuf);
 815
 816     // Save the input stream
 817     boundParams[ParameterIndex - 1].setInputStream (x, length);
 818 }
 819 // -------------------------------------------------------------------------
 820
 821 // -------------------------------------------------------------------------
 822
 823 void OPreparedStatement::FreeParams()
 824 {
 825     numParams = 0;
 826     delete [] boundParams;
 827     boundParams = NULL;
 828 }
 829 // -------------------------------------------------------------------------
 830 void OPreparedStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue) throw (Exception)
 831 {
 832     try
 833     {
 834         switch(nHandle)
 835         {
 836             case PROPERTY_ID_RESULTSETCONCURRENCY:
 837                 if(!isPrepared())
 838                     setResultSetConcurrency(comphelper::getINT32(rValue));
 839                 break;
 840             case PROPERTY_ID_RESULTSETTYPE:
 841                 if(!isPrepared())
 842                     setResultSetType(comphelper::getINT32(rValue));
 843                 break;
 844             case PROPERTY_ID_FETCHDIRECTION:
 845                 if(!isPrepared())
 846                     setFetchDirection(comphelper::getINT32(rValue));
 847                 break;
 848             case PROPERTY_ID_USEBOOKMARKS:
 849                 if(!isPrepared())
 850                     setUsingBookmarks(comphelper::getBOOL(rValue));
 851                 break;
 852             default:
 853                 OStatement_Base::setFastPropertyValue_NoBroadcast(nHandle,rValue);
 854         }
 855     }
 856     catch(const SQLException&)
 857     {
 858         //  throw Exception(e.Message,*this);
 859     }
 860 }
 861 // -----------------------------------------------------------------------------
 862 void OPreparedStatement::prepareStatement()
 863 {
 864     if(!isPrepared())
 865     {
 866         OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
 867         ::rtl::OString aSql(::rtl::OUStringToOString(m_sSqlStatement,getOwnConnection()->getTextEncoding()));
 868         SQLRETURN nReturn = N3SQLPrepare(m_aStatementHandle,(SDB_ODBC_CHAR *) aSql.getStr(),aSql.getLength());
 869         OTools::ThrowException(m_pConnection,nReturn,m_aStatementHandle,SQL_HANDLE_STMT,*this);
 870         m_bPrepared = sal_True;
 871         initBoundParam();
 872     }
 873 }
 874 // -----------------------------------------------------------------------------
 875 void OPreparedStatement::checkParameterIndex(sal_Int32 _parameterIndex)
 876 {
 877     if( !_parameterIndex || _parameterIndex > numParams)
 878     {
 879         ::connectivity::SharedResources aResources;
 880         const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution(STR_WRONG_PARAM_INDEX,
 881             "$pos$", ::rtl::OUString::valueOf(_parameterIndex),
 882             "$count$", ::rtl::OUString::valueOf((sal_Int32)numParams)
 883             ));
 884         SQLException aNext(sError,*this, ::rtl::OUString(),0,Any());
 885
 886         ::dbtools::throwInvalidIndexException(*this,makeAny(aNext));
 887     }
 888 }
 889 // -----------------------------------------------------------------------------
 890 OResultSet* OPreparedStatement::createResulSet()
 891 {
 892     OResultSet* pReturn = new OResultSet(m_aStatementHandle,this);
 893     pReturn->setMetaData(getMetaData());
 894     return pReturn;
 895 }
 896 // -----------------------------------------------------------------------------
 897
 898 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */