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