connectivity/source/drivers/mysqlc/mysqlc_prepared_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 "mysqlc_propertyids.hxx"
  21 #include "mysqlc_general.hxx"
  22 #include "mysqlc_prepared_resultset.hxx"
  23 #include "mysqlc_resultsetmetadata.hxx"
  24
  25 #include <com/sun/star/beans/PropertyAttribute.hpp>
  26 #include <com/sun/star/lang/DisposedException.hpp>
  27 #include <com/sun/star/sdbc/DataType.hpp>
  28 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
  29 #include <com/sun/star/sdbc/ResultSetType.hpp>
  30 #include <com/sun/star/sdbc/FetchDirection.hpp>
  31 #include <com/sun/star/sdbcx/CompareBookmark.hpp>
  32 #include <cppuhelper/supportsservice.hxx>
  33 #include <cppuhelper/typeprovider.hxx>
  34
  35 using namespace rtl;
  36 #include <comphelper/string.hxx>
  37
  38 #include <cstdlib>
  39
  40 using namespace connectivity::mysqlc;
  41 using namespace connectivity;
  42 using namespace cppu;
  43 using namespace com::sun::star;
  44 using namespace com::sun::star::lang;
  45 using namespace com::sun::star::beans;
  46 using namespace com::sun::star::sdbc;
  47 using namespace com::sun::star::sdbcx;
  48 using namespace com::sun::star::container;
  49 using namespace com::sun::star::io;
  50 using namespace com::sun::star::util;
  51 using namespace ::comphelper;
  52 using ::osl::MutexGuard;
  53
  54 #include <stdio.h>
  55 #include <typeinfo>
  56 #include <typeindex>
  57
  58 namespace
  59 {
  60 const std::type_index getTypeFromMysqlType(enum_field_types type)
  61 {
  62     switch (type)
  63     {
  64         case MYSQL_TYPE_TINY:
  65             return std::type_index(typeid(sal_Int8));
  66         case MYSQL_TYPE_SHORT:
  67             return std::type_index(typeid(sal_Int16));
  68         case MYSQL_TYPE_LONG:
  69             return std::type_index(typeid(sal_Int32));
  70         case MYSQL_TYPE_LONGLONG:
  71             return std::type_index(typeid(sal_Int64));
  72         case MYSQL_TYPE_FLOAT:
  73             return std::type_index(typeid(float));
  74         case MYSQL_TYPE_DOUBLE:
  75             return std::type_index(typeid(double));
  76         case MYSQL_TYPE_TIMESTAMP:
  77         case MYSQL_TYPE_DATETIME:
  78             return std::type_index(typeid(DateTime));
  79         case MYSQL_TYPE_DATE:
  80             return std::type_index(typeid(Date));
  81         case MYSQL_TYPE_TIME:
  82             return std::type_index(typeid(Time));
  83         case MYSQL_TYPE_STRING:
  84         case MYSQL_TYPE_VAR_STRING:
  85         case MYSQL_TYPE_DECIMAL:
  86         case MYSQL_TYPE_NEWDECIMAL:
  87             return std::type_index(typeid(OUString));
  88         case MYSQL_TYPE_BLOB:
  89         case MYSQL_TYPE_YEAR:
  90         case MYSQL_TYPE_BIT:
  91         case MYSQL_TYPE_INT24:
  92         case MYSQL_TYPE_SET:
  93         case MYSQL_TYPE_ENUM:
  94         case MYSQL_TYPE_GEOMETRY:
  95         case MYSQL_TYPE_NULL:
  96         default:
  97             return std::type_index(typeid(nullptr));
  98     }
  99 }
 100 }
 101
 102 OUString SAL_CALL OPreparedResultSet::getImplementationName()
 103 {
 104     return OUString("com.sun.star.sdbcx.mysqlc.ResultSet");
 105 }
 106
 107 uno::Sequence<OUString> SAL_CALL OPreparedResultSet::getSupportedServiceNames()
 108 {
 109     uno::Sequence<OUString> aSupported(2);
 110     aSupported[0] = "com.sun.star.sdbc.ResultSet";
 111     aSupported[1] = "com.sun.star.sdbcx.ResultSet";
 112     return aSupported;
 113 }
 114
 115 sal_Bool SAL_CALL OPreparedResultSet::supportsService(const OUString& _rServiceName)
 116 {
 117     return cppu::supportsService(this, _rServiceName);
 118 }
 119 OPreparedResultSet::OPreparedResultSet(OConnection& rConn, OPreparedStatement* pPrepared,
 120                                        MYSQL_STMT* pStmt)
 121     : OPreparedResultSet_BASE(m_aMutex)
 122     , OPropertySetHelper(OPreparedResultSet_BASE::rBHelper)
 123     , m_rConnection(rConn)
 124     , m_aStatement(static_cast<OWeakObject*>(pPrepared))
 125     , m_pStmt(pStmt)
 126     , m_encoding(rConn.getConnectionEncoding())
 127 {
 128     m_nFieldCount = mysql_stmt_field_count(pStmt);
 129     m_pResult = mysql_stmt_result_metadata(m_pStmt);
 130     m_aFields = mysql_fetch_fields(m_pResult);
 131 }
 132
 133 void OPreparedResultSet::disposing()
 134 {
 135     OPropertySetHelper::disposing();
 136
 137     MutexGuard aGuard(m_aMutex);
 138
 139     m_aStatement = nullptr;
 140     m_xMetaData = nullptr;
 141 }
 142
 143 Any SAL_CALL OPreparedResultSet::queryInterface(const Type& rType)
 144 {
 145     Any aRet = OPropertySetHelper::queryInterface(rType);
 146     if (!aRet.hasValue())
 147     {
 148         aRet = OPreparedResultSet_BASE::queryInterface(rType);
 149     }
 150     return aRet;
 151 }
 152
 153 uno::Sequence<Type> SAL_CALL OPreparedResultSet::getTypes()
 154 {
 155     OTypeCollection aTypes(cppu::UnoType<XMultiPropertySet>::get(),
 156                            cppu::UnoType<XFastPropertySet>::get(),
 157                            cppu::UnoType<XPropertySet>::get());
 158
 159     return concatSequences(aTypes.getTypes(), OPreparedResultSet_BASE::getTypes());
 160 }
 161
 162 sal_Int32 SAL_CALL OPreparedResultSet::findColumn(const OUString& columnName)
 163 {
 164     MutexGuard aGuard(m_aMutex);
 165     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 166
 167     MYSQL_FIELD* pFields = mysql_fetch_fields(m_pResult);
 168     for (sal_Int32 i = 0; i < m_nFieldCount; ++i)
 169     {
 170         if (columnName.equalsIgnoreAsciiCaseAscii(pFields[i].name))
 171             return i + 1; // sdbc indexes from 1
 172     }
 173
 174     throw SQLException("The column name '" + columnName + "' is not valid.", *this, "42S22", 0,
 175                        Any());
 176 }
 177
 178 template <typename T> T OPreparedResultSet::safelyRetrieveValue(sal_Int32 nColumnIndex)
 179 {
 180     MutexGuard aGuard(m_aMutex);
 181     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 182     checkColumnIndex(nColumnIndex);
 183     if (*m_aData[nColumnIndex - 1].is_null)
 184     {
 185         m_bWasNull = true;
 186         return T();
 187     }
 188     m_bWasNull = false;
 189
 190     return retrieveValue<T>(nColumnIndex);
 191 }
 192
 193 template <typename T> T OPreparedResultSet::retrieveValue(sal_Int32 nColumnIndex)
 194 {
 195     if (getTypeFromMysqlType(m_aFields[nColumnIndex - 1].type) == std::type_index(typeid(T)))
 196         return *static_cast<T*>(m_aData[nColumnIndex - 1].buffer);
 197     else
 198         return getRowSetValue(nColumnIndex);
 199 }
 200
 201 template <> uno::Sequence<sal_Int8> OPreparedResultSet::retrieveValue(sal_Int32 column)
 202 {
 203     // TODO make conversion possible
 204     return uno::Sequence<sal_Int8>(static_cast<sal_Int8 const*>(m_aData[column - 1].buffer),
 205                                    *m_aData[column - 1].length);
 206 }
 207
 208 template <> Date OPreparedResultSet::retrieveValue(sal_Int32 column)
 209 {
 210     if (getTypeFromMysqlType(m_aFields[column - 1].type) != std::type_index(typeid(Date)))
 211         return getRowSetValue(column);
 212     const MYSQL_TIME* pTime = static_cast<MYSQL_TIME*>(m_aData[column - 1].buffer);
 213
 214     Date d;
 215     d.Year = pTime->year;
 216     d.Month = pTime->month;
 217     d.Day = pTime->day;
 218     return d;
 219 }
 220
 221 template <> Time OPreparedResultSet::retrieveValue(sal_Int32 column)
 222 {
 223     if (getTypeFromMysqlType(m_aFields[column - 1].type) != std::type_index(typeid(Time)))
 224         return getRowSetValue(column);
 225     const MYSQL_TIME* pTime = static_cast<MYSQL_TIME*>(m_aData[column - 1].buffer);
 226
 227     Time t;
 228     t.Hours = pTime->hour;
 229     t.Minutes = pTime->minute;
 230     t.Seconds = pTime->second;
 231     return t;
 232 }
 233
 234 template <> DateTime OPreparedResultSet::retrieveValue(sal_Int32 column)
 235 {
 236     if (getTypeFromMysqlType(m_aFields[column - 1].type) != std::type_index(typeid(DateTime)))
 237         return getRowSetValue(column);
 238     const MYSQL_TIME* pTime = static_cast<MYSQL_TIME*>(m_aData[column - 1].buffer);
 239
 240     DateTime t;
 241     t.Year = pTime->year;
 242     t.Month = pTime->month;
 243     t.Day = pTime->day;
 244     t.Hours = pTime->hour;
 245     t.Minutes = pTime->minute;
 246     t.Seconds = pTime->second;
 247     return t;
 248 }
 249
 250 template <> OUString OPreparedResultSet::retrieveValue(sal_Int32 column)
 251 {
 252     if (getTypeFromMysqlType(m_aFields[column - 1].type) != std::type_index(typeid(OUString)))
 253         return getRowSetValue(column);
 254     const char* sStr = static_cast<const char*>(m_aData[column - 1].buffer);
 255
 256     OUString sReturn = OUString(sStr, *m_aData[column - 1].length, m_encoding);
 257     return sReturn;
 258 }
 259
 260 ORowSetValue OPreparedResultSet::getRowSetValue(sal_Int32 nColumnIndex)
 261 {
 262     switch (m_aFields[nColumnIndex - 1].type)
 263     {
 264         case MYSQL_TYPE_TINY:
 265             return getByte(nColumnIndex);
 266         case MYSQL_TYPE_SHORT:
 267             return getShort(nColumnIndex);
 268         case MYSQL_TYPE_LONG:
 269             return getInt(nColumnIndex);
 270         case MYSQL_TYPE_LONGLONG:
 271             return getLong(nColumnIndex);
 272         case MYSQL_TYPE_FLOAT:
 273         case MYSQL_TYPE_DOUBLE:
 274             return getDouble(nColumnIndex);
 275         case MYSQL_TYPE_TIMESTAMP:
 276         case MYSQL_TYPE_DATETIME:
 277             return getTimestamp(nColumnIndex);
 278         case MYSQL_TYPE_DATE:
 279             return getDate(nColumnIndex);
 280         case MYSQL_TYPE_TIME:
 281             return getTime(nColumnIndex);
 282         case MYSQL_TYPE_STRING:
 283         case MYSQL_TYPE_VAR_STRING:
 284         case MYSQL_TYPE_DECIMAL:
 285         case MYSQL_TYPE_NEWDECIMAL:
 286             return getString(nColumnIndex);
 287         default:
 288             mysqlc_sdbc_driver::throwFeatureNotImplementedException(
 289                 "OPreparedResultSet::getRowSetValue", *this);
 290             return ORowSetValue();
 291     }
 292 }
 293
 294 uno::Reference<XInputStream> SAL_CALL OPreparedResultSet::getBinaryStream(sal_Int32 /*column*/)
 295 {
 296     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::getBinaryStream",
 297                                                             *this);
 298     return nullptr;
 299 }
 300
 301 uno::Reference<XInputStream> SAL_CALL OPreparedResultSet::getCharacterStream(sal_Int32 /*column*/)
 302 {
 303     mysqlc_sdbc_driver::throwFeatureNotImplementedException(
 304         "OPreparedResultSet::getCharacterStream", *this);
 305     return nullptr;
 306 }
 307
 308 sal_Bool SAL_CALL OPreparedResultSet::getBoolean(sal_Int32 column)
 309 {
 310     return safelyRetrieveValue<bool>(column);
 311 }
 312
 313 sal_Int8 SAL_CALL OPreparedResultSet::getByte(sal_Int32 column)
 314 {
 315     return safelyRetrieveValue<sal_Int8>(column);
 316 }
 317
 318 uno::Sequence<sal_Int8> SAL_CALL OPreparedResultSet::getBytes(sal_Int32 column)
 319 {
 320     return safelyRetrieveValue<uno::Sequence<sal_Int8>>(column);
 321 }
 322
 323 Date SAL_CALL OPreparedResultSet::getDate(sal_Int32 column)
 324 {
 325     return safelyRetrieveValue<Date>(column);
 326 }
 327
 328 double SAL_CALL OPreparedResultSet::getDouble(sal_Int32 column)
 329 {
 330     return safelyRetrieveValue<double>(column);
 331 }
 332
 333 float SAL_CALL OPreparedResultSet::getFloat(sal_Int32 column)
 334 {
 335     return safelyRetrieveValue<float>(column);
 336 }
 337
 338 sal_Int32 SAL_CALL OPreparedResultSet::getInt(sal_Int32 column)
 339 {
 340     return safelyRetrieveValue<sal_Int32>(column);
 341 }
 342
 343 sal_Int32 SAL_CALL OPreparedResultSet::getRow()
 344 {
 345     MutexGuard aGuard(m_aMutex);
 346     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 347
 348     return static_cast<sal_Int32>(mysql_field_tell(m_pResult));
 349 }
 350
 351 sal_Int64 SAL_CALL OPreparedResultSet::getLong(sal_Int32 column)
 352 {
 353     return safelyRetrieveValue<sal_Int64>(column);
 354 }
 355
 356 uno::Reference<XResultSetMetaData> SAL_CALL OPreparedResultSet::getMetaData()
 357 {
 358     MutexGuard aGuard(m_aMutex);
 359     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 360     if (!m_xMetaData.is())
 361     {
 362         m_xMetaData = new OResultSetMetaData(m_rConnection, m_pResult);
 363     }
 364     return m_xMetaData;
 365 }
 366
 367 uno::Reference<XArray> SAL_CALL OPreparedResultSet::getArray(sal_Int32 column)
 368 {
 369     MutexGuard aGuard(m_aMutex);
 370     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 371     checkColumnIndex(column);
 372
 373     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::getArray", *this);
 374     return nullptr;
 375 }
 376
 377 uno::Reference<XClob> SAL_CALL OPreparedResultSet::getClob(sal_Int32 column)
 378 {
 379     MutexGuard aGuard(m_aMutex);
 380     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 381     checkColumnIndex(column);
 382
 383     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::getClob", *this);
 384     return nullptr;
 385 }
 386
 387 uno::Reference<XBlob> SAL_CALL OPreparedResultSet::getBlob(sal_Int32 column)
 388 {
 389     MutexGuard aGuard(m_aMutex);
 390     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 391     checkColumnIndex(column);
 392
 393     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::getBlob", *this);
 394     return nullptr;
 395 }
 396
 397 uno::Reference<XRef> SAL_CALL OPreparedResultSet::getRef(sal_Int32 column)
 398 {
 399     MutexGuard aGuard(m_aMutex);
 400     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 401     checkColumnIndex(column);
 402
 403     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::getRef", *this);
 404     return nullptr;
 405 }
 406
 407 Any SAL_CALL OPreparedResultSet::getObject(sal_Int32 column,
 408                                            const uno::Reference<XNameAccess>& /* typeMap */)
 409 {
 410     MutexGuard aGuard(m_aMutex);
 411     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 412     checkColumnIndex(column);
 413
 414     Any aRet = Any();
 415
 416     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::getObject", *this);
 417     return aRet;
 418 }
 419
 420 sal_Int16 SAL_CALL OPreparedResultSet::getShort(sal_Int32 column)
 421 {
 422     return safelyRetrieveValue<sal_Int16>(column);
 423 }
 424
 425 OUString SAL_CALL OPreparedResultSet::getString(sal_Int32 column)
 426 {
 427     return safelyRetrieveValue<OUString>(column);
 428 }
 429
 430 Time SAL_CALL OPreparedResultSet::getTime(sal_Int32 column)
 431 {
 432     return safelyRetrieveValue<Time>(column);
 433 }
 434
 435 DateTime SAL_CALL OPreparedResultSet::getTimestamp(sal_Int32 column)
 436 {
 437     return safelyRetrieveValue<DateTime>(column);
 438 }
 439
 440 sal_Bool SAL_CALL OPreparedResultSet::isBeforeFirst()
 441 {
 442     MutexGuard aGuard(m_aMutex);
 443     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 444
 445     return m_nCurrentField == 0;
 446 }
 447
 448 sal_Bool SAL_CALL OPreparedResultSet::isAfterLast()
 449 {
 450     MutexGuard aGuard(m_aMutex);
 451     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 452
 453     return m_nCurrentField >= m_nFieldCount;
 454 }
 455
 456 sal_Bool SAL_CALL OPreparedResultSet::isFirst()
 457 {
 458     MutexGuard aGuard(m_aMutex);
 459     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 460
 461     return m_nCurrentField == 1 && !isAfterLast();
 462 }
 463
 464 sal_Bool SAL_CALL OPreparedResultSet::isLast()
 465 {
 466     MutexGuard aGuard(m_aMutex);
 467     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 468
 469     return mysql_field_tell(m_pResult) == static_cast<unsigned>(m_nFieldCount);
 470 }
 471
 472 void SAL_CALL OPreparedResultSet::beforeFirst()
 473 {
 474     MutexGuard aGuard(m_aMutex);
 475     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 476
 477     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::beforeFirst",
 478                                                             *this);
 479 }
 480
 481 void SAL_CALL OPreparedResultSet::afterLast()
 482 {
 483     MutexGuard aGuard(m_aMutex);
 484     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 485
 486     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::afterLast", *this);
 487 }
 488
 489 void SAL_CALL OPreparedResultSet::close()
 490 {
 491     MutexGuard aGuard(m_aMutex);
 492     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 493
 494     m_aData.reset();
 495     m_aMetaData.reset();
 496
 497     if (m_pResult)
 498         mysql_free_result(m_pResult);
 499     mysql_stmt_free_result(m_pStmt);
 500     dispose();
 501 }
 502
 503 sal_Bool SAL_CALL OPreparedResultSet::first()
 504 {
 505     MutexGuard aGuard(m_aMutex);
 506     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 507
 508     mysql_stmt_data_seek(m_pStmt, 0);
 509     next();
 510
 511     return true;
 512 }
 513
 514 sal_Bool SAL_CALL OPreparedResultSet::last()
 515 {
 516     MutexGuard aGuard(m_aMutex);
 517     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 518
 519     mysql_stmt_data_seek(m_pStmt, m_nFieldCount - 1);
 520     next();
 521
 522     return true;
 523 }
 524
 525 sal_Bool SAL_CALL OPreparedResultSet::absolute(sal_Int32 row)
 526 {
 527     MutexGuard aGuard(m_aMutex);
 528     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 529
 530     sal_Int32 nFields = m_nFieldCount;
 531     sal_Int32 nToGo = row < 0 ? nFields - row : row - 1;
 532
 533     if (nToGo >= nFields)
 534         nToGo = nFields - 1;
 535     if (nToGo < 0)
 536         nToGo = 0;
 537
 538     mysql_stmt_data_seek(m_pStmt, nToGo);
 539     next();
 540
 541     return true;
 542 }
 543
 544 sal_Bool SAL_CALL OPreparedResultSet::relative(sal_Int32 row)
 545 {
 546     MutexGuard aGuard(m_aMutex);
 547     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 548
 549     sal_Int32 nFields = m_nFieldCount;
 550     if (row == 0)
 551         return true;
 552
 553     sal_Int32 nToGo = m_nCurrentField + row;
 554     if (nToGo >= nFields)
 555         nToGo = nFields - 1;
 556     if (nToGo < 0)
 557         nToGo = 0;
 558
 559     mysql_stmt_data_seek(m_pStmt, nToGo);
 560     next();
 561     m_nCurrentField += row;
 562
 563     return true;
 564 }
 565
 566 sal_Bool SAL_CALL OPreparedResultSet::previous()
 567 {
 568     MutexGuard aGuard(m_aMutex);
 569     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 570
 571     if (m_nCurrentField <= 1)
 572         return false;
 573
 574     mysql_stmt_data_seek(m_pStmt, m_nCurrentField - 2);
 575     next();
 576     --m_nFieldCount;
 577     return true;
 578 }
 579
 580 uno::Reference<uno::XInterface> SAL_CALL OPreparedResultSet::getStatement()
 581 {
 582     MutexGuard aGuard(m_aMutex);
 583     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 584
 585     return m_aStatement.get();
 586 }
 587
 588 sal_Bool SAL_CALL OPreparedResultSet::rowDeleted()
 589 {
 590     MutexGuard aGuard(m_aMutex);
 591     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 592
 593     return false;
 594 }
 595
 596 sal_Bool SAL_CALL OPreparedResultSet::rowInserted()
 597 {
 598     MutexGuard aGuard(m_aMutex);
 599     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 600
 601     return false;
 602 }
 603
 604 sal_Bool SAL_CALL OPreparedResultSet::rowUpdated()
 605 {
 606     MutexGuard aGuard(m_aMutex);
 607     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 608
 609     return false;
 610 }
 611
 612 sal_Bool SAL_CALL OPreparedResultSet::next()
 613 {
 614     MutexGuard aGuard(m_aMutex);
 615     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 616
 617     bool bFirstRun = false;
 618     // allocate array if it does not exist
 619     if (m_aData == nullptr)
 620     {
 621         bFirstRun = true;
 622         m_aData.reset(new MYSQL_BIND[m_nFieldCount]);
 623         memset(m_aData.get(), 0, m_nFieldCount * sizeof(MYSQL_BIND));
 624         m_aMetaData.reset(new BindMetaData[m_nFieldCount]);
 625     }
 626     for (sal_Int32 i = 0; i < m_nFieldCount; ++i)
 627     {
 628         m_aMetaData[i].is_null = 0;
 629         m_aMetaData[i].length = 0l;
 630         m_aMetaData[i].error = 0;
 631
 632         m_aData[i].is_null = &m_aMetaData[i].is_null;
 633         m_aData[i].buffer_length = m_aFields[i].type == MYSQL_TYPE_BLOB ? 0 : m_aFields[i].length;
 634         m_aData[i].length = &m_aMetaData[i].length;
 635         m_aData[i].error = &m_aMetaData[i].error;
 636         m_aData[i].buffer = nullptr;
 637         m_aData[i].buffer_type = m_aFields[i].type;
 638
 639         // allocates memory, if it is a fixed size type. If not then nullptr
 640         mysqlc_sdbc_driver::allocateSqlVar(&m_aData[i].buffer, m_aData[i].buffer_type,
 641                                            m_aFields[i].length);
 642     }
 643     mysql_stmt_bind_result(m_pStmt, m_aData.get());
 644     if (bFirstRun)
 645         mysql_stmt_store_result(m_pStmt);
 646     int failure = mysql_stmt_fetch(m_pStmt);
 647
 648     for (sal_Int32 i = 0; i < m_nFieldCount; ++i)
 649     {
 650         if (*m_aData[i].error)
 651         {
 652             // expected if we have a BLOB, as buffer_length is set to 0. We want to
 653             // fetch it piece by piece
 654             // see https://bugs.mysql.com/file.php?id=12361&bug_id=33086
 655             if (m_aData[i].buffer == nullptr)
 656             {
 657                 m_aData[i].buffer_length = *m_aData[i].length;
 658                 m_aData[i].buffer = malloc(*m_aData[i].length);
 659                 mysql_stmt_fetch_column(m_pStmt, &m_aData[i], i, 0);
 660             }
 661         }
 662     }
 663
 664     if (failure == 1)
 665     {
 666         MYSQL* pMysql = m_rConnection.getMysqlConnection();
 667         mysqlc_sdbc_driver::throwSQLExceptionWithMsg(mysql_error(pMysql), mysql_errno(pMysql),
 668                                                      *this, m_encoding);
 669     }
 670     else if (failure == MYSQL_NO_DATA)
 671         return false;
 672
 673     // current field cannot be asked as a number. We have to keep track it
 674     // manually.
 675     m_nCurrentField += 1;
 676
 677     return true;
 678 }
 679
 680 sal_Bool SAL_CALL OPreparedResultSet::wasNull()
 681 {
 682     MutexGuard aGuard(m_aMutex);
 683     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 684
 685     return m_bWasNull;
 686 }
 687
 688 void SAL_CALL OPreparedResultSet::cancel()
 689 {
 690     MutexGuard aGuard(m_aMutex);
 691     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 692 }
 693
 694 void SAL_CALL OPreparedResultSet::clearWarnings() {}
 695
 696 Any SAL_CALL OPreparedResultSet::getWarnings()
 697 {
 698     Any aRet = Any();
 699     return aRet;
 700 }
 701
 702 void SAL_CALL OPreparedResultSet::insertRow()
 703 {
 704     MutexGuard aGuard(m_aMutex);
 705     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 706     // you only have to implement this if you want to insert new rows
 707     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::insertRow", *this);
 708 }
 709
 710 void SAL_CALL OPreparedResultSet::updateRow()
 711 {
 712     MutexGuard aGuard(m_aMutex);
 713     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 714
 715     // only when you allow updates
 716     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::updateRow", *this);
 717 }
 718
 719 void SAL_CALL OPreparedResultSet::deleteRow()
 720 {
 721     MutexGuard aGuard(m_aMutex);
 722     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 723     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::deleteRow", *this);
 724 }
 725
 726 void SAL_CALL OPreparedResultSet::cancelRowUpdates()
 727 {
 728     MutexGuard aGuard(m_aMutex);
 729     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 730     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::cancelRowUpdates",
 731                                                             *this);
 732 }
 733
 734 void SAL_CALL OPreparedResultSet::moveToInsertRow()
 735 {
 736     MutexGuard aGuard(m_aMutex);
 737     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 738
 739     // only when you allow insert's
 740     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::moveToInsertRow",
 741                                                             *this);
 742 }
 743
 744 void SAL_CALL OPreparedResultSet::moveToCurrentRow()
 745 {
 746     MutexGuard aGuard(m_aMutex);
 747     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 748 }
 749
 750 void SAL_CALL OPreparedResultSet::updateNull(sal_Int32 column)
 751 {
 752     MutexGuard aGuard(m_aMutex);
 753     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 754     checkColumnIndex(column);
 755     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::updateNull",
 756                                                             *this);
 757 }
 758
 759 void SAL_CALL OPreparedResultSet::updateBoolean(sal_Int32 column, sal_Bool /* x */)
 760 {
 761     MutexGuard aGuard(m_aMutex);
 762     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 763     checkColumnIndex(column);
 764     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::updateBoolean",
 765                                                             *this);
 766 }
 767
 768 void SAL_CALL OPreparedResultSet::updateByte(sal_Int32 column, sal_Int8 /* x */)
 769 {
 770     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 771     MutexGuard aGuard(m_aMutex);
 772     checkColumnIndex(column);
 773     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::updateByte",
 774                                                             *this);
 775 }
 776
 777 void SAL_CALL OPreparedResultSet::updateShort(sal_Int32 column, sal_Int16 /* x */)
 778 {
 779     MutexGuard aGuard(m_aMutex);
 780     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 781     checkColumnIndex(column);
 782     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::updateShort",
 783                                                             *this);
 784 }
 785
 786 void SAL_CALL OPreparedResultSet::updateInt(sal_Int32 column, sal_Int32 /* x */)
 787 {
 788     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 789     MutexGuard aGuard(m_aMutex);
 790     checkColumnIndex(column);
 791     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::updateInt", *this);
 792 }
 793
 794 void SAL_CALL OPreparedResultSet::updateLong(sal_Int32 column, sal_Int64 /* x */)
 795 {
 796     MutexGuard aGuard(m_aMutex);
 797     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 798     checkColumnIndex(column);
 799     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::updateLong",
 800                                                             *this);
 801 }
 802
 803 void SAL_CALL OPreparedResultSet::updateFloat(sal_Int32 column, float /* x */)
 804 {
 805     MutexGuard aGuard(m_aMutex);
 806     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 807     checkColumnIndex(column);
 808     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::updateFloat",
 809                                                             *this);
 810 }
 811
 812 void SAL_CALL OPreparedResultSet::updateDouble(sal_Int32 column, double /* x */)
 813 {
 814     MutexGuard aGuard(m_aMutex);
 815     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 816     checkColumnIndex(column);
 817     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::updateDouble",
 818                                                             *this);
 819 }
 820
 821 void SAL_CALL OPreparedResultSet::updateString(sal_Int32 column, const OUString& /* x */)
 822 {
 823     MutexGuard aGuard(m_aMutex);
 824     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 825     checkColumnIndex(column);
 826     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::updateString",
 827                                                             *this);
 828 }
 829
 830 void SAL_CALL OPreparedResultSet::updateBytes(sal_Int32 column,
 831                                               const uno::Sequence<sal_Int8>& /* x */)
 832 {
 833     MutexGuard aGuard(m_aMutex);
 834     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 835     checkColumnIndex(column);
 836     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::updateBytes",
 837                                                             *this);
 838 }
 839
 840 void SAL_CALL OPreparedResultSet::updateDate(sal_Int32 column, const Date& /* x */)
 841 {
 842     MutexGuard aGuard(m_aMutex);
 843     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 844     checkColumnIndex(column);
 845     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::updateDate",
 846                                                             *this);
 847 }
 848
 849 void SAL_CALL OPreparedResultSet::updateTime(sal_Int32 column, const Time& /* x */)
 850 {
 851     MutexGuard aGuard(m_aMutex);
 852     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 853     checkColumnIndex(column);
 854     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::updateTime",
 855                                                             *this);
 856 }
 857
 858 void SAL_CALL OPreparedResultSet::updateTimestamp(sal_Int32 column, const DateTime& /* x */)
 859 {
 860     MutexGuard aGuard(m_aMutex);
 861     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 862     checkColumnIndex(column);
 863     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::updateTimestamp",
 864                                                             *this);
 865 }
 866
 867 void SAL_CALL OPreparedResultSet::updateBinaryStream(sal_Int32 column,
 868                                                      const uno::Reference<XInputStream>& /* x */,
 869                                                      sal_Int32 /* length */)
 870 {
 871     MutexGuard aGuard(m_aMutex);
 872     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 873     checkColumnIndex(column);
 874     mysqlc_sdbc_driver::throwFeatureNotImplementedException(
 875         "OPreparedResultSet::updateBinaryStream", *this);
 876 }
 877
 878 void SAL_CALL OPreparedResultSet::updateCharacterStream(sal_Int32 column,
 879                                                         const uno::Reference<XInputStream>& /* x */,
 880                                                         sal_Int32 /* length */)
 881 {
 882     MutexGuard aGuard(m_aMutex);
 883     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 884     checkColumnIndex(column);
 885     mysqlc_sdbc_driver::throwFeatureNotImplementedException(
 886         "OPreparedResultSet::updateCharacterStream", *this);
 887 }
 888
 889 void SAL_CALL OPreparedResultSet::refreshRow()
 890 {
 891     MutexGuard aGuard(m_aMutex);
 892     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 893     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::refreshRow",
 894                                                             *this);
 895 }
 896
 897 void SAL_CALL OPreparedResultSet::updateObject(sal_Int32 column, const Any& /* x */)
 898 {
 899     MutexGuard aGuard(m_aMutex);
 900     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 901     checkColumnIndex(column);
 902     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::updateObject",
 903                                                             *this);
 904 }
 905
 906 void SAL_CALL OPreparedResultSet::updateNumericObject(sal_Int32 column, const Any& /* x */,
 907                                                       sal_Int32 /* scale */)
 908 {
 909     MutexGuard aGuard(m_aMutex);
 910     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 911     checkColumnIndex(column);
 912     mysqlc_sdbc_driver::throwFeatureNotImplementedException(
 913         "OPreparedResultSet::updateNumericObject", *this);
 914 }
 915
 916 // XRowLocate
 917 Any SAL_CALL OPreparedResultSet::getBookmark()
 918 {
 919     MutexGuard aGuard(m_aMutex);
 920     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 921     Any aRet = Any();
 922
 923     // if you don't want to support bookmark you must remove the XRowLocate interface
 924     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::getBookmark",
 925                                                             *this);
 926
 927     return aRet;
 928 }
 929
 930 sal_Bool SAL_CALL OPreparedResultSet::moveToBookmark(const Any& /* bookmark */)
 931 {
 932     MutexGuard aGuard(m_aMutex);
 933     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 934
 935     return false;
 936 }
 937
 938 sal_Bool SAL_CALL OPreparedResultSet::moveRelativeToBookmark(const Any& /* bookmark */,
 939                                                              sal_Int32 /* rows */)
 940 {
 941     MutexGuard aGuard(m_aMutex);
 942     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 943
 944     mysqlc_sdbc_driver::throwFeatureNotImplementedException(
 945         "OPreparedResultSet::moveRelativeToBookmark", *this);
 946     return false;
 947 }
 948
 949 sal_Int32 SAL_CALL OPreparedResultSet::compareBookmarks(const Any& /* n1 */, const Any& /* n2 */)
 950 {
 951     MutexGuard aGuard(m_aMutex);
 952     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 953
 954     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::compareBookmarks",
 955                                                             *this);
 956
 957     return CompareBookmark::NOT_EQUAL;
 958 }
 959
 960 sal_Bool SAL_CALL OPreparedResultSet::hasOrderedBookmarks() { return false; }
 961
 962 sal_Int32 SAL_CALL OPreparedResultSet::hashBookmark(const Any& /* bookmark */)
 963 {
 964     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::hashBookmark",
 965                                                             *this);
 966     return 0;
 967 }
 968
 969 // XDeleteRows
 970 uno::Sequence<sal_Int32>
 971     SAL_CALL OPreparedResultSet::deleteRows(const uno::Sequence<Any>& /* rows */)
 972 {
 973     MutexGuard aGuard(m_aMutex);
 974     checkDisposed(OPreparedResultSet_BASE::rBHelper.bDisposed);
 975     uno::Sequence<sal_Int32> aRet = uno::Sequence<sal_Int32>();
 976
 977     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedResultSet::deleteRows",
 978                                                             *this);
 979     return aRet;
 980 }
 981
 982 IPropertyArrayHelper* OPreparedResultSet::createArrayHelper() const
 983 {
 984     uno::Sequence<Property> aProps(5);
 985     Property* pProperties = aProps.getArray();
 986     sal_Int32 nPos = 0;
 987     pProperties[nPos++] = Property("FetchDirection", PROPERTY_ID_FETCHDIRECTION,
 988                                    cppu::UnoType<sal_Int32>::get(), 0);
 989     pProperties[nPos++]
 990         = Property("FetchSize", PROPERTY_ID_FETCHSIZE, cppu::UnoType<sal_Int32>::get(), 0);
 991     pProperties[nPos++] = Property("IsBookmarkable", PROPERTY_ID_ISBOOKMARKABLE,
 992                                    cppu::UnoType<bool>::get(), PropertyAttribute::READONLY);
 993     pProperties[nPos++] = Property("ResultSetConcurrency", PROPERTY_ID_RESULTSETCONCURRENCY,
 994                                    cppu::UnoType<sal_Int32>::get(), PropertyAttribute::READONLY);
 995     pProperties[nPos++] = Property("ResultSetType", PROPERTY_ID_RESULTSETTYPE,
 996                                    cppu::UnoType<sal_Int32>::get(), PropertyAttribute::READONLY);
 997
 998     return new OPropertyArrayHelper(aProps);
 999 }
