connectivity/source/drivers/firebird/ResultSet.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 "ResultSet.hxx"
  21 #include "ResultSetMetaData.hxx"
  22 #include "Util.hxx"
  23
  24 #include <comphelper/sequence.hxx>
  25 #include <cppuhelper/supportsservice.hxx>
  26 #include <connectivity/dbexception.hxx>
  27 #include <propertyids.hxx>
  28 #include <rtl/ustrbuf.hxx>
  29 #include <sal/log.hxx>
  30 #include <TConnection.hxx>
  31
  32 #include <com/sun/star/beans/PropertyAttribute.hpp>
  33 #include <com/sun/star/sdbc/DataType.hpp>
  34 #include <com/sun/star/sdbc/FetchDirection.hpp>
  35 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
  36 #include <com/sun/star/sdbc/ResultSetType.hpp>
  37 #include <com/sun/star/sdbc/SQLException.hpp>
  38
  39 using namespace ::comphelper;
  40 using namespace ::connectivity;
  41 using namespace ::connectivity::firebird;
  42 using namespace ::cppu;
  43 using namespace ::dbtools;
  44 using namespace ::osl;
  45
  46 using namespace ::com::sun::star;
  47 using namespace ::com::sun::star::uno;
  48 using namespace ::com::sun::star::lang;
  49 using namespace ::com::sun::star::beans;
  50 using namespace ::com::sun::star::sdbc;
  51 using namespace ::com::sun::star::sdbcx;
  52 using namespace ::com::sun::star::container;
  53 using namespace ::com::sun::star::io;
  54 using namespace ::com::sun::star::util;
  55
  56 OResultSet::OResultSet(Connection* pConnection,
  57                        ::osl::Mutex& rMutex,
  58                        const uno::Reference< XInterface >& xStatement,
  59                        isc_stmt_handle aStatementHandle,
  60                        XSQLDA* pSqlda )
  61     : OResultSet_BASE(rMutex)
  62     , OPropertyContainer(OResultSet_BASE::rBHelper)
  63     , m_bIsBookmarkable(false)
  64     , m_nFetchSize(1)
  65     , m_nResultSetType(css::sdbc::ResultSetType::FORWARD_ONLY)
  66     , m_nFetchDirection(css::sdbc::FetchDirection::FORWARD)
  67     , m_nResultSetConcurrency(css::sdbc::ResultSetConcurrency::READ_ONLY)
  68     , m_pConnection(pConnection)
  69     , m_rMutex(rMutex)
  70     , m_xStatement(xStatement)
  71     , m_pSqlda(pSqlda)
  72     , m_statementHandle(aStatementHandle)
  73     , m_bWasNull(false)
  74     , m_currentRow(0)
  75     , m_bIsAfterLastRow(false)
  76     , m_fieldCount(pSqlda? pSqlda->sqld : 0)
  77 {
  78     SAL_INFO("connectivity.firebird", "OResultSet().");
  79     registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISBOOKMARKABLE),
  80                      PROPERTY_ID_ISBOOKMARKABLE,
  81                      PropertyAttribute::READONLY,
  82                      &m_bIsBookmarkable,
  83                      cppu::UnoType<decltype(m_bIsBookmarkable)>::get());
  84     registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHSIZE),
  85                      PROPERTY_ID_FETCHSIZE,
  86                      PropertyAttribute::READONLY,
  87                      &m_nFetchSize,
  88                      cppu::UnoType<decltype(m_nFetchSize)>::get());
  89     registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETTYPE),
  90                      PROPERTY_ID_RESULTSETTYPE,
  91                      PropertyAttribute::READONLY,
  92                      &m_nResultSetType,
  93                      cppu::UnoType<decltype(m_nResultSetType)>::get());
  94     registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHDIRECTION),
  95                      PROPERTY_ID_FETCHDIRECTION,
  96                      PropertyAttribute::READONLY,
  97                      &m_nFetchDirection,
  98                      cppu::UnoType<decltype(m_nFetchDirection)>::get());
  99     registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETCONCURRENCY),
 100                      PROPERTY_ID_RESULTSETCONCURRENCY,
 101                      PropertyAttribute::READONLY,
 102                      &m_nResultSetConcurrency,
 103                      cppu::UnoType<decltype(m_nResultSetConcurrency)>::get());
 104
 105     if (!pSqlda)
 106         return; // TODO: what?
 107
 108 }
 109
 110 OResultSet::~OResultSet()
 111 {
 112 }
 113
 114 // ---- XResultSet -- Row retrieval methods ------------------------------------
 115 sal_Int32 SAL_CALL OResultSet::getRow()
 116 {
 117     MutexGuard aGuard(m_rMutex);
 118     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 119
 120     return m_currentRow;
 121 }
 122
 123 sal_Bool SAL_CALL OResultSet::next()
 124 {
 125     MutexGuard aGuard(m_rMutex);
 126     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 127
 128     m_currentRow++;
 129
 130     ISC_STATUS fetchStat = isc_dsql_fetch(m_statusVector,
 131                                &m_statementHandle,
 132                                1,
 133                                m_pSqlda);
 134     if (fetchStat == 0)         // SUCCESSFUL
 135     {
 136         return true;
 137     }
 138     else if (fetchStat == 100) // END OF DATASET
 139     {
 140         m_bIsAfterLastRow = true;
 141         return false;
 142     }
 143     else
 144     {
 145         SAL_WARN("connectivity.firebird", "Error when fetching data");
 146         // Throws sql exception as appropriate
 147         evaluateStatusVector(m_statusVector, u"isc_dsql_fetch", *this);
 148         return false;
 149     }
 150 }
 151
 152 sal_Bool SAL_CALL OResultSet::previous()
 153 {
 154     ::dbtools::throwFunctionNotSupportedSQLException("previous not supported in firebird",
 155                                                   *this);
 156     return false;
 157 }
 158
 159 sal_Bool SAL_CALL OResultSet::isLast()
 160 {
 161     ::dbtools::throwFunctionNotSupportedSQLException("isLast not supported in firebird",
 162                                                   *this);
 163     return false;
 164 }
 165
 166 sal_Bool SAL_CALL OResultSet::isBeforeFirst()
 167 {
 168     MutexGuard aGuard(m_rMutex);
 169     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 170
 171     return m_currentRow == 0;
 172 }
 173
 174 sal_Bool SAL_CALL OResultSet::isAfterLast()
 175 {
 176     MutexGuard aGuard(m_rMutex);
 177     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 178
 179     return m_bIsAfterLastRow;
 180 }
 181
 182 sal_Bool SAL_CALL OResultSet::isFirst()
 183 {
 184     MutexGuard aGuard(m_rMutex);
 185     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 186
 187     return m_currentRow == 1 && !m_bIsAfterLastRow;
 188 }
 189
 190 void SAL_CALL OResultSet::beforeFirst()
 191 {
 192     MutexGuard aGuard(m_rMutex);
 193     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 194
 195     if (m_currentRow != 0)
 196         ::dbtools::throwFunctionNotSupportedSQLException("beforeFirst not supported in firebird",
 197                                                       *this);
 198 }
 199
 200 void SAL_CALL OResultSet::afterLast()
 201 {
 202     MutexGuard aGuard(m_rMutex);
 203     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 204
 205     if (!m_bIsAfterLastRow)
 206         ::dbtools::throwFunctionNotSupportedSQLException("afterLast not supported in firebird",
 207                                                       *this);
 208 }
 209
 210 sal_Bool SAL_CALL OResultSet::first()
 211 {
 212     MutexGuard aGuard(m_rMutex);
 213     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 214
 215     if (m_currentRow == 0)
 216     {
 217         return next();
 218     }
 219     else if (m_currentRow == 1 && !m_bIsAfterLastRow)
 220     {
 221         return true;
 222     }
 223     else
 224     {
 225         ::dbtools::throwFunctionNotSupportedSQLException("first not supported in firebird",
 226                                                       *this);
 227         return false;
 228     }
 229 }
 230
 231 sal_Bool SAL_CALL OResultSet::last()
 232 {
 233     // We need to iterate past the last row to know when we've passed the last
 234     // row, hence we can't actually move to last.
 235     ::dbtools::throwFunctionNotSupportedSQLException("last not supported in firebird",
 236                                                   *this);
 237     return false;
 238 }
 239
 240 sal_Bool SAL_CALL OResultSet::absolute(sal_Int32 aRow)
 241 {
 242     MutexGuard aGuard(m_rMutex);
 243     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 244
 245     if (aRow > m_currentRow)
 246     {
 247         sal_Int32 aIterations = aRow - m_currentRow;
 248         return relative(aIterations);
 249     }
 250     else
 251     {
 252         ::dbtools::throwFunctionNotSupportedSQLException("absolute not supported in firebird",
 253                                                       *this);
 254         return false;
 255     }
 256 }
 257
 258 sal_Bool SAL_CALL OResultSet::relative(sal_Int32 row)
 259 {
 260     MutexGuard aGuard(m_rMutex);
 261     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 262
 263     if (row > 0)
 264     {
 265         while (row--)
 266         {
 267             if (!next())
 268                 return false;
 269         }
 270         return true;
 271     }
 272     else
 273     {
 274         ::dbtools::throwFunctionNotSupportedSQLException("relative not supported in firebird",
 275                                                       *this);
 276         return false;
 277     }
 278 }
 279
 280 void OResultSet::checkColumnIndex(sal_Int32 nIndex)
 281 {
 282     MutexGuard aGuard(m_rMutex);
 283     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 284
 285     if( nIndex < 1 || nIndex > m_fieldCount )
 286     {
 287         ::dbtools::throwSQLException(
 288             "No column " + OUString::number(nIndex),
 289             ::dbtools::StandardSQLState::COLUMN_NOT_FOUND,
 290             *this);
 291     }
 292 }
 293
 294 void OResultSet::checkRowIndex()
 295 {
 296     MutexGuard aGuard(m_rMutex);
 297     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 298
 299     if((m_currentRow < 1) || m_bIsAfterLastRow)
 300     {
 301         ::dbtools::throwSQLException(
 302             "Invalid Row",
 303             ::dbtools::StandardSQLState::INVALID_CURSOR_POSITION,
 304             *this);
 305     }
 306 }
 307
 308 Any SAL_CALL OResultSet::queryInterface( const Type & rType )
 309 {
 310     Any aRet = OPropertySetHelper::queryInterface(rType);
 311     return aRet.hasValue() ? aRet : OResultSet_BASE::queryInterface(rType);
 312 }
 313
 314  Sequence<  Type > SAL_CALL OResultSet::getTypes()
 315 {
 316     return concatSequences(OPropertySetHelper::getTypes(), OResultSet_BASE::getTypes());
 317 }
 318 // ---- XColumnLocate ---------------------------------------------------------
 319 sal_Int32 SAL_CALL OResultSet::findColumn(const OUString& rColumnName)
 320 {
 321     MutexGuard aGuard(m_rMutex);
 322     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 323
 324     uno::Reference< XResultSetMetaData > xMeta = getMetaData();
 325     sal_Int32 nLen = xMeta->getColumnCount();
 326     sal_Int32 i;
 327
 328     for(i = 1; i<=nLen; ++i)
 329     {
 330         // We assume case sensitive, otherwise you'd have to test
 331         // xMeta->isCaseSensitive and use qualsIgnoreAsciiCase as needed.
 332         if (rColumnName == xMeta->getColumnName(i))
 333             return i;
 334     }
 335
 336     ::dbtools::throwInvalidColumnException(rColumnName, *this);
 337     assert(false);
 338     return 0; // Never reached
 339 }
 340
 341 uno::Reference< XInputStream > SAL_CALL OResultSet::getBinaryStream( sal_Int32 )
 342 {
 343     MutexGuard aGuard(m_rMutex);
 344     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 345
 346     return nullptr;
 347 }
 348
 349 uno::Reference< XInputStream > SAL_CALL OResultSet::getCharacterStream( sal_Int32 )
 350 {
 351     MutexGuard aGuard(m_rMutex);
 352     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 353
 354     return nullptr;
 355 }
 356
 357 // ---- Internal Utilities ---------------------------------------------------
 358 bool OResultSet::isNull(const sal_Int32 nColumnIndex)
 359 {
 360     assert(nColumnIndex <= m_fieldCount);
 361     XSQLVAR* pVar = m_pSqlda->sqlvar;
 362
 363     if (pVar[nColumnIndex-1].sqltype & 1) // Indicates column may contain null
 364     {
 365         if (*pVar[nColumnIndex-1].sqlind == -1)
 366             return true;
 367     }
 368     return false;
 369 }
 370
 371 template <typename T>
 372 OUString OResultSet::makeNumericString(const sal_Int32 nColumnIndex)
 373 {
 374     //  minus because firebird stores scale as a negative number
 375     int nDecimalCount = -(m_pSqlda->sqlvar[nColumnIndex-1].sqlscale);
 376     if(nDecimalCount < 0)
 377     {
 378         // scale should be always positive
 379         assert(false);
 380         return OUString();
 381     }
 382
 383     OUStringBuffer sRetBuffer;
 384     T nAllDigits = *reinterpret_cast<T*>(m_pSqlda->sqlvar[nColumnIndex-1].sqldata);
 385     sal_Int64 nDecimalCountExp = pow10Integer(nDecimalCount);
 386
 387     if(nAllDigits < 0)
 388     {
 389         sRetBuffer.append('-');
 390         nAllDigits = -nAllDigits; // abs
 391     }
 392
 393     sRetBuffer.append(static_cast<sal_Int64>(nAllDigits / nDecimalCountExp) );
 394     if( nDecimalCount > 0)
 395     {
 396         sRetBuffer.append('.');
 397
 398         sal_Int64 nFractionalPart = nAllDigits % nDecimalCountExp;
 399
 400         int iCount = 0; // digit count
 401         sal_Int64 nFracTemp = nFractionalPart;
 402         while(nFracTemp>0)
 403         {
 404             nFracTemp /= 10;
 405             iCount++;
 406         }
 407
 408         int nMissingNulls = nDecimalCount - iCount;
 409
 410         // append nulls after dot and before nFractionalPart
 411         for(int i=0; i<nMissingNulls; i++)
 412         {
 413             sRetBuffer.append('0');
 414         }
 415
 416         // the rest
 417         sRetBuffer.append(nFractionalPart);
 418     }
 419
 420     return sRetBuffer.makeStringAndClear();
 421 }
 422
 423 template <typename T>
 424 T OResultSet::retrieveValue(const sal_Int32 nColumnIndex, const ISC_SHORT nType)
 425 {
 426     m_bWasNull = isNull(nColumnIndex);
 427     if (m_bWasNull)
 428         return T();
 429
 430     if ((m_pSqlda->sqlvar[nColumnIndex-1].sqltype & ~1) == nType)
 431         return *reinterpret_cast<T*>(m_pSqlda->sqlvar[nColumnIndex-1].sqldata);
 432     else
 433         return retrieveValue< ORowSetValue >(nColumnIndex, 0);
 434 }
 435
 436 template <>
 437 ORowSetValue OResultSet::retrieveValue(const sal_Int32 nColumnIndex, const ISC_SHORT /*nType*/)
 438 {
 439     // See http://wiki.openoffice.org/wiki/Documentation/DevGuide/Database/Using_the_getXXX_Methods
 440     // (bottom of page) for a chart of possible conversions, we should allow all
 441     // of these -- Blob/Clob will probably need some specialist handling especially
 442     // w.r.t. to generating Strings for them.
 443     //
 444     // Basically we just have to map to the correct direct request and
 445     // ORowSetValue does the rest for us here.
 446     int nSqlSubType = m_pSqlda->sqlvar[nColumnIndex-1].sqlsubtype;
 447
 448     // TODO Firebird 3.0 does not set subtype (i.e. set to 0) for computed numeric/decimal value.
 449     // It may change in the future.
 450     // Imply numeric data type when subtype is 0 and scale is negative
 451     if( nSqlSubType == 0 && m_pSqlda->sqlvar[nColumnIndex-1].sqlscale < 0 )
 452         nSqlSubType = 1;
 453
 454     switch (m_pSqlda->sqlvar[nColumnIndex-1].sqltype & ~1)
 455     {
 456         case SQL_TEXT:
 457         case SQL_VARYING:
 458             return getString(nColumnIndex);
 459         case SQL_SHORT:
 460             if(nSqlSubType == 1 || nSqlSubType == 2) //numeric or decimal
 461                 return getString(nColumnIndex);
 462             return getShort(nColumnIndex);
 463         case SQL_LONG:
 464             if(nSqlSubType == 1 || nSqlSubType == 2) //numeric or decimal
 465                 return getString(nColumnIndex);
 466             return getInt(nColumnIndex);
 467         case SQL_FLOAT:
 468             return getFloat(nColumnIndex);
 469         case SQL_DOUBLE:
 470             if(nSqlSubType == 1 || nSqlSubType == 2) //numeric or decimal
 471                 return getString(nColumnIndex);
 472             return getDouble(nColumnIndex);
 473         case SQL_D_FLOAT:
 474             return getFloat(nColumnIndex);
 475         case SQL_TIMESTAMP:
 476             return getTimestamp(nColumnIndex);
 477         case SQL_TYPE_TIME:
 478             return getTime(nColumnIndex);
 479         case SQL_TYPE_DATE:
 480             return getDate(nColumnIndex);
 481         case SQL_INT64:
 482             if(nSqlSubType == 1 || nSqlSubType == 2) //numeric or decimal
 483                 return getString(nColumnIndex);
 484             return getLong(nColumnIndex);
 485         case SQL_BOOLEAN:
 486             return ORowSetValue(bool(getBoolean(nColumnIndex)));
 487         case SQL_BLOB:
 488         case SQL_NULL:
 489         case SQL_QUAD:
 490         case SQL_ARRAY:
 491             // TODO: these are all invalid conversions, so maybe we should
 492             // throw an exception?
 493             return ORowSetValue();
 494         default:
 495             assert(false);
 496             return ORowSetValue();
 497     }
 498 }
 499
 500 template <>
 501 Date OResultSet::retrieveValue(const sal_Int32 nColumnIndex, const ISC_SHORT /*nType*/)
 502 {
 503     if ((m_pSqlda->sqlvar[nColumnIndex-1].sqltype & ~1) == SQL_TYPE_DATE)
 504     {
 505         ISC_DATE aISCDate = *reinterpret_cast<ISC_DATE*>(m_pSqlda->sqlvar[nColumnIndex-1].sqldata);
 506
 507         struct tm aCTime;
 508         isc_decode_sql_date(&aISCDate, &aCTime);
 509
 510         return Date(aCTime.tm_mday, aCTime.tm_mon + 1, aCTime.tm_year + 1900);
 511     }
 512     else
 513     {
 514         return retrieveValue< ORowSetValue >(nColumnIndex, 0);
 515     }
 516 }
 517
 518 template <>
 519 Time OResultSet::retrieveValue(const sal_Int32 nColumnIndex, const ISC_SHORT /*nType*/)
 520 {
 521     if ((m_pSqlda->sqlvar[nColumnIndex-1].sqltype & ~1) == SQL_TYPE_TIME)
 522     {
 523         ISC_TIME aISCTime = *reinterpret_cast<ISC_TIME*>(m_pSqlda->sqlvar[nColumnIndex-1].sqldata);
 524
 525         struct tm aCTime;
 526         isc_decode_sql_time(&aISCTime, &aCTime);
 527
 528         // First field is nanoseconds.
 529         // last field denotes UTC (true) or unknown (false)
 530         // Here we "know" that ISC_TIME is simply in units of seconds/ISC_TIME_SECONDS_PRECISION
 531         // with no other funkiness, so we can get the fractional seconds easily.
 532         return Time((aISCTime % ISC_TIME_SECONDS_PRECISION) * (1000000000 / ISC_TIME_SECONDS_PRECISION),
 533                     aCTime.tm_sec, aCTime.tm_min, aCTime.tm_hour, false);
 534     }
 535     else
 536     {
 537         return retrieveValue< ORowSetValue >(nColumnIndex, 0);
 538     }
 539 }
 540
 541 template <>
 542 DateTime OResultSet::retrieveValue(const sal_Int32 nColumnIndex, const ISC_SHORT /*nType*/)
 543 {
 544     if ((m_pSqlda->sqlvar[nColumnIndex-1].sqltype & ~1) == SQL_TIMESTAMP)
 545     {
 546         ISC_TIMESTAMP aISCTimestamp = *reinterpret_cast<ISC_TIMESTAMP*>(m_pSqlda->sqlvar[nColumnIndex-1].sqldata);
 547
 548         struct tm aCTime;
 549         isc_decode_timestamp(&aISCTimestamp, &aCTime);
 550
 551         // Ditto here, see comment in previous function about ISC_TIME and ISC_TIME_SECONDS_PRECISION.
 552         return DateTime((aISCTimestamp.timestamp_time % ISC_TIME_SECONDS_PRECISION) * (1000000000 / ISC_TIME_SECONDS_PRECISION), //nanoseconds
 553                         aCTime.tm_sec,
 554                         aCTime.tm_min,
 555                         aCTime.tm_hour,
 556                         aCTime.tm_mday,
 557                         aCTime.tm_mon + 1, // tm is from 0 to 11
 558                         aCTime.tm_year + 1900, //tm_year is the years since 1900
 559                         false); // denotes UTC (true), or unknown (false)
 560     }
 561     else
 562     {
 563         return retrieveValue< ORowSetValue >(nColumnIndex, 0);
 564     }
 565 }
 566
 567 template <>
 568 OUString OResultSet::retrieveValue(const sal_Int32 nColumnIndex, const ISC_SHORT /*nType*/)
 569 {
 570     // &~1 to remove the "can contain NULL" indicator
 571     int aSqlType = m_pSqlda->sqlvar[nColumnIndex-1].sqltype & ~1;
 572     int aSqlSubType = m_pSqlda->sqlvar[nColumnIndex-1].sqlsubtype;
 573     if (aSqlType == SQL_TEXT )
 574     {
 575         return OUString(m_pSqlda->sqlvar[nColumnIndex-1].sqldata,
 576                         m_pSqlda->sqlvar[nColumnIndex-1].sqllen,
 577                         RTL_TEXTENCODING_UTF8);
 578     }
 579     else if (aSqlType == SQL_VARYING)
 580     {
 581         // First 2 bytes are a short containing the length of the string
 582         // Under unclear conditions, it may be wrong and greater than sqllen.
 583         sal_uInt16 aLength = *reinterpret_cast<sal_uInt16*>(m_pSqlda->sqlvar[nColumnIndex-1].sqldata);
 584         // Use greater signed type sal_Int32 to get the minimum of two 16-bit values
 585         return OUString(m_pSqlda->sqlvar[nColumnIndex-1].sqldata + 2,
 586                         std::min<sal_Int32>(aLength, m_pSqlda->sqlvar[nColumnIndex-1].sqllen),
 587                         RTL_TEXTENCODING_UTF8);
 588     }
 589     else if ((aSqlType == SQL_SHORT || aSqlType == SQL_LONG ||
 590               aSqlType == SQL_DOUBLE || aSqlType == SQL_INT64)
 591           && (aSqlSubType == 1 ||
 592               aSqlSubType == 2 ||
 593               (aSqlSubType == 0 && m_pSqlda->sqlvar[nColumnIndex-1].sqlscale < 0) ) )
 594     {
 595         // decimal and numeric types
 596         switch(aSqlType)
 597         {
 598             case SQL_SHORT:
 599                 return makeNumericString<sal_Int16>(nColumnIndex);
 600             case SQL_LONG:
 601                 return makeNumericString<sal_Int32>(nColumnIndex);
 602             case SQL_DOUBLE:
 603                 // TODO FIXME 64 bits?
 604             case SQL_INT64:
 605                 return makeNumericString<sal_Int64>(nColumnIndex);
 606             default:
 607                 assert(false);
 608                 return OUString(); // never reached
 609         }
 610     }
 611     else if(aSqlType == SQL_BLOB && aSqlSubType == static_cast<short>(BlobSubtype::Clob) )
 612     {
 613         uno::Reference<XClob> xClob = getClob(nColumnIndex);
 614         return xClob->getSubString( 0, xClob->length() );
 615     }
 616     else
 617     {
 618         return retrieveValue< ORowSetValue >(nColumnIndex, 0);
 619     }
 620 }
 621
 622 template <>
 623 ISC_QUAD* OResultSet::retrieveValue(const sal_Int32 nColumnIndex, const ISC_SHORT nType)
 624 {
 625     // TODO: this is probably wrong
 626     if ((m_pSqlda->sqlvar[nColumnIndex-1].sqltype & ~1) != nType)
 627         throw SQLException(); // TODO: better exception (can't convert Blob)
 628
 629     return reinterpret_cast<ISC_QUAD*>(m_pSqlda->sqlvar[nColumnIndex-1].sqldata);
 630 }
 631
 632 template <typename T>
 633 T OResultSet::safelyRetrieveValue(const sal_Int32 nColumnIndex, const ISC_SHORT nType)
 634 {
 635     MutexGuard aGuard(m_rMutex);
 636     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 637
 638     checkColumnIndex(nColumnIndex);
 639     checkRowIndex();
 640
 641     m_bWasNull = isNull(nColumnIndex);
 642     if (m_bWasNull)
 643         return T();
 644
 645     return retrieveValue< T >(nColumnIndex, nType);
 646 }
 647
 648 // ---- XRow -----------------------------------------------------------------
 649 sal_Bool SAL_CALL OResultSet::wasNull()
 650 {
 651     MutexGuard aGuard(m_rMutex);
 652     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 653
 654     return m_bWasNull;
 655 }
 656
 657 // ---- XRow: Simple Numerical types ------------------------------------------
 658 sal_Bool SAL_CALL OResultSet::getBoolean(sal_Int32 nColumnIndex)
 659 {
 660     return safelyRetrieveValue< bool >(nColumnIndex, SQL_BOOLEAN);
 661 }
 662
 663 sal_Int8 SAL_CALL OResultSet::getByte(sal_Int32 nColumnIndex)
 664 {
 665     // Not a native firebird type hence we always have to convert.
 666     return safelyRetrieveValue< ORowSetValue >(nColumnIndex);
 667 }
 668
 669 Sequence< sal_Int8 > SAL_CALL OResultSet::getBytes(sal_Int32 nColumnIndex)
 670 {
 671     // &~1 to remove the "can contain NULL" indicator
 672     int aSqlType = m_pSqlda->sqlvar[nColumnIndex-1].sqltype & ~1;
 673     if ( aSqlType == SQL_BLOB )
 674     {
 675         Reference< XBlob> xBlob = getBlob(nColumnIndex);
 676         if (xBlob.is())
 677         {
 678             const sal_Int64 aBlobLength = xBlob->length();
 679             if (aBlobLength > SAL_MAX_INT32)
 680             {
 681                 SAL_WARN("connectivity.firebird", "getBytes can't return " << aBlobLength << " bytes but only max " << SAL_MAX_INT32);
 682                 return xBlob->getBytes(1, SAL_MAX_INT32);
 683             }
 684             return xBlob->getBytes(1, static_cast<sal_Int32>(aBlobLength));
 685         }
 686         else
 687             return Sequence< sal_Int8 >();
 688     }
 689     // TODO implement SQL_VARYING and SQL_TEXT
 690     // as it's the counterpart as OPreparedStatement::setBytes
 691     else
 692     {
 693         return Sequence< sal_Int8 >(); // TODO: implement
 694     }
 695 }
 696
 697 sal_Int16 SAL_CALL OResultSet::getShort(sal_Int32 columnIndex)
 698 {
 699     return safelyRetrieveValue< sal_Int16 >(columnIndex, SQL_SHORT);
 700 }
 701
 702 sal_Int32 SAL_CALL OResultSet::getInt(sal_Int32 columnIndex)
 703 {
 704     return safelyRetrieveValue< sal_Int32 >(columnIndex, SQL_LONG);
 705 }
 706
 707 sal_Int64 SAL_CALL OResultSet::getLong(sal_Int32 columnIndex)
 708 {
 709     return safelyRetrieveValue< sal_Int64 >(columnIndex, SQL_INT64);
 710 }
 711
 712 float SAL_CALL OResultSet::getFloat(sal_Int32 columnIndex)
 713 {
 714     return safelyRetrieveValue< float >(columnIndex, SQL_FLOAT);
 715 }
 716
 717 double SAL_CALL OResultSet::getDouble(sal_Int32 columnIndex)
 718 {
 719     return safelyRetrieveValue< double >(columnIndex, SQL_DOUBLE);
 720 }
 721
 722 // ---- XRow: More complex types ----------------------------------------------
 723 OUString SAL_CALL OResultSet::getString(sal_Int32 nIndex)
 724 {
 725     return safelyRetrieveValue< OUString >(nIndex);
 726 }
 727
 728 Date SAL_CALL OResultSet::getDate(sal_Int32 nIndex)
 729 {
 730     return safelyRetrieveValue< Date >(nIndex, SQL_TYPE_DATE);
 731 }
 732
 733 Time SAL_CALL OResultSet::getTime(sal_Int32 nIndex)
 734 {
 735     return safelyRetrieveValue< css::util::Time >(nIndex, SQL_TYPE_TIME);
 736 }
 737
 738 DateTime SAL_CALL OResultSet::getTimestamp(sal_Int32 nIndex)
 739 {
 740     return safelyRetrieveValue< DateTime >(nIndex, SQL_TIMESTAMP);
 741 }
 742
 743
 744 uno::Reference< XResultSetMetaData > SAL_CALL OResultSet::getMetaData(  )
 745 {
 746     MutexGuard aGuard(m_rMutex);
 747     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 748
 749     if(!m_xMetaData.is())
 750         m_xMetaData = new OResultSetMetaData(m_pConnection
 751                                            , m_pSqlda);
 752     return m_xMetaData;
 753 }
 754
 755 uno::Reference< XArray > SAL_CALL OResultSet::getArray( sal_Int32 )
 756 {
 757     MutexGuard aGuard(m_rMutex);
 758     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 759
 760     return nullptr;
 761 }
 762
 763
 764 uno::Reference< XClob > SAL_CALL OResultSet::getClob( sal_Int32 columnIndex )
 765 {
 766     MutexGuard aGuard(m_rMutex);
 767     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 768
 769     int aSqlSubType = m_pSqlda->sqlvar[columnIndex-1].sqlsubtype;
 770
 771     SAL_WARN_IF(aSqlSubType != 1,
 772         "connectivity.firebird", "wrong subtype, not a textual blob");
 773
 774     ISC_QUAD* pBlobID = safelyRetrieveValue< ISC_QUAD* >(columnIndex, SQL_BLOB);
 775     if (!pBlobID)
 776         return nullptr;
 777     return m_pConnection->createClob(pBlobID);
 778 }
 779
 780 uno::Reference< XBlob > SAL_CALL OResultSet::getBlob(sal_Int32 columnIndex)
 781 {
 782     MutexGuard aGuard(m_rMutex);
 783     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 784
 785     // TODO: CLOB etc. should be valid here too, but we probably want some more
 786     // cleverness around this.
 787     ISC_QUAD* pBlobID = safelyRetrieveValue< ISC_QUAD* >(columnIndex, SQL_BLOB);
 788     if (!pBlobID)
 789         return nullptr;
 790     return m_pConnection->createBlob(pBlobID);
 791 }
 792
 793
 794 uno::Reference< XRef > SAL_CALL OResultSet::getRef( sal_Int32 )
 795 {
 796     MutexGuard aGuard(m_rMutex);
 797     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 798
 799     return nullptr;
 800 }
 801
 802
 803 Any SAL_CALL OResultSet::getObject( sal_Int32, const uno::Reference< css::container::XNameAccess >& )
 804 {
 805     MutexGuard aGuard(m_rMutex);
 806     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 807
 808     return Any();
 809 }
 810
 811
 812 void SAL_CALL OResultSet::close()
 813 {
 814     SAL_INFO("connectivity.firebird", "close().");
 815
 816     {
 817         MutexGuard aGuard(m_rMutex);
 818         checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 819     }
 820     dispose();
 821 }
 822
 823
 824 uno::Reference< XInterface > SAL_CALL OResultSet::getStatement()
 825 {
 826     MutexGuard aGuard(m_rMutex);
 827     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 828
 829     return m_xStatement;
 830 }
 831 //----- XResultSet: unsupported change detection methods ---------------------
 832 sal_Bool SAL_CALL OResultSet::rowDeleted()
 833 {
 834     ::dbtools::throwFunctionNotSupportedSQLException("rowDeleted not supported in firebird",
 835                                                   *this);
 836     return false;
 837 }
 838 sal_Bool SAL_CALL OResultSet::rowInserted()
 839 {
 840     ::dbtools::throwFunctionNotSupportedSQLException("rowInserted not supported in firebird",
 841                                                   *this);
 842     return false;
 843 }
 844
 845 sal_Bool SAL_CALL OResultSet::rowUpdated()
 846 {
 847     ::dbtools::throwFunctionNotSupportedSQLException("rowUpdated not supported in firebird",
 848                                                   *this);
 849     return false;
 850 }
 851
 852 void SAL_CALL OResultSet::refreshRow()
 853 {
 854     ::dbtools::throwFunctionNotSupportedSQLException("refreshRow not supported in firebird",
 855                                                   *this);
 856 }
 857
 858
 859 void SAL_CALL OResultSet::cancel(  )
 860 {
 861     MutexGuard aGuard(m_rMutex);
 862     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 863
 864 }
 865
 866 //----- OIdPropertyArrayUsageHelper ------------------------------------------
 867 IPropertyArrayHelper* OResultSet::createArrayHelper() const
 868 {
 869     Sequence< Property > aProperties;
 870     describeProperties(aProperties);
 871     return new ::cppu::OPropertyArrayHelper(aProperties);
 872 }
 873
 874 IPropertyArrayHelper & OResultSet::getInfoHelper()
 875 {
 876     return *getArrayHelper();
 877 }
 878
 879 void SAL_CALL OResultSet::acquire() noexcept
 880 {
 881     OResultSet_BASE::acquire();
 882 }
 883
 884 void SAL_CALL OResultSet::release() noexcept
 885 {
 886     OResultSet_BASE::release();
 887 }
 888
 889 uno::Reference< css::beans::XPropertySetInfo > SAL_CALL OResultSet::getPropertySetInfo(  )
 890 {
 891     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 892 }
 893
 894 // ---- XServiceInfo -----------------------------------------------------------
 895 OUString SAL_CALL OResultSet::getImplementationName()
 896 {
 897     return "com.sun.star.sdbcx.firebird.ResultSet";
 898 }
 899
 900 Sequence< OUString > SAL_CALL OResultSet::getSupportedServiceNames()
 901 {
 902     return {"com.sun.star.sdbc.ResultSet","com.sun.star.sdbcx.ResultSet"};
 903 }
 904
 905 sal_Bool SAL_CALL OResultSet::supportsService(const OUString& _rServiceName)
 906 {
 907     return cppu::supportsService(this, _rServiceName);
 908 }
 909
 910 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */