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