1000
1001 IPropertyArrayHelper& OPreparedResultSet::getInfoHelper() { return *getArrayHelper(); }
1002
1003 sal_Bool OPreparedResultSet::convertFastPropertyValue(Any& /* rConvertedValue */,
1004                                                       Any& /* rOldValue */, sal_Int32 nHandle,
1005                                                       const Any& /* rValue */)
1006 {
1007     switch (nHandle)
1008     {
1009         case PROPERTY_ID_ISBOOKMARKABLE:
1010         case PROPERTY_ID_CURSORNAME:
1011         case PROPERTY_ID_RESULTSETCONCURRENCY:
1012         case PROPERTY_ID_RESULTSETTYPE:
1013             throw css::lang::IllegalArgumentException();
1014         case PROPERTY_ID_FETCHDIRECTION:
1015         case PROPERTY_ID_FETCHSIZE:
1016         default:;
1017     }
1018     return false;
1019 }
1020
1021 void OPreparedResultSet::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,
1022                                                           const Any& /* rValue */)
1023 {
1024     switch (nHandle)
1025     {
1026         case PROPERTY_ID_ISBOOKMARKABLE:
1027         case PROPERTY_ID_CURSORNAME:
1028         case PROPERTY_ID_RESULTSETCONCURRENCY:
1029         case PROPERTY_ID_RESULTSETTYPE:
1030             throw uno::Exception("cannot set prop " + OUString::number(nHandle), nullptr);
1031         case PROPERTY_ID_FETCHDIRECTION:
1032             break;
1033         case PROPERTY_ID_FETCHSIZE:
1034             break;
1035         default:;
1036     }
1037 }
1038
1039 void OPreparedResultSet::getFastPropertyValue(Any& _rValue, sal_Int32 nHandle) const
1040 {
1041     switch (nHandle)
1042     {
1043         case PROPERTY_ID_ISBOOKMARKABLE:
1044             _rValue <<= false;
1045             break;
1046         case PROPERTY_ID_CURSORNAME:
1047             break;
1048         case PROPERTY_ID_RESULTSETCONCURRENCY:
1049             _rValue <<= ResultSetConcurrency::READ_ONLY;
1050             break;
1051         case PROPERTY_ID_RESULTSETTYPE:
1052             _rValue <<= ResultSetType::SCROLL_INSENSITIVE;
1053             break;
1054         case PROPERTY_ID_FETCHDIRECTION:
1055             _rValue <<= FetchDirection::FORWARD;
1056             break;
1057         case PROPERTY_ID_FETCHSIZE:
1058             _rValue <<= sal_Int32(50);
1059             break;
1060             ;
1061         default:;
1062     }
1063 }
1064
1065 void SAL_CALL OPreparedResultSet::acquire() throw() { OPreparedResultSet_BASE::acquire(); }
1066
1067 void SAL_CALL OPreparedResultSet::release() throw() { OPreparedResultSet_BASE::release(); }
1068
1069 css::uno::Reference<css::beans::XPropertySetInfo> SAL_CALL OPreparedResultSet::getPropertySetInfo()
1070 {
1071     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
1072 }
1073
1074 void OPreparedResultSet::checkColumnIndex(sal_Int32 index)
1075 {
1076     if (!m_aData)
1077         throw SQLException("Cursor out of range", *this, OUString(), 1, Any());
1078     if (index < 1 || index > static_cast<int>(m_nFieldCount))
1079     {
1080         /* static object for efficiency or thread safety is a problem ? */
1081         throw SQLException("index out of range", *this, OUString(), 1, Any());
1082     }
1083 }
1084
1085 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */