connectivity/source/drivers/firebird/PreparedStatement.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21 #include <cmath>
  22
  23 #include <string_view>
  24
  25 #include "Connection.hxx"
  26 #include "PreparedStatement.hxx"
  27 #include "ResultSet.hxx"
  28 #include "ResultSetMetaData.hxx"
  29 #include "Util.hxx"
  30
  31 #include <comphelper/sequence.hxx>
  32 #include <connectivity/dbexception.hxx>
  33 #include <propertyids.hxx>
  34 #include <connectivity/dbtools.hxx>
  35 #include <sal/log.hxx>
  36
  37 #include <com/sun/star/sdbc/DataType.hpp>
  38
  39 using namespace connectivity::firebird;
  40
  41 using namespace ::comphelper;
  42 using namespace ::osl;
  43
  44 using namespace com::sun::star;
  45 using namespace com::sun::star::uno;
  46 using namespace com::sun::star::lang;
  47 using namespace com::sun::star::beans;
  48 using namespace com::sun::star::sdbc;
  49 using namespace com::sun::star::container;
  50 using namespace com::sun::star::io;
  51 using namespace com::sun::star::util;
  52
  53 IMPLEMENT_SERVICE_INFO(OPreparedStatement,"com.sun.star.sdbcx.firebird.PreparedStatement","com.sun.star.sdbc.PreparedStatement");
  54
  55
  56 OPreparedStatement::OPreparedStatement( Connection* _pConnection,
  57                                         const OUString& sql)
  58     :OStatementCommonBase(_pConnection)
  59     ,m_sSqlStatement(sql)
  60     ,m_pOutSqlda(nullptr)
  61     ,m_pInSqlda(nullptr)
  62 {
  63     SAL_INFO("connectivity.firebird", "OPreparedStatement(). "
  64              "sql: " << sql);
  65 }
  66
  67 void OPreparedStatement::ensurePrepared()
  68 {
  69     MutexGuard aGuard(m_aMutex);
  70     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
  71
  72     if (m_aStatementHandle)
  73         return;
  74
  75     ISC_STATUS aErr = 0;
  76
  77     if (!m_pInSqlda)
  78     {
  79         m_pInSqlda = static_cast<XSQLDA*>(calloc(1, XSQLDA_LENGTH(10)));
  80         m_pInSqlda->version = SQLDA_VERSION1;
  81         m_pInSqlda->sqln = 10;
  82     }
  83
  84     prepareAndDescribeStatement(m_sSqlStatement,
  85                                m_pOutSqlda,
  86                                m_pInSqlda);
  87
  88     aErr = isc_dsql_describe_bind(m_statusVector,
  89                                   &m_aStatementHandle,
  90                                   1,
  91                                   m_pInSqlda);
  92
  93     if (aErr)
  94     {
  95         SAL_WARN("connectivity.firebird", "isc_dsql_describe_bind failed");
  96     }
  97     else if (m_pInSqlda->sqld > m_pInSqlda->sqln) // Not large enough
  98     {
  99         short nItems = m_pInSqlda->sqld;
 100         free(m_pInSqlda);
 101         m_pInSqlda = static_cast<XSQLDA*>(calloc(1, XSQLDA_LENGTH(nItems)));
 102         m_pInSqlda->version = SQLDA_VERSION1;
 103         m_pInSqlda->sqln = nItems;
 104         aErr = isc_dsql_describe_bind(m_statusVector,
 105                                       &m_aStatementHandle,
 106                                       1,
 107                                       m_pInSqlda);
 108         SAL_WARN_IF(aErr, "connectivity.firebird", "isc_dsql_describe_bind failed");
 109     }
 110
 111     if (!aErr)
 112         mallocSQLVAR(m_pInSqlda);
 113     else
 114         evaluateStatusVector(m_statusVector, m_sSqlStatement, *this);
 115 }
 116
 117 OPreparedStatement::~OPreparedStatement()
 118 {
 119 }
 120
 121 void SAL_CALL OPreparedStatement::acquire() noexcept
 122 {
 123     OStatementCommonBase::acquire();
 124 }
 125
 126 void SAL_CALL OPreparedStatement::release() noexcept
 127 {
 128     OStatementCommonBase::release();
 129 }
 130
 131 Any SAL_CALL OPreparedStatement::queryInterface(const Type& rType)
 132 {
 133     Any aRet = OStatementCommonBase::queryInterface(rType);
 134     if(!aRet.hasValue())
 135         aRet = OPreparedStatement_Base::queryInterface(rType);
 136     return aRet;
 137 }
 138
 139 uno::Sequence< Type > SAL_CALL OPreparedStatement::getTypes()
 140 {
 141     return concatSequences(OPreparedStatement_Base::getTypes(),
 142                            OStatementCommonBase::getTypes());
 143 }
 144
 145 Reference< XResultSetMetaData > SAL_CALL OPreparedStatement::getMetaData()
 146 {
 147     ::osl::MutexGuard aGuard( m_aMutex );
 148     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 149     ensurePrepared();
 150
 151     if(!m_xMetaData.is())
 152         m_xMetaData = new OResultSetMetaData(m_pConnection.get()
 153                                            , m_pOutSqlda);
 154
 155     return m_xMetaData;
 156 }
 157
 158 void SAL_CALL OPreparedStatement::close()
 159 {
 160     MutexGuard aGuard( m_aMutex );
 161     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 162
 163     OStatementCommonBase::close();
 164     if (m_pInSqlda)
 165     {
 166         freeSQLVAR(m_pInSqlda);
 167         free(m_pInSqlda);
 168         m_pInSqlda = nullptr;
 169     }
 170     if (m_pOutSqlda)
 171     {
 172         freeSQLVAR(m_pOutSqlda);
 173         free(m_pOutSqlda);
 174         m_pOutSqlda = nullptr;
 175     }
 176 }
 177
 178 void SAL_CALL OPreparedStatement::disposing()
 179 {
 180     close();
 181 }
 182
 183 void SAL_CALL OPreparedStatement::setString(sal_Int32 nParameterIndex,
 184                                             const OUString& sInput)
 185 {
 186     SAL_INFO("connectivity.firebird",
 187              "setString(" << nParameterIndex << " , " << sInput << ")");
 188
 189     MutexGuard aGuard( m_aMutex );
 190     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 191     ensurePrepared();
 192
 193     checkParameterIndex(nParameterIndex);
 194     setParameterNull(nParameterIndex, false);
 195
 196     OString str = OUStringToOString(sInput , RTL_TEXTENCODING_UTF8 );
 197
 198     XSQLVAR* pVar = m_pInSqlda->sqlvar + (nParameterIndex - 1);
 199
 200     int dtype = (pVar->sqltype & ~1); // drop flag bit for now
 201
 202     if (str.getLength() > pVar->sqllen)
 203         str = str.copy(0, pVar->sqllen);
 204
 205     switch (dtype) {
 206     case SQL_VARYING:
 207     {
 208         const sal_Int32 max_varchar_len = 0xFFFF;
 209         // First 2 bytes indicate string size
 210         if (str.getLength() > max_varchar_len)
 211         {
 212             str = str.copy(0, max_varchar_len);
 213         }
 214         const auto nLength = str.getLength();
 215         memcpy(pVar->sqldata, &nLength, 2);
 216         // Actual data
 217         memcpy(pVar->sqldata + 2, str.getStr(), str.getLength());
 218         break;
 219     }
 220     case SQL_TEXT:
 221         memcpy(pVar->sqldata, str.getStr(), str.getLength());
 222         // Fill remainder with spaces
 223         memset(pVar->sqldata + str.getLength(), ' ', pVar->sqllen - str.getLength());
 224         break;
 225     case SQL_BLOB: // Clob
 226         assert( pVar->sqlsubtype == static_cast<short>(BlobSubtype::Clob) );
 227         setClob(nParameterIndex, sInput );
 228         break;
 229     case SQL_SHORT:
 230     {
 231         sal_Int32 int32Value = sInput.toInt32();
 232         if ( (int32Value < std::numeric_limits<sal_Int16>::min()) ||
 233              (int32Value > std::numeric_limits<sal_Int16>::max()) )
 234         {
 235             ::dbtools::throwSQLException(
 236                 "Value out of range for SQL_SHORT type",
 237                 ::dbtools::StandardSQLState::INVALID_SQL_DATA_TYPE,
 238                 *this);
 239         }
 240         setShort(nParameterIndex, int32Value);
 241         break;
 242     }
 243     case SQL_LONG:
 244     {
 245         sal_Int32 int32Value = sInput.toInt32();
 246         setInt(nParameterIndex, int32Value);
 247         break;
 248     }
 249     case SQL_INT64:
 250     {
 251         sal_Int64 int64Value = sInput.toInt64();
 252         setLong(nParameterIndex, int64Value);
 253         break;
 254     }
 255     case SQL_FLOAT:
 256     {
 257         float floatValue = sInput.toFloat();
 258         setFloat(nParameterIndex, floatValue);
 259         break;
 260     }
 261     case SQL_BOOLEAN:
 262     {
 263         bool boolValue = sInput.toBoolean();
 264         setBoolean(nParameterIndex, boolValue);
 265         break;
 266     }
 267     default:
 268         ::dbtools::throwSQLException(
 269             "Incorrect type for setString",
 270             ::dbtools::StandardSQLState::INVALID_SQL_DATA_TYPE,
 271             *this);
 272     }
 273 }
 274
 275 Reference< XConnection > SAL_CALL OPreparedStatement::getConnection()
 276 {
 277     MutexGuard aGuard( m_aMutex );
 278     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 279
 280     return m_pConnection;
 281 }
 282
 283 sal_Bool SAL_CALL OPreparedStatement::execute()
 284 {
 285     SAL_INFO("connectivity.firebird", "executeQuery(). "
 286         "Got called with sql: " <<  m_sSqlStatement);
 287
 288     MutexGuard aGuard( m_aMutex );
 289     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 290
 291     ensurePrepared();
 292
 293     ISC_STATUS aErr;
 294
 295     if (m_xResultSet.is()) // Checks whether we have already run the statement.
 296     {
 297         disposeResultSet();
 298         // Closes the cursor from the last run.
 299         // This doesn't actually free the statement -- using DSQL_close closes
 300         // the cursor and keeps the statement, using DSQL_drop frees the statement
 301         // (and associated cursors).
 302         aErr = isc_dsql_free_statement(m_statusVector,
 303                                        &m_aStatementHandle,
 304                                        DSQL_close);
 305         if (aErr)
 306         {
 307             // Do not throw error. Trying to close a closed cursor is not a
 308             // critical mistake.
 309             OUString sErrMsg  = StatusVectorToString(m_statusVector,
 310                     u"isc_dsql_free_statement: close cursor");
 311             SAL_WARN("connectivity.firebird", sErrMsg);
 312         }
 313     }
 314
 315     aErr = isc_dsql_execute(m_statusVector,
 316                                 &m_pConnection->getTransaction(),
 317                                 &m_aStatementHandle,
 318                                 1,
 319                                 m_pInSqlda);
 320     if (aErr)
 321     {
 322         SAL_WARN("connectivity.firebird", "isc_dsql_execute failed" );
 323         evaluateStatusVector(m_statusVector, u"isc_dsql_execute", *this);
 324     }
 325
 326     m_xResultSet = new OResultSet(m_pConnection.get(),
 327                                   m_aMutex,
 328                                   uno::Reference< XInterface >(*this),
 329                                   m_aStatementHandle,
 330                                   m_pOutSqlda);
 331
 332     if (getStatementChangeCount() > 0)
 333         m_pConnection->notifyDatabaseModified();
 334
 335     return m_xResultSet.is();
 336     // TODO: implement handling of multiple ResultSets.
 337 }
 338
 339 sal_Int32 SAL_CALL OPreparedStatement::executeUpdate()
 340 {
 341     execute();
 342     return getStatementChangeCount();
 343 }
 344
 345 Reference< XResultSet > SAL_CALL OPreparedStatement::executeQuery()
 346 {
 347     execute();
 348     return m_xResultSet;
 349 }
 350
 351 namespace {
 352
 353 /**
 354  * Take out the number part of a fix point decimal without
 355  * the information of where is the fractional part from a
 356  * string representation of a number. (e.g. 54.654 -> 54654)
 357  */
 358 sal_Int64 toNumericWithoutDecimalPlace(const OUString& sSource)
 359 {
 360     OUString sNumber(sSource);
 361
 362     // cut off leading 0 eventually ( eg. 0.567 -> .567)
 363     (void)sSource.startsWith("0", &sNumber);
 364
 365     sal_Int32 nDotIndex = sNumber.indexOf('.');
 366
 367     if( nDotIndex < 0)
 368     {
 369         return sNumber.toInt64(); // no dot -> it's an integer
 370     }
 371     else
 372     {
 373         // remove dot
 374         OUStringBuffer sBuffer(15);
 375         if(nDotIndex > 0)
 376         {
 377             sBuffer.append(sNumber.subView(0, nDotIndex));
 378         }
 379         sBuffer.append(sNumber.subView(nDotIndex + 1));
 380         return sBuffer.makeStringAndClear().toInt64();
 381     }
 382 }
 383
 384 }
 385
 386 //----- XParameters -----------------------------------------------------------
 387 void SAL_CALL OPreparedStatement::setNull(sal_Int32 nIndex, sal_Int32 /*nSqlType*/)
 388 {
 389     MutexGuard aGuard( m_aMutex );
 390     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 391     ensurePrepared();
 392
 393     checkParameterIndex(nIndex);
 394     setParameterNull(nIndex);
 395 }
 396
 397 void SAL_CALL OPreparedStatement::setBoolean(sal_Int32 nIndex, sal_Bool bValue)
 398 {
 399     setValue< sal_Bool >(nIndex, bValue, SQL_BOOLEAN);
 400 }
 401
 402 template <typename T>
 403 void OPreparedStatement::setValue(sal_Int32 nIndex, const T& nValue, ISC_SHORT nType)
 404 {
 405     MutexGuard aGuard( m_aMutex );
 406     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 407     ensurePrepared();
 408
 409     checkParameterIndex(nIndex);
 410     setParameterNull(nIndex, false);
 411
 412     XSQLVAR* pVar = m_pInSqlda->sqlvar + (nIndex - 1);
 413
 414     if ((pVar->sqltype & ~1) != nType)
 415     {
 416        ::dbtools::throwSQLException(
 417             "Incorrect type for setValue",
 418             ::dbtools::StandardSQLState::INVALID_SQL_DATA_TYPE,
 419             *this);
 420     }
 421
 422     memcpy(pVar->sqldata, &nValue, sizeof(nValue));
 423 }
 424
 425 void SAL_CALL OPreparedStatement::setByte(sal_Int32 nIndex, sal_Int8 nValue)
 426 {
 427     // there's no TINYINT or equivalent on Firebird,
 428     // so do the same as setShort
 429     setValue< sal_Int16 >(nIndex, nValue, SQL_SHORT);
 430 }
 431
 432 void SAL_CALL OPreparedStatement::setShort(sal_Int32 nIndex, sal_Int16 nValue)
 433 {
 434     setValue< sal_Int16 >(nIndex, nValue, SQL_SHORT);
 435 }
 436
 437 void SAL_CALL OPreparedStatement::setInt(sal_Int32 nIndex, sal_Int32 nValue)
 438 {
 439     setValue< sal_Int32 >(nIndex, nValue, SQL_LONG);
 440 }
 441
 442 void SAL_CALL OPreparedStatement::setLong(sal_Int32 nIndex, sal_Int64 nValue)
 443 {
 444     setValue< sal_Int64 >(nIndex, nValue, SQL_INT64);
 445 }
 446
 447 void SAL_CALL OPreparedStatement::setFloat(sal_Int32 nIndex, float nValue)
 448 {
 449     setValue< float >(nIndex, nValue, SQL_FLOAT);
 450 }
 451
 452 void SAL_CALL OPreparedStatement::setDouble(sal_Int32 nIndex, double nValue)
 453 {
 454     MutexGuard aGuard( m_aMutex );
 455     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 456     ensurePrepared();
 457
 458     XSQLVAR* pVar = m_pInSqlda->sqlvar + (nIndex - 1);
 459     short dType = (pVar->sqltype & ~1); // drop flag bit for now
 460     short dSubType = pVar->sqlsubtype;
 461     // Assume it is a sub type of a number.
 462     if(dSubType < 0 || dSubType > 2)
 463     {
 464         ::dbtools::throwSQLException(
 465             "Incorrect number sub type",
 466             ::dbtools::StandardSQLState::INVALID_SQL_DATA_TYPE,
 467             *this);
 468     }
 469     // firebird stores scale as a negative number
 470     ColumnTypeInfo columnType{ dType, dSubType,
 471         static_cast<short>(-pVar->sqlscale) };
 472
 473     // Caller might try to set an integer type here. It makes sense to convert
 474     // it instead of throwing an error.
 475     switch(columnType.getSdbcType())
 476     {
 477         case DataType::SMALLINT:
 478             setValue< sal_Int16 >(nIndex,
 479                     static_cast<sal_Int16>(nValue),
 480                     dType);
 481             break;
 482         case DataType::INTEGER:
 483             setValue< sal_Int32 >(nIndex,
 484                     static_cast<sal_Int32>(nValue),
 485                     dType);
 486             break;
 487         case DataType::BIGINT:
 488             setValue< sal_Int64 >(nIndex,
 489                     static_cast<sal_Int64>(nValue),
 490                     dType);
 491             break;
 492         case DataType::NUMERIC:
 493         case DataType::DECIMAL:
 494             // take decimal places into account, later on they are removed in makeNumericString
 495             setObjectWithInfo(nIndex,Any{nValue}, columnType.getSdbcType(), columnType.getScale());
 496             break;
 497         default:
 498             setValue< double >(nIndex, nValue, SQL_DOUBLE); // TODO: SQL_D_FLOAT?
 499     }
 500 }
 501
 502 void SAL_CALL OPreparedStatement::setDate(sal_Int32 nIndex, const Date& rDate)
 503 {
 504     struct tm aCTime;
 505     aCTime.tm_mday = rDate.Day;
 506     aCTime.tm_mon = rDate.Month -1;
 507     aCTime.tm_year = rDate.Year -1900;
 508
 509     ISC_DATE aISCDate;
 510     isc_encode_sql_date(&aCTime, &aISCDate);
 511
 512     setValue< ISC_DATE >(nIndex, aISCDate, SQL_TYPE_DATE);
 513 }
 514
 515 void SAL_CALL OPreparedStatement::setTime( sal_Int32 nIndex, const css::util::Time& rTime)
 516 {
 517     struct tm aCTime;
 518     aCTime.tm_sec = rTime.Seconds;
 519     aCTime.tm_min = rTime.Minutes;
 520     aCTime.tm_hour = rTime.Hours;
 521
 522     ISC_TIME aISCTime;
 523     isc_encode_sql_time(&aCTime, &aISCTime);
 524
 525     // Here we "know" that ISC_TIME is simply in units of seconds/ISC_TIME_SECONDS_PRECISION with no
 526     // other funkiness, so we can simply add the fraction of a second.
 527     aISCTime += rTime.NanoSeconds / (1000000000 / ISC_TIME_SECONDS_PRECISION);
 528
 529     setValue< ISC_TIME >(nIndex, aISCTime, SQL_TYPE_TIME);
 530 }
 531
 532 void SAL_CALL OPreparedStatement::setTimestamp(sal_Int32 nIndex, const DateTime& rTimestamp)
 533 {
 534     struct tm aCTime;
 535     aCTime.tm_sec = rTimestamp.Seconds;
 536     aCTime.tm_min = rTimestamp.Minutes;
 537     aCTime.tm_hour = rTimestamp.Hours;
 538     aCTime.tm_mday = rTimestamp.Day;
 539     aCTime.tm_mon = rTimestamp.Month - 1;
 540     aCTime.tm_year = rTimestamp.Year - 1900;
 541
 542     ISC_TIMESTAMP aISCTimestamp;
 543     isc_encode_timestamp(&aCTime, &aISCTimestamp);
 544
 545     // As in previous function
 546     aISCTimestamp.timestamp_time += rTimestamp.NanoSeconds / (1000000000 / ISC_TIME_SECONDS_PRECISION);
 547
 548     setValue< ISC_TIMESTAMP >(nIndex, aISCTimestamp, SQL_TIMESTAMP);
 549 }
 550
 551
 552 // void OPreparedStatement::set
 553 void OPreparedStatement::openBlobForWriting(isc_blob_handle& rBlobHandle, ISC_QUAD& rBlobId)
 554 {
 555     ISC_STATUS aErr;
 556
 557     aErr = isc_create_blob2(m_statusVector,
 558                             &m_pConnection->getDBHandle(),
 559                             &m_pConnection->getTransaction(),
 560                             &rBlobHandle,
 561                             &rBlobId,
 562                             0, // Blob parameter buffer length
 563                             nullptr); // Blob parameter buffer handle
 564
 565     if (aErr)
 566     {
 567         evaluateStatusVector(m_statusVector,
 568                              OUString("setBlob failed on " + m_sSqlStatement),
 569                              *this);
 570         assert(false);
 571     }
 572 }
 573
 574 void OPreparedStatement::closeBlobAfterWriting(isc_blob_handle& rBlobHandle)
 575 {
 576     ISC_STATUS aErr;
 577
 578     aErr = isc_close_blob(m_statusVector,
 579             &rBlobHandle);
 580     if (aErr)
 581     {
 582         evaluateStatusVector(m_statusVector,
 583                 u"isc_close_blob failed",
 584                 *this);
 585         assert(false);
 586     }
 587 }
 588
 589 void SAL_CALL OPreparedStatement::setClob(sal_Int32 nParameterIndex, const Reference< XClob >& xClob )
 590 {
 591     ::osl::MutexGuard aGuard( m_aMutex );
 592     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 593
 594 #if SAL_TYPES_SIZEOFPOINTER == 8
 595     isc_blob_handle aBlobHandle = 0;
 596 #else
 597     isc_blob_handle aBlobHandle = nullptr;
 598 #endif
 599     ISC_QUAD aBlobId;
 600
 601     openBlobForWriting(aBlobHandle, aBlobId);
 602
 603
 604     // Max segment size is 2^16 == SAL_MAX_UINT16
 605     // SAL_MAX_UINT16 / 4 is surely enough for UTF-8
 606     // TODO apply max segment size to character encoding
 607     sal_Int64 nCharWritten = 1; // XClob is indexed from 1
 608     ISC_STATUS aErr = 0;
 609     sal_Int64 nLen = xClob->length();
 610     while ( nLen > nCharWritten )
 611     {
 612         sal_Int64 nCharRemain = nLen - nCharWritten;
 613         constexpr sal_uInt16 MAX_SIZE = SAL_MAX_UINT16 / 4;
 614         sal_uInt16 nWriteSize = std::min<sal_Int64>(nCharRemain, MAX_SIZE);
 615         OString sData = OUStringToOString(
 616                 xClob->getSubString(nCharWritten, nWriteSize),
 617                 RTL_TEXTENCODING_UTF8);
 618         aErr = isc_put_segment( m_statusVector,
 619                 &aBlobHandle,
 620                 sData.getLength(),
 621                 sData.getStr() );
 622         nCharWritten += nWriteSize;
 623
 624         if (aErr)
 625             break;
 626     }
 627
 628     // We need to make sure we close the Blob even if there are errors, hence evaluate
 629     // errors after closing.
 630     closeBlobAfterWriting(aBlobHandle);
 631
 632     if (aErr)
 633     {
 634         evaluateStatusVector(m_statusVector,
 635                 u"isc_put_segment failed",
 636                 *this);
 637         assert(false);
 638     }
 639
 640     setValue< ISC_QUAD >(nParameterIndex, aBlobId, SQL_BLOB);
 641 }
 642
 643 void OPreparedStatement::setClob( sal_Int32 nParameterIndex, const OUString& rStr )
 644 {
 645     ::osl::MutexGuard aGuard( m_aMutex );
 646     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 647     checkParameterIndex(nParameterIndex);
 648
 649 #if SAL_TYPES_SIZEOFPOINTER == 8
 650     isc_blob_handle aBlobHandle = 0;
 651 #else
 652     isc_blob_handle aBlobHandle = nullptr;
 653 #endif
 654     ISC_QUAD aBlobId;
 655
 656     openBlobForWriting(aBlobHandle, aBlobId);
 657
 658     OString sData = OUStringToOString(
 659             rStr,
 660             RTL_TEXTENCODING_UTF8);
 661     ISC_STATUS aErr = isc_put_segment( m_statusVector,
 662                             &aBlobHandle,
 663                             sData.getLength(),
 664                             sData.getStr() );
 665
 666     // We need to make sure we close the Blob even if there are errors, hence evaluate
 667     // errors after closing.
 668     closeBlobAfterWriting(aBlobHandle);
 669
 670     if (aErr)
 671     {
 672         evaluateStatusVector(m_statusVector,
 673                              u"isc_put_segment failed",
 674                              *this);
 675         assert(false);
 676     }
 677
 678     setValue< ISC_QUAD >(nParameterIndex, aBlobId, SQL_BLOB);
 679 }
 680
 681 void SAL_CALL OPreparedStatement::setBlob(sal_Int32 nParameterIndex,
 682                                           const Reference< XBlob >& xBlob)
 683 {
 684     ::osl::MutexGuard aGuard(m_aMutex);
 685     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 686     checkParameterIndex(nParameterIndex);
 687
 688 #if SAL_TYPES_SIZEOFPOINTER == 8
 689     isc_blob_handle aBlobHandle = 0;
 690 #else
 691     isc_blob_handle aBlobHandle = nullptr;
 692 #endif
 693     ISC_QUAD aBlobId;
 694
 695     openBlobForWriting(aBlobHandle, aBlobId);
 696
 697     ISC_STATUS aErr = 0;
 698     const sal_Int64 nBlobLen = xBlob->length();
 699     if (nBlobLen > 0)
 700     {
 701         // Max write size is 0xFFFF == SAL_MAX_UINT16
 702         sal_uInt64 nDataWritten = 0;
 703         while (sal::static_int_cast<sal_uInt64>(nBlobLen) > nDataWritten)
 704         {
 705             sal_uInt64 nDataRemaining = nBlobLen - nDataWritten;
 706             sal_uInt16 nWriteSize = std::min(nDataRemaining, sal_uInt64(SAL_MAX_UINT16));
 707             aErr = isc_put_segment(m_statusVector,
 708                                    &aBlobHandle,
 709                                    nWriteSize,
 710                                    reinterpret_cast<const char*>(xBlob->getBytes(nDataWritten, nWriteSize).getConstArray()));
 711             nDataWritten += nWriteSize;
 712
 713             if (aErr)
 714                 break;
 715         }
 716     }
 717
 718     // We need to make sure we close the Blob even if there are errors, hence evaluate
 719     // errors after closing.
 720     closeBlobAfterWriting(aBlobHandle);
 721
 722     if (aErr)
 723     {
 724         evaluateStatusVector(m_statusVector,
 725                              u"isc_put_segment failed",
 726                              *this);
 727         assert(false);
 728     }
 729
 730     setValue< ISC_QUAD >(nParameterIndex, aBlobId, SQL_BLOB);
 731 }
 732
 733
 734 void SAL_CALL OPreparedStatement::setArray( sal_Int32 nIndex, const Reference< XArray >& )
 735 {
 736     ::osl::MutexGuard aGuard( m_aMutex );
 737     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 738     checkParameterIndex(nIndex);
 739 }
 740
 741
 742 void SAL_CALL OPreparedStatement::setRef( sal_Int32 nIndex, const Reference< XRef >& )
 743 {
 744     ::osl::MutexGuard aGuard( m_aMutex );
 745     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 746     checkParameterIndex(nIndex);
 747 }
 748
 749
 750 void SAL_CALL OPreparedStatement::setObjectWithInfo( sal_Int32 parameterIndex, const Any& x, sal_Int32 sqlType, sal_Int32 scale )
 751 {
 752     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 753     ::osl::MutexGuard aGuard( m_aMutex );
 754     ensurePrepared();
 755
 756     checkParameterIndex(parameterIndex);
 757     setParameterNull(parameterIndex, false);
 758
 759     XSQLVAR* pVar = m_pInSqlda->sqlvar + (parameterIndex - 1);
 760     int dType = (pVar->sqltype & ~1); // drop null flag
 761
 762     if(sqlType == DataType::DECIMAL || sqlType == DataType::NUMERIC)
 763     {
 764         double dbValue =0.0;
 765         OUString sValue;
 766         if( x >>= dbValue )
 767         {
 768             // truncate and round to 'scale' number of decimal places
 769             sValue = OUString::number( std::floor((dbValue * pow10Integer(scale)) + .5) / pow10Integer(scale) );
 770         }
 771         else
 772         {
 773             x >>= sValue;
 774         }
 775
 776         // fill in the number with nulls in fractional part.
 777         // We need this because  e.g. 0.450 != 0.045 despite
 778         // their scale is equal
 779         OUStringBuffer sBuffer(15);
 780         sBuffer.append(sValue);
 781         if(sValue.indexOf('.') != -1) // there is a dot
 782         {
 783             for(sal_Int32 i=sValue.copy(sValue.indexOf('.')+1).getLength(); i<scale;i++)
 784             {
 785                 sBuffer.append('0');
 786             }
 787         }
 788         else
 789         {
 790             for (sal_Int32 i=0; i<scale; i++)
 791             {
 792                 sBuffer.append('0');
 793             }
 794         }
 795
 796         sValue = sBuffer.makeStringAndClear();
 797         switch(dType)
 798         {
 799             case SQL_SHORT:
 800                 setValue< sal_Int16 >(parameterIndex,
 801                         static_cast<sal_Int16>( toNumericWithoutDecimalPlace(sValue) ),
 802                         dType);
 803                 break;
 804             case SQL_LONG:
 805             case SQL_DOUBLE:
 806                 setValue< sal_Int32 >(parameterIndex,
 807                         static_cast<sal_Int32>( toNumericWithoutDecimalPlace(sValue) ),
 808                         dType);
 809                 break;
 810             case SQL_INT64:
 811                 setValue< sal_Int64 >(parameterIndex,
 812                         toNumericWithoutDecimalPlace(sValue),
 813                         dType);
 814                 break;
 815             default:
 816                 SAL_WARN("connectivity.firebird",
 817                         "No Firebird sql type found for numeric or decimal types");
 818                 ::dbtools::setObjectWithInfo(this,parameterIndex,x,sqlType,scale);
 819         }
 820     }
 821     else
 822     {
 823         ::dbtools::setObjectWithInfo(this,parameterIndex,x,sqlType,scale);
 824     }
 825
 826 }
 827
 828
 829 void SAL_CALL OPreparedStatement::setObjectNull( sal_Int32 nIndex, sal_Int32, const OUString& )
 830 {
 831     ::osl::MutexGuard aGuard( m_aMutex );
 832     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 833     checkParameterIndex(nIndex);
 834 }
 835
 836
 837 void SAL_CALL OPreparedStatement::setObject( sal_Int32 nIndex, const Any& )
 838 {
 839     ::osl::MutexGuard aGuard( m_aMutex );
 840     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 841     checkParameterIndex(nIndex);
 842 }
 843
 844 void SAL_CALL OPreparedStatement::setBytes(sal_Int32 nParameterIndex,
 845                                            const Sequence< sal_Int8 >& xBytes)
 846 {
 847     ::osl::MutexGuard aGuard(m_aMutex);
 848     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 849     checkParameterIndex(nParameterIndex);
 850
 851     XSQLVAR* pVar = m_pInSqlda->sqlvar + (nParameterIndex - 1);
 852     int dType = (pVar->sqltype & ~1); // drop flag bit for now
 853
 854     if( dType == SQL_BLOB )
 855     {
 856 #if SAL_TYPES_SIZEOFPOINTER == 8
 857         isc_blob_handle aBlobHandle = 0;
 858 #else
 859         isc_blob_handle aBlobHandle = nullptr;
 860 #endif
 861         ISC_QUAD aBlobId;
 862
 863         openBlobForWriting(aBlobHandle, aBlobId);
 864
 865         ISC_STATUS aErr = 0;
 866         const sal_Int32 nBytesLen = xBytes.getLength();
 867         if (nBytesLen > 0)
 868         {
 869             // Max write size is 0xFFFF == SAL_MAX_UINT16
 870             sal_uInt32 nDataWritten = 0;
 871             while (sal::static_int_cast<sal_uInt32>(nBytesLen) > nDataWritten)
 872             {
 873                 sal_uInt32 nDataRemaining = nBytesLen - nDataWritten;
 874                 sal_uInt16 nWriteSize = std::min(nDataRemaining, sal_uInt32(SAL_MAX_UINT16));
 875                 aErr = isc_put_segment(m_statusVector,
 876                                        &aBlobHandle,
 877                                        nWriteSize,
 878                                        reinterpret_cast<const char*>(xBytes.getConstArray()) + nDataWritten);
 879                 nDataWritten += nWriteSize;
 880
 881                 if (aErr)
 882                     break;
 883             }
 884         }
 885
 886         // We need to make sure we close the Blob even if there are errors, hence evaluate
 887         // errors after closing.
 888         closeBlobAfterWriting(aBlobHandle);
 889
 890         if (aErr)
 891         {
 892             evaluateStatusVector(m_statusVector,
 893                                  u"isc_put_segment failed",
 894                                  *this);
 895             assert(false);
 896         }
 897
 898         setValue< ISC_QUAD >(nParameterIndex, aBlobId, SQL_BLOB);
 899     }
 900     else if( dType == SQL_VARYING )
 901     {
 902             setParameterNull(nParameterIndex, false);
 903             const sal_Int32 nMaxSize = 0xFFFF;
 904             Sequence<sal_Int8> xBytesCopy(xBytes);
 905             if (xBytesCopy.getLength() > nMaxSize)
 906             {
 907                 xBytesCopy.realloc( nMaxSize );
 908             }
 909             const auto nSize = xBytesCopy.getLength();
 910             // 8000 corresponds to value from lcl_addDefaultParameters
 911             // in dbaccess/source/filter/hsqldb/createparser.cxx
 912             if (nSize > 8000)
 913             {
 914                 free(pVar->sqldata);
 915                 pVar->sqldata = static_cast<char *>(malloc(sizeof(char) * nSize + 2));
 916             }
 917             // First 2 bytes indicate string size
 918             memcpy(pVar->sqldata, &nSize, 2);
 919             // Actual data
 920             memcpy(pVar->sqldata + 2, xBytesCopy.getConstArray(), nSize);
 921     }
 922     else if( dType == SQL_TEXT )
 923     {
 924             setParameterNull(nParameterIndex, false);
 925             memcpy(pVar->sqldata, xBytes.getConstArray(), xBytes.getLength() );
 926             // Fill remainder with spaces
 927             memset(pVar->sqldata + xBytes.getLength(), 0, pVar->sqllen - xBytes.getLength());
 928     }
 929     else
 930     {
 931         ::dbtools::throwSQLException(
 932             "Incorrect type for setBytes",
 933             ::dbtools::StandardSQLState::INVALID_SQL_DATA_TYPE,
 934             *this);
 935     }
 936 }
 937
 938
 939 void SAL_CALL OPreparedStatement::setCharacterStream( sal_Int32 nIndex, const Reference< css::io::XInputStream >&, sal_Int32 )
 940 {
 941     ::osl::MutexGuard aGuard( m_aMutex );
 942     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 943     checkParameterIndex(nIndex);
 944 }
 945
 946
 947 void SAL_CALL OPreparedStatement::setBinaryStream( sal_Int32 nIndex, const Reference< css::io::XInputStream >&, sal_Int32 )
 948 {
 949     ::osl::MutexGuard aGuard( m_aMutex );
 950     checkDisposed(OStatementCommonBase_Base::rBHelper.bDisposed);
 951     checkParameterIndex(nIndex);
 952 }
 953
 954
 955 void SAL_CALL OPreparedStatement::clearParameters(  )
 956 {
 957 }
 958
 959 // ---- Batch methods -- unsupported -----------------------------------------
 960 void SAL_CALL OPreparedStatement::clearBatch()
 961 {
 962     // Unsupported
 963 }
 964
 965 void SAL_CALL OPreparedStatement::addBatch()
 966 {
 967     // Unsupported by firebird
 968 }
 969
 970 Sequence< sal_Int32 > SAL_CALL OPreparedStatement::executeBatch()
 971 {
 972     // Unsupported by firebird
 973     return Sequence< sal_Int32 >();
 974 }
 975
 976 void OPreparedStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue)
 977 {
 978     switch(nHandle)
 979     {
 980         case PROPERTY_ID_RESULTSETCONCURRENCY:
 981             break;
 982         case PROPERTY_ID_RESULTSETTYPE:
 983             break;
 984         case PROPERTY_ID_FETCHDIRECTION:
 985             break;
 986         case PROPERTY_ID_USEBOOKMARKS:
 987             break;
 988         default:
 989             OStatementCommonBase::setFastPropertyValue_NoBroadcast(nHandle,rValue);
 990     }
 991 }
 992
 993 void OPreparedStatement::checkParameterIndex(sal_Int32 nParameterIndex)
 994 {
 995     ensurePrepared();
 996     if ((nParameterIndex == 0) || (nParameterIndex > m_pInSqlda->sqld))
 997     {
 998         ::dbtools::throwSQLException(
 999             "No column " + OUString::number(nParameterIndex),
1000             ::dbtools::StandardSQLState::COLUMN_NOT_FOUND,
1001             *this);
1002     }
1003 }
1004
1005 void OPreparedStatement::setParameterNull(sal_Int32 nParameterIndex,
1006                                           bool bSetNull)
1007 {
1008     XSQLVAR* pVar = m_pInSqlda->sqlvar + (nParameterIndex - 1);
1009     if (bSetNull)
1010     {
1011         pVar->sqltype |= 1;
1012         *pVar->sqlind = -1;
1013     }
1014     else
1015         *pVar->sqlind = 0;
1016 }
1017
1018 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */