connectivity/source/drivers/kab/KResultSet.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: KResultSet.cxx,v $
  10  * $Revision: 1.9.46.2 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_connectivity.hxx"
  33
  34 #include "KResultSet.hxx"
  35 #include "KResultSetMetaData.hxx"
  36 #include "KConnection.hxx"
  37 #include "kcondition.hxx"
  38 #include "korder.hxx"
  39 #include "kfields.hxx"
  40 #include <com/sun/star/beans/PropertyAttribute.hpp>
  41 #include <com/sun/star/sdbcx/CompareBookmark.hpp>
  42 #include "TConnection.hxx"
  43 #include <connectivity/dbexception.hxx>
  44 #include "resource/kab_res.hrc"
  45 #include "resource/sharedresources.hxx"
  46
  47 using namespace connectivity::kab;
  48 using namespace cppu;
  49 using namespace com::sun::star::uno;
  50 using namespace com::sun::star::lang;
  51 using namespace com::sun::star::beans;
  52 using namespace com::sun::star::sdbc;
  53 using namespace com::sun::star::sdbcx;
  54 using namespace com::sun::star::io;
  55 using namespace com::sun::star::util;
  56
  57 IMPLEMENT_SERVICE_INFO(KabResultSet, "com.sun.star.sdbc.drivers.KabResultSet", "com.sun.star.sdbc.ResultSet");
  58 // -------------------------------------------------------------------------
  59 KabResultSet::KabResultSet(KabCommonStatement* pStmt)
  60     : KabResultSet_BASE(m_aMutex),
  61       OPropertySetHelper(KabResultSet_BASE::rBHelper),
  62       m_xStatement(pStmt),
  63       m_xMetaData(NULL),
  64       m_aKabAddressees(),
  65       m_nRowPos(-1),
  66       m_bWasNull(sal_True)
  67 {
  68 }
  69 // -------------------------------------------------------------------------
  70 KabResultSet::~KabResultSet()
  71 {
  72 }
  73 // -------------------------------------------------------------------------
  74 void KabResultSet::allKabAddressees()
  75 {
  76     KabConnection* pConnection = static_cast< KabConnection *>(m_xStatement->getConnection().get());
  77     KABC::AddressBook* pAddressBook = pConnection->getAddressBook();
  78
  79     m_aKabAddressees = pAddressBook->allAddressees();
  80 }
  81 // -------------------------------------------------------------------------
  82 void KabResultSet::someKabAddressees(const KabCondition *pCondition)
  83 {
  84     KabConnection* pConnection = static_cast< KabConnection *>(m_xStatement->getConnection().get());
  85     KABC::AddressBook* pAddressBook = pConnection->getAddressBook();
  86
  87     KABC::AddressBook::Iterator iterator;
  88
  89     for (iterator = pAddressBook->begin();
  90          iterator != pAddressBook->end();
  91          ++iterator)
  92     {
  93         if (pCondition->eval(*iterator))
  94             m_aKabAddressees.push_back(*iterator);
  95     }
  96 }
  97 // -------------------------------------------------------------------------
  98 void KabResultSet::sortKabAddressees(const KabOrder *pOrder)
  99 {
 100     // We do not use class KAddresseeList, which has a sorting algorithm in it, because
 101     // it uses templates. It would expand to more or less the same code as the one
 102     // which follows, but it would need not be called in a much less convenient way.
 103
 104     KABC::Addressee::List::Iterator
 105         begin = m_aKabAddressees.begin(),
 106         end = m_aKabAddressees.end(),
 107         iterator;
 108
 109     // Bubble sort. Feel free to implement a better algorithm.
 110     while (begin != end)
 111     {
 112         end--;
 113         for (iterator = begin; iterator != end; ++iterator)
 114         {
 115             if (pOrder->compare(*iterator, *end) > 0)
 116                 qSwap(*iterator, *end);
 117         }
 118     }
 119 }
 120 // -------------------------------------------------------------------------
 121 void KabResultSet::disposing()
 122 {
 123     OPropertySetHelper::disposing();
 124
 125     ::osl::MutexGuard aGuard(m_aMutex);
 126
 127 m_xStatement.clear();
 128 m_xMetaData.clear();
 129 }
 130 // -------------------------------------------------------------------------
 131 Any SAL_CALL KabResultSet::queryInterface(const Type & rType) throw(RuntimeException)
 132 {
 133     Any aRet = OPropertySetHelper::queryInterface(rType);
 134     if (!aRet.hasValue())
 135         aRet = KabResultSet_BASE::queryInterface(rType);
 136     return aRet;
 137 }
 138 // -------------------------------------------------------------------------
 139 void SAL_CALL KabResultSet::acquire() throw()
 140 {
 141     KabResultSet_BASE::acquire();
 142 }
 143 // -------------------------------------------------------------------------
 144 void SAL_CALL KabResultSet::release() throw()
 145 {
 146     KabResultSet_BASE::release();
 147 }
 148 // -------------------------------------------------------------------------
 149 Sequence<  Type > SAL_CALL KabResultSet::getTypes() throw(RuntimeException)
 150 {
 151     OTypeCollection aTypes(
 152         ::getCppuType( (const Reference< ::com::sun::star::beans::XMultiPropertySet >*) 0),
 153         ::getCppuType( (const Reference< ::com::sun::star::beans::XFastPropertySet >*) 0),
 154         ::getCppuType( (const Reference< ::com::sun::star::beans::XPropertySet >*) 0));
 155
 156     return comphelper::concatSequences(aTypes.getTypes(), KabResultSet_BASE::getTypes());
 157 }
 158 // -------------------------------------------------------------------------
 159 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL KabResultSet::getPropertySetInfo(  ) throw(::com::sun::star::uno::RuntimeException)
 160 {
 161     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 162 }
 163 // -------------------------------------------------------------------------
 164 sal_Int32 SAL_CALL KabResultSet::findColumn(const ::rtl::OUString& columnName) throw(SQLException, RuntimeException)
 165 {
 166     ::osl::MutexGuard aGuard( m_aMutex );
 167     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 168
 169     // find the first column with the name columnName
 170     Reference< XResultSetMetaData > xMeta = getMetaData();
 171     sal_Int32 nLen = xMeta->getColumnCount();
 172
 173     for (sal_Int32 i = 1; i <= nLen; ++i)
 174         if (xMeta->isCaseSensitive(i) ?
 175             columnName == xMeta->getColumnName(i) :
 176             columnName.equalsIgnoreAsciiCase(xMeta->getColumnName(i)))
 177                 return i;
 178
 179     ::connectivity::SharedResources aResources;
 180     const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution(
 181             STR_INVALID_COLUMNNAME,
 182             "$columnname$",columnName
 183          ) );
 184     ::dbtools::throwGenericSQLException(sError,NULL);
 185
 186     // Unreachable:
 187     OSL_ASSERT(false);
 188     return 0;
 189 }
 190 // -------------------------------------------------------------------------
 191 ::rtl::OUString SAL_CALL KabResultSet::getString(sal_Int32 columnIndex) throw(SQLException, RuntimeException)
 192 {
 193     ::osl::MutexGuard aGuard( m_aMutex );
 194     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 195
 196     ::rtl::OUString aRet;
 197     sal_Int32 nAddressees = m_aKabAddressees.size();
 198     ::KABC::Field::List aFields = ::KABC::Field::allFields();
 199
 200     if (m_nRowPos != -1 && m_nRowPos != nAddressees && m_xMetaData.is())
 201     {
 202         sal_Int32 nFieldNumber = m_xMetaData->fieldAtColumn(columnIndex);
 203         QString aQtName;
 204
 205         switch (nFieldNumber)
 206         {
 207             case KAB_FIELD_REVISION:
 208 // trigger an exception here
 209 m_bWasNull = true;
 210 return aRet;
 211             default:
 212                 aQtName = aFields[nFieldNumber - KAB_DATA_FIELDS]->value(m_aKabAddressees[m_nRowPos]);
 213         }
 214 // KDE address book currently does not use NULL values.
 215 // But it might do it someday
 216         if (!aQtName.isNull())
 217         {
 218             m_bWasNull = false;
 219             aRet = ::rtl::OUString((const sal_Unicode *) aQtName.ucs2());
 220             return aRet;
 221         }
 222     }
 223 // Trigger an exception ?
 224     m_bWasNull = true;
 225     return aRet;
 226 }
 227 // -------------------------------------------------------------------------
 228 sal_Bool SAL_CALL KabResultSet::getBoolean(sal_Int32) throw(SQLException, RuntimeException)
 229 {
 230     ::osl::MutexGuard aGuard( m_aMutex );
 231     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 232
 233 ::dbtools::throwFunctionNotSupportedException("getBoolean", NULL);
 234
 235     return sal_False;
 236 }
 237 // -------------------------------------------------------------------------
 238 sal_Int8 SAL_CALL KabResultSet::getByte(sal_Int32) throw(SQLException, RuntimeException)
 239 {
 240     ::osl::MutexGuard aGuard( m_aMutex );
 241     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 242
 243 ::dbtools::throwFunctionNotSupportedException("getByte", NULL);
 244
 245     sal_Int8 nRet = 0;
 246     return nRet;
 247 }
 248 // -------------------------------------------------------------------------
 249 sal_Int16 SAL_CALL KabResultSet::getShort(sal_Int32) throw(SQLException, RuntimeException)
 250 {
 251     ::osl::MutexGuard aGuard( m_aMutex );
 252     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 253
 254 ::dbtools::throwFunctionNotSupportedException("getShort", NULL);
 255
 256     sal_Int16 nRet = 0;
 257     return nRet;
 258 }
 259 // -------------------------------------------------------------------------
 260 sal_Int32 SAL_CALL KabResultSet::getInt(sal_Int32) throw(SQLException, RuntimeException)
 261 {
 262     ::osl::MutexGuard aGuard( m_aMutex );
 263     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 264
 265 ::dbtools::throwFunctionNotSupportedException("getInt", NULL);
 266
 267     sal_Int32 nRet = 0;
 268     return nRet;
 269 }
 270 // -------------------------------------------------------------------------
 271 sal_Int64 SAL_CALL KabResultSet::getLong(sal_Int32) throw(SQLException, RuntimeException)
 272 {
 273     ::osl::MutexGuard aGuard( m_aMutex );
 274     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 275
 276 ::dbtools::throwFunctionNotSupportedException("getLong", NULL);
 277
 278     return sal_Int64();
 279 }
 280 // -------------------------------------------------------------------------
 281 float SAL_CALL KabResultSet::getFloat(sal_Int32) throw(SQLException, RuntimeException)
 282 {
 283     ::osl::MutexGuard aGuard( m_aMutex );
 284     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 285
 286 ::dbtools::throwFunctionNotSupportedException("getFloat", NULL);
 287
 288     float nVal(0);
 289     return nVal;
 290 }
 291 // -------------------------------------------------------------------------
 292 double SAL_CALL KabResultSet::getDouble(sal_Int32) throw(SQLException, RuntimeException)
 293 {
 294     ::osl::MutexGuard aGuard( m_aMutex );
 295     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 296
 297 ::dbtools::throwFunctionNotSupportedException("getDouble", NULL);
 298
 299     double nRet = 0;
 300     return nRet;
 301 }
 302 // -------------------------------------------------------------------------
 303 Sequence< sal_Int8 > SAL_CALL KabResultSet::getBytes(sal_Int32) throw(SQLException, RuntimeException)
 304 {
 305     ::osl::MutexGuard aGuard( m_aMutex );
 306     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 307
 308 ::dbtools::throwFunctionNotSupportedException("", NULL);
 309
 310     return Sequence< sal_Int8 >();
 311 }
 312 // -------------------------------------------------------------------------
 313 Date SAL_CALL KabResultSet::getDate(sal_Int32) throw(SQLException, RuntimeException)
 314 {
 315     ::osl::MutexGuard aGuard( m_aMutex );
 316     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 317
 318 ::dbtools::throwFunctionNotSupportedException("getDate", NULL);
 319
 320     Date aRet;
 321     return aRet;
 322 }
 323 // -------------------------------------------------------------------------
 324 Time SAL_CALL KabResultSet::getTime(sal_Int32) throw(SQLException, RuntimeException)
 325 {
 326     ::osl::MutexGuard aGuard( m_aMutex );
 327     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 328
 329 ::dbtools::throwFunctionNotSupportedException("getTime", NULL);
 330
 331     Time nRet;
 332     return nRet;
 333 }
 334 // -------------------------------------------------------------------------
 335 DateTime SAL_CALL KabResultSet::getTimestamp(sal_Int32 columnIndex) throw(SQLException, RuntimeException)
 336 {
 337     ::osl::MutexGuard aGuard( m_aMutex );
 338     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 339
 340     DateTime nRet;
 341     sal_Int32 nAddressees = m_aKabAddressees.size();
 342
 343     if (m_nRowPos != -1 && m_nRowPos != nAddressees && m_xMetaData.is())
 344     {
 345         KabResultSetMetaData *pMeta = static_cast<KabResultSetMetaData *>(m_xMetaData.get());
 346         sal_Int32 nFieldNumber = pMeta->fieldAtColumn(columnIndex);
 347
 348         if (nFieldNumber == KAB_FIELD_REVISION)
 349         {
 350             QDateTime nRevision(m_aKabAddressees[m_nRowPos].revision());
 351
 352             if (!nRevision.isNull())
 353             {
 354                 m_bWasNull = false;
 355                 nRet.Year = nRevision.date().year();
 356                 nRet.Month = nRevision.date().month();
 357                 nRet.Day = nRevision.date().day();
 358                 nRet.Hours = nRevision.time().hour();
 359                 nRet.Minutes = nRevision.time().minute();
 360                 nRet.Seconds = nRevision.time().second();
 361                 nRet.HundredthSeconds = nRevision.time().msec() / 10;
 362                 return nRet;
 363             }
 364         }
 365         else {
 366             ;
 367         }
 368 // trigger an exception here
 369     }
 370 // Trigger an exception ?
 371     m_bWasNull = true;
 372     return nRet;
 373 }
 374 // -------------------------------------------------------------------------
 375 Reference< XInputStream > SAL_CALL KabResultSet::getBinaryStream(sal_Int32) throw(SQLException, RuntimeException)
 376 {
 377     ::osl::MutexGuard aGuard( m_aMutex );
 378     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 379
 380 ::dbtools::throwFunctionNotSupportedException("getBinaryStream", NULL);
 381
 382     return NULL;
 383 }
 384 // -------------------------------------------------------------------------
 385 Reference< XInputStream > SAL_CALL KabResultSet::getCharacterStream(sal_Int32) throw(SQLException, RuntimeException)
 386 {
 387     ::osl::MutexGuard aGuard( m_aMutex );
 388     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 389
 390 ::dbtools::throwFunctionNotSupportedException("getCharacterStream", NULL);
 391
 392     return NULL;
 393 }
 394 // -------------------------------------------------------------------------
 395 Any SAL_CALL KabResultSet::getObject(sal_Int32, const Reference< ::com::sun::star::container::XNameAccess >&) throw(SQLException, RuntimeException)
 396 {
 397     ::osl::MutexGuard aGuard( m_aMutex );
 398     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 399
 400 ::dbtools::throwFunctionNotSupportedException("getObject", NULL);
 401
 402     return Any();
 403 }
 404 // -------------------------------------------------------------------------
 405 Reference< XRef > SAL_CALL KabResultSet::getRef(sal_Int32) throw(SQLException, RuntimeException)
 406 {
 407     ::osl::MutexGuard aGuard( m_aMutex );
 408     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 409
 410 ::dbtools::throwFunctionNotSupportedException("getRef", NULL);
 411
 412     return NULL;
 413 }
 414 // -------------------------------------------------------------------------
 415 Reference< XBlob > SAL_CALL KabResultSet::getBlob(sal_Int32) throw(SQLException, RuntimeException)
 416 {
 417     ::osl::MutexGuard aGuard( m_aMutex );
 418     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 419
 420 ::dbtools::throwFunctionNotSupportedException("getBlob", NULL);
 421
 422     return NULL;
 423 }
 424 // -------------------------------------------------------------------------
 425 Reference< XClob > SAL_CALL KabResultSet::getClob(sal_Int32) throw(SQLException, RuntimeException)
 426 {
 427     ::osl::MutexGuard aGuard( m_aMutex );
 428     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 429
 430 ::dbtools::throwFunctionNotSupportedException("getClob", NULL);
 431
 432     return NULL;
 433 }
 434 // -------------------------------------------------------------------------
 435 Reference< XArray > SAL_CALL KabResultSet::getArray(sal_Int32) throw(SQLException, RuntimeException)
 436 {
 437     ::osl::MutexGuard aGuard( m_aMutex );
 438     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 439
 440 ::dbtools::throwFunctionNotSupportedException("getArray", NULL);
 441
 442     return NULL;
 443 }
 444 // -------------------------------------------------------------------------
 445 Reference< XResultSetMetaData > SAL_CALL KabResultSet::getMetaData() throw(SQLException, RuntimeException)
 446 {
 447     ::osl::MutexGuard aGuard( m_aMutex );
 448     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 449
 450     if (!m_xMetaData.is())
 451         m_xMetaData = new KabResultSetMetaData(m_xStatement->getOwnConnection());
 452
 453     Reference< XResultSetMetaData > xMetaData = m_xMetaData.get();
 454     return xMetaData;
 455 }
 456 // -------------------------------------------------------------------------
 457 sal_Bool SAL_CALL KabResultSet::isBeforeFirst() throw(SQLException, RuntimeException)
 458 {
 459     ::osl::MutexGuard aGuard( m_aMutex );
 460     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 461
 462     if (m_nRowPos == -1)
 463         return sal_True;
 464
 465     return sal_False;
 466 }
 467 // -------------------------------------------------------------------------
 468 sal_Bool SAL_CALL KabResultSet::isAfterLast() throw(SQLException, RuntimeException)
 469 {
 470     ::osl::MutexGuard aGuard( m_aMutex );
 471     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 472
 473     sal_Int32 nAddressees = m_aKabAddressees.size();
 474     if (m_nRowPos == nAddressees)
 475         return sal_True;
 476
 477     return sal_False;
 478 }
 479 // -------------------------------------------------------------------------
 480 sal_Bool SAL_CALL KabResultSet::isFirst() throw(SQLException, RuntimeException)
 481 {
 482     ::osl::MutexGuard aGuard( m_aMutex );
 483     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 484
 485     if (m_nRowPos == 0)
 486         return sal_True;
 487
 488     return sal_False;
 489 }
 490 // -------------------------------------------------------------------------
 491 sal_Bool SAL_CALL KabResultSet::isLast() throw(SQLException, RuntimeException)
 492 {
 493     ::osl::MutexGuard aGuard( m_aMutex );
 494     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 495
 496     sal_Int32 nAddressees = m_aKabAddressees.size();
 497     if (m_nRowPos == nAddressees - 1)
 498         return sal_True;
 499
 500     return sal_False;
 501 }
 502 // -------------------------------------------------------------------------
 503 void SAL_CALL KabResultSet::beforeFirst() throw(SQLException, RuntimeException)
 504 {
 505     ::osl::MutexGuard aGuard( m_aMutex );
 506     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 507
 508     // move before the first row
 509     m_nRowPos = -1;
 510 }
 511 // -------------------------------------------------------------------------
 512 void SAL_CALL KabResultSet::afterLast() throw(SQLException, RuntimeException)
 513 {
 514     ::osl::MutexGuard aGuard( m_aMutex );
 515     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 516
 517     // move after the last row
 518     sal_Int32 nAddressees = m_aKabAddressees.size();
 519     m_nRowPos = nAddressees;
 520 }
 521 // -------------------------------------------------------------------------
 522 void SAL_CALL KabResultSet::close() throw(SQLException, RuntimeException)
 523 {
 524     {
 525         ::osl::MutexGuard aGuard( m_aMutex );
 526         checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 527     }
 528     dispose();
 529 }
 530 // -------------------------------------------------------------------------
 531 sal_Bool SAL_CALL KabResultSet::first() throw(SQLException, RuntimeException)
 532 {
 533     ::osl::MutexGuard aGuard( m_aMutex );
 534     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 535
 536     sal_Int32 nAddressees = m_aKabAddressees.size();
 537     if (nAddressees == 0)
 538         return sal_False;
 539
 540     m_nRowPos = 0;
 541     return sal_True;
 542 }
 543 // -------------------------------------------------------------------------
 544 sal_Bool SAL_CALL KabResultSet::last() throw(SQLException, RuntimeException)
 545 {
 546     ::osl::MutexGuard aGuard( m_aMutex );
 547     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 548
 549     sal_Int32 nAddressees = m_aKabAddressees.size();
 550     if (nAddressees == 0)
 551         return sal_False;
 552
 553     m_nRowPos = nAddressees - 1;
 554     return sal_True;
 555 }
 556 // -------------------------------------------------------------------------
 557 sal_Int32 SAL_CALL KabResultSet::getRow() throw(SQLException, RuntimeException)
 558 {
 559     ::osl::MutexGuard aGuard( m_aMutex );
 560     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 561
 562     return m_nRowPos;
 563 }
 564 // -------------------------------------------------------------------------
 565 sal_Bool SAL_CALL KabResultSet::absolute(sal_Int32 row) throw(SQLException, RuntimeException)
 566 {
 567     ::osl::MutexGuard aGuard( m_aMutex );
 568     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 569
 570     sal_Int32 nAddressees = m_aKabAddressees.size();
 571     if (row <= -1 ||
 572         row >= nAddressees)
 573         return sal_False;
 574
 575     m_nRowPos = row;
 576     return sal_True;
 577 }
 578 // -------------------------------------------------------------------------
 579 sal_Bool SAL_CALL KabResultSet::relative(sal_Int32 row) throw(SQLException, RuntimeException)
 580 {
 581     ::osl::MutexGuard aGuard( m_aMutex );
 582     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 583
 584     return absolute(m_nRowPos + row);
 585 }
 586 // -------------------------------------------------------------------------
 587 sal_Bool SAL_CALL KabResultSet::next() throw(SQLException, RuntimeException)
 588 {
 589     ::osl::MutexGuard aGuard( m_aMutex );
 590     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 591
 592     return absolute(m_nRowPos + 1);
 593 }
 594 // -------------------------------------------------------------------------
 595 sal_Bool SAL_CALL KabResultSet::previous() throw(SQLException, RuntimeException)
 596 {
 597     ::osl::MutexGuard aGuard( m_aMutex );
 598     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 599
 600     return absolute(m_nRowPos - 1);
 601 }
 602 // -------------------------------------------------------------------------
 603 Reference< XInterface > SAL_CALL KabResultSet::getStatement() throw(SQLException, RuntimeException)
 604 {
 605     ::osl::MutexGuard aGuard( m_aMutex );
 606     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 607
 608     Reference< XStatement > xStatement = m_xStatement.get();
 609     return xStatement;
 610 }
 611 // -------------------------------------------------------------------------
 612 sal_Bool SAL_CALL KabResultSet::rowDeleted() throw(SQLException, RuntimeException)
 613 {
 614     ::osl::MutexGuard aGuard( m_aMutex );
 615     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 616
 617     return sal_False;
 618 }
 619 // -------------------------------------------------------------------------
 620 sal_Bool SAL_CALL KabResultSet::rowInserted() throw(SQLException, RuntimeException)
 621 {
 622     ::osl::MutexGuard aGuard( m_aMutex );
 623     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 624
 625     return sal_False;
 626 }
 627 // -------------------------------------------------------------------------
 628 sal_Bool SAL_CALL KabResultSet::rowUpdated() throw(SQLException, RuntimeException)
 629 {
 630     ::osl::MutexGuard aGuard( m_aMutex );
 631     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 632
 633     return sal_False;
 634 }
 635 // -------------------------------------------------------------------------
 636 sal_Bool SAL_CALL KabResultSet::wasNull() throw(SQLException, RuntimeException)
 637 {
 638     ::osl::MutexGuard aGuard( m_aMutex );
 639     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 640
 641     return m_bWasNull;
 642 }
 643 // -------------------------------------------------------------------------
 644 void SAL_CALL KabResultSet::cancel() throw(RuntimeException)
 645 {
 646     ::osl::MutexGuard aGuard( m_aMutex );
 647     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 648 }
 649 // -------------------------------------------------------------------------
 650 void SAL_CALL KabResultSet::clearWarnings() throw(SQLException, RuntimeException)
 651 {
 652 }
 653 // -------------------------------------------------------------------------
 654 Any SAL_CALL KabResultSet::getWarnings() throw(SQLException, RuntimeException)
 655 {
 656     return Any();
 657 }
 658 // -------------------------------------------------------------------------
 659 void SAL_CALL KabResultSet::insertRow() throw(SQLException, RuntimeException)
 660 {
 661     ::osl::MutexGuard aGuard( m_aMutex );
 662     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 663
 664     // you only have to implement this if you want to insert new rows
 665 }
 666 // -------------------------------------------------------------------------
 667 void SAL_CALL KabResultSet::updateRow() throw(SQLException, RuntimeException)
 668 {
 669     ::osl::MutexGuard aGuard( m_aMutex );
 670     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 671
 672     // only when you allow updates
 673 }
 674 // -------------------------------------------------------------------------
 675 void SAL_CALL KabResultSet::deleteRow() throw(SQLException, RuntimeException)
 676 {
 677     ::osl::MutexGuard aGuard( m_aMutex );
 678     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 679 }
 680 // -------------------------------------------------------------------------
 681 void SAL_CALL KabResultSet::cancelRowUpdates() throw(SQLException, RuntimeException)
 682 {
 683     ::osl::MutexGuard aGuard( m_aMutex );
 684     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 685 }
 686 // -------------------------------------------------------------------------
 687 void SAL_CALL KabResultSet::moveToInsertRow() throw(SQLException, RuntimeException)
 688 {
 689     ::osl::MutexGuard aGuard( m_aMutex );
 690     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 691
 692     // only when you allow inserts
 693 }
 694 // -------------------------------------------------------------------------
 695 void SAL_CALL KabResultSet::moveToCurrentRow() throw(SQLException, RuntimeException)
 696 {
 697     ::osl::MutexGuard aGuard( m_aMutex );
 698     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 699 }
 700 // -------------------------------------------------------------------------
 701 void SAL_CALL KabResultSet::updateNull(sal_Int32) throw(SQLException, RuntimeException)
 702 {
 703     ::osl::MutexGuard aGuard( m_aMutex );
 704     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 705 }
 706 // -------------------------------------------------------------------------
 707 void SAL_CALL KabResultSet::updateBoolean(sal_Int32, sal_Bool) throw(SQLException, RuntimeException)
 708 {
 709     ::osl::MutexGuard aGuard( m_aMutex );
 710     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 711 }
 712 // -------------------------------------------------------------------------
 713 void SAL_CALL KabResultSet::updateByte(sal_Int32, sal_Int8) throw(SQLException, RuntimeException)
 714 {
 715     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 716     ::osl::MutexGuard aGuard( m_aMutex );
 717 }
 718 // -------------------------------------------------------------------------
 719 void SAL_CALL KabResultSet::updateShort(sal_Int32, sal_Int16) throw(SQLException, RuntimeException)
 720 {
 721     ::osl::MutexGuard aGuard( m_aMutex );
 722     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 723 }
 724 // -------------------------------------------------------------------------
 725 void SAL_CALL KabResultSet::updateInt(sal_Int32, sal_Int32) throw(SQLException, RuntimeException)
 726 {
 727     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 728     ::osl::MutexGuard aGuard( m_aMutex );
 729 }
 730 // -------------------------------------------------------------------------
 731 void SAL_CALL KabResultSet::updateLong(sal_Int32, sal_Int64) throw(SQLException, RuntimeException)
 732 {
 733     ::osl::MutexGuard aGuard( m_aMutex );
 734     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 735 }
 736 // -----------------------------------------------------------------------
 737 void SAL_CALL KabResultSet::updateFloat(sal_Int32, float) throw(SQLException, RuntimeException)
 738 {
 739     ::osl::MutexGuard aGuard( m_aMutex );
 740     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 741 }
 742 // -------------------------------------------------------------------------
 743 void SAL_CALL KabResultSet::updateDouble(sal_Int32, double) throw(SQLException, RuntimeException)
 744 {
 745     ::osl::MutexGuard aGuard( m_aMutex );
 746     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 747 }
 748 // -------------------------------------------------------------------------
 749 void SAL_CALL KabResultSet::updateString(sal_Int32, const ::rtl::OUString&) throw(SQLException, RuntimeException)
 750 {
 751     ::osl::MutexGuard aGuard( m_aMutex );
 752     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 753 }
 754 // -------------------------------------------------------------------------
 755 void SAL_CALL KabResultSet::updateBytes(sal_Int32, const Sequence< sal_Int8 >&) throw(SQLException, RuntimeException)
 756 {
 757     ::osl::MutexGuard aGuard( m_aMutex );
 758     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 759 }
 760 // -------------------------------------------------------------------------
 761 void SAL_CALL KabResultSet::updateDate(sal_Int32, const Date&) throw(SQLException, RuntimeException)
 762 {
 763     ::osl::MutexGuard aGuard( m_aMutex );
 764     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 765 }
 766 // -------------------------------------------------------------------------
 767 void SAL_CALL KabResultSet::updateTime(sal_Int32, const Time&) throw(SQLException, RuntimeException)
 768 {
 769     ::osl::MutexGuard aGuard( m_aMutex );
 770     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 771 }
 772 // -------------------------------------------------------------------------
 773 void SAL_CALL KabResultSet::updateTimestamp(sal_Int32, const DateTime&) throw(SQLException, RuntimeException)
 774 {
 775     ::osl::MutexGuard aGuard( m_aMutex );
 776     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 777 }
 778 // -------------------------------------------------------------------------
 779 void SAL_CALL KabResultSet::updateBinaryStream(sal_Int32, const Reference< XInputStream >&, sal_Int32) throw(SQLException, RuntimeException)
 780 {
 781     ::osl::MutexGuard aGuard( m_aMutex );
 782     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 783 }
 784 // -------------------------------------------------------------------------
 785 void SAL_CALL KabResultSet::updateCharacterStream(sal_Int32, const Reference< XInputStream >&, sal_Int32) throw(SQLException, RuntimeException)
 786 {
 787     ::osl::MutexGuard aGuard( m_aMutex );
 788     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 789 }
 790 // -------------------------------------------------------------------------
 791 void SAL_CALL KabResultSet::refreshRow() throw(SQLException, RuntimeException)
 792 {
 793     ::osl::MutexGuard aGuard( m_aMutex );
 794     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 795 }
 796 // -------------------------------------------------------------------------
 797 void SAL_CALL KabResultSet::updateObject(sal_Int32, const Any&) throw(SQLException, RuntimeException)
 798 {
 799     ::osl::MutexGuard aGuard( m_aMutex );
 800     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 801 }
 802 // -------------------------------------------------------------------------
 803 void SAL_CALL KabResultSet::updateNumericObject(sal_Int32, const Any&, sal_Int32) throw(SQLException, RuntimeException)
 804 {
 805     ::osl::MutexGuard aGuard( m_aMutex );
 806     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 807 }
 808 // -------------------------------------------------------------------------
 809 // XRowLocate
 810 Any SAL_CALL KabResultSet::getBookmark() throw( SQLException,  RuntimeException)
 811 {
 812     ::osl::MutexGuard aGuard( m_aMutex );
 813     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 814
 815         sal_Int32 nAddressees = m_aKabAddressees.size();
 816
 817         if (m_nRowPos != -1 && m_nRowPos != nAddressees)
 818         {
 819                 QString aQtName = m_aKabAddressees[m_nRowPos].uid();
 820                ::rtl::OUString sUniqueIdentifier = ::rtl::OUString((const sal_Unicode *) aQtName.ucs2());
 821         return makeAny(sUniqueIdentifier);
 822     }
 823     return Any();
 824 }
 825 // -------------------------------------------------------------------------
 826 sal_Bool SAL_CALL KabResultSet::moveToBookmark(const  Any& bookmark) throw( SQLException,  RuntimeException)
 827 {
 828     ::osl::MutexGuard aGuard( m_aMutex );
 829     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 830
 831     ::rtl::OUString sBookmark = comphelper::getString(bookmark);
 832         sal_Int32 nAddressees = m_aKabAddressees.size();
 833
 834     for (sal_Int32 nRow = 0; nRow < nAddressees; nRow++)
 835     {
 836                 QString aQtName = m_aKabAddressees[nRow].uid();
 837                ::rtl::OUString sUniqueIdentifier = ::rtl::OUString((const sal_Unicode *) aQtName.ucs2());
 838
 839         if (sUniqueIdentifier == sBookmark)
 840         {
 841             m_nRowPos = nRow;
 842             return sal_True;
 843         }
 844     }
 845     return sal_False;
 846 }
 847 // -------------------------------------------------------------------------
 848 sal_Bool SAL_CALL KabResultSet::moveRelativeToBookmark(const  Any& bookmark, sal_Int32 rows) throw( SQLException,  RuntimeException)
 849 {
 850     ::osl::MutexGuard aGuard( m_aMutex );
 851     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 852
 853     sal_Int32 nRowSave = m_nRowPos;
 854
 855     if (moveToBookmark(bookmark))
 856     {
 857         sal_Int32 nAddressees = m_aKabAddressees.size();
 858
 859         m_nRowPos += rows;
 860
 861         if (-1 < m_nRowPos && m_nRowPos < nAddressees)
 862             return sal_True;
 863     }
 864
 865     m_nRowPos = nRowSave;
 866     return sal_False;
 867 }
 868 // -------------------------------------------------------------------------
 869 sal_Int32 SAL_CALL KabResultSet::compareBookmarks(const  Any& firstItem, const  Any& secondItem) throw( SQLException,  RuntimeException)
 870 {
 871     ::osl::MutexGuard aGuard( m_aMutex );
 872     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 873
 874     ::rtl::OUString sFirst = comphelper::getString(firstItem);
 875     ::rtl::OUString sSecond = comphelper::getString(secondItem);
 876
 877     if (sFirst < sSecond)
 878         return CompareBookmark::LESS;
 879     if (sFirst > sSecond)
 880         return CompareBookmark::GREATER;
 881     return CompareBookmark::EQUAL;
 882 }
 883 // -------------------------------------------------------------------------
 884 sal_Bool SAL_CALL KabResultSet::hasOrderedBookmarks() throw( SQLException,  RuntimeException)
 885 {
 886     return sal_False;
 887 }
 888 // -------------------------------------------------------------------------
 889 sal_Int32 SAL_CALL KabResultSet::hashBookmark(const  Any& bookmark) throw( SQLException,  RuntimeException)
 890 {
 891     ::osl::MutexGuard aGuard( m_aMutex );
 892     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 893
 894     ::rtl::OUString sBookmark = comphelper::getString(bookmark);
 895
 896     return sBookmark.hashCode();
 897 }
 898 // -------------------------------------------------------------------------
 899 // XDeleteRows
 900 Sequence< sal_Int32 > SAL_CALL KabResultSet::deleteRows(const  Sequence<  Any >&) throw( SQLException,  RuntimeException)
 901 {
 902     ::osl::MutexGuard aGuard( m_aMutex );
 903     checkDisposed(KabResultSet_BASE::rBHelper.bDisposed);
 904
 905     return Sequence< sal_Int32 >();
 906 }
 907 // -------------------------------------------------------------------------
 908 IPropertyArrayHelper* KabResultSet::createArrayHelper() const
 909 {
 910     Sequence< Property > aProps(6);
 911     Property* pProperties = aProps.getArray();
 912     sal_Int32 nPos = 0;
 913     DECL_PROP1IMPL(CURSORNAME,                  ::rtl::OUString) PropertyAttribute::READONLY);
 914     DECL_PROP0(FETCHDIRECTION,                  sal_Int32);
 915     DECL_PROP0(FETCHSIZE,                               sal_Int32);
 916     DECL_BOOL_PROP1IMPL(ISBOOKMARKABLE) PropertyAttribute::READONLY);
 917     DECL_PROP1IMPL(RESULTSETCONCURRENCY,sal_Int32) PropertyAttribute::READONLY);
 918     DECL_PROP1IMPL(RESULTSETTYPE,               sal_Int32) PropertyAttribute::READONLY);
 919
 920     return new OPropertyArrayHelper(aProps);
 921 }
 922 // -------------------------------------------------------------------------
 923 IPropertyArrayHelper & KabResultSet::getInfoHelper()
 924 {
 925     return *static_cast<KabResultSet*>(this)->getArrayHelper();
 926 }
 927 // -------------------------------------------------------------------------
 928 sal_Bool KabResultSet::convertFastPropertyValue(
 929             Any &,
 930             Any &,
 931             sal_Int32 nHandle,
 932             const Any& )
 933                 throw (::com::sun::star::lang::IllegalArgumentException)
 934 {
 935     switch (nHandle)
 936     {
 937         case PROPERTY_ID_ISBOOKMARKABLE:
 938         case PROPERTY_ID_CURSORNAME:
 939         case PROPERTY_ID_RESULTSETCONCURRENCY:
 940         case PROPERTY_ID_RESULTSETTYPE:
 941             throw ::com::sun::star::lang::IllegalArgumentException();
 942             break;
 943         case PROPERTY_ID_FETCHDIRECTION:
 944         case PROPERTY_ID_FETCHSIZE:
 945         default:
 946             ;
 947     }
 948     return sal_False;
 949 }
 950 // -------------------------------------------------------------------------
 951 void KabResultSet::setFastPropertyValue_NoBroadcast(
 952             sal_Int32 nHandle,
 953             const Any& )
 954                  throw (Exception)
 955 {
 956     switch (nHandle)
 957     {
 958         case PROPERTY_ID_ISBOOKMARKABLE:
 959         case PROPERTY_ID_CURSORNAME:
 960         case PROPERTY_ID_RESULTSETCONCURRENCY:
 961         case PROPERTY_ID_RESULTSETTYPE:
 962             throw Exception();
 963             break;
 964         case PROPERTY_ID_FETCHDIRECTION:
 965             break;
 966         case PROPERTY_ID_FETCHSIZE:
 967             break;
 968         default:
 969             ;
 970     }
 971 }
 972 // -------------------------------------------------------------------------
 973 void KabResultSet::getFastPropertyValue(
 974             Any& _rValue,
 975             sal_Int32 nHandle) const
 976 {
 977     switch (nHandle)
 978     {
 979         case PROPERTY_ID_ISBOOKMARKABLE:
 980             _rValue <<= (sal_Bool)sal_False;
 981             break;
 982         case PROPERTY_ID_CURSORNAME:
 983         case PROPERTY_ID_RESULTSETCONCURRENCY:
 984         case PROPERTY_ID_RESULTSETTYPE:
 985         case PROPERTY_ID_FETCHDIRECTION:
 986         case PROPERTY_ID_FETCHSIZE:
 987             ;
 988     }
 989 }
 990 // -----------------------------------------------------------------------------