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