odk/examples/DevelopersGuide/Database/DriverSkeleton/SResultSet.cxx

   1 /*************************************************************************
   2  *
   3  *  $RCSfile: SResultSet.cxx,v $
   4  *
   5  *  $Revision: 1.7 $
   6  *
   7  *  last change: $Author: rt $ $Date: 2008-04-10 16:35:24 $
   8  *
   9  *  The Contents of this file are made available subject to the terms of
  10  *  the BSD license.
  11  *
  12  *  Copyright (c) 2003 by Sun Microsystems, Inc.
  13  *  All rights reserved.
  14  *
  15  *  Redistribution and use in source and binary forms, with or without
  16  *  modification, are permitted provided that the following conditions
  17  *  are met:
  18  *  1. Redistributions of source code must retain the above copyright
  19  *     notice, this list of conditions and the following disclaimer.
  20  *  2. Redistributions in binary form must reproduce the above copyright
  21  *     notice, this list of conditions and the following disclaimer in the
  22  *     documentation and/or other materials provided with the distribution.
  23  *  3. Neither the name of Sun Microsystems, Inc. nor the names of its
  24  *     contributors may be used to endorse or promote products derived
  25  *     from this software without specific prior written permission.
  26  *
  27  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  28  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  29  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  30  *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  31  *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  32  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  33  *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  34  *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  35  *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  36  *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  37  *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  38  *
  39  *************************************************************************/
  40
  41 #include "SResultSet.hxx"
  42 #include "SResultSetMetaData.hxx"
  43 #include <com/sun/star/sdbc/DataType.hpp>
  44 #include <com/sun/star/beans/PropertyAttribute.hpp>
  45 #include <com/sun/star/sdbcx/CompareBookmark.hpp>
  46 #include <cppuhelper/typeprovider.hxx>
  47 #include <com/sun/star/lang/DisposedException.hpp>
  48 #include "propertyids.hxx"
  49
  50 using namespace connectivity::skeleton;
  51 using namespace cppu;
  52 using namespace com::sun::star::uno;
  53 using namespace com::sun::star::lang;
  54 using namespace com::sun::star::beans;
  55 using namespace com::sun::star::sdbc;
  56 using namespace com::sun::star::sdbcx;
  57 using namespace com::sun::star::container;
  58 using namespace com::sun::star::io;
  59 using namespace com::sun::star::util;
  60
  61 //------------------------------------------------------------------------------
  62 //      IMPLEMENT_SERVICE_INFO(OResultSet,"com.sun.star.sdbcx.OResultSet","com.sun.star.sdbc.ResultSet");
  63 ::rtl::OUString SAL_CALL OResultSet::getImplementationName(  ) throw ( RuntimeException)        \
  64 {
  65     return ::rtl::OUString::createFromAscii("com.sun.star.sdbcx.skeleton.ResultSet");
  66 }
  67 // -------------------------------------------------------------------------
  68  Sequence< ::rtl::OUString > SAL_CALL OResultSet::getSupportedServiceNames(  ) throw( RuntimeException)
  69 {
  70      Sequence< ::rtl::OUString > aSupported(2);
  71     aSupported[0] = ::rtl::OUString::createFromAscii("com.sun.star.sdbc.ResultSet");
  72     aSupported[1] = ::rtl::OUString::createFromAscii("com.sun.star.sdbcx.ResultSet");
  73     return aSupported;
  74 }
  75 // -------------------------------------------------------------------------
  76 sal_Bool SAL_CALL OResultSet::supportsService( const ::rtl::OUString& _rServiceName ) throw( RuntimeException)
  77 {
  78     Sequence< ::rtl::OUString > aSupported(getSupportedServiceNames());
  79     const ::rtl::OUString* pSupported = aSupported.getConstArray();
  80     const ::rtl::OUString* pEnd = pSupported + aSupported.getLength();
  81     for (;pSupported != pEnd && !pSupported->equals(_rServiceName); ++pSupported)
  82         ;
  83
  84     return pSupported != pEnd;
  85 }
  86
  87 // -------------------------------------------------------------------------
  88 OResultSet::OResultSet(OStatement_Base* pStmt)
  89     : OResultSet_BASE(m_aMutex)
  90     ,OPropertySetHelper(OResultSet_BASE::rBHelper)
  91     ,m_aStatement((OWeakObject*)pStmt)
  92     ,m_xMetaData(NULL)
  93     ,m_nTextEncoding(pStmt->getOwnConnection()->getTextEncoding())
  94     ,m_pStatement(pStmt)
  95     ,m_bWasNull(sal_True)
  96 {
  97 }
  98 // -------------------------------------------------------------------------
  99 OResultSet::~OResultSet()
 100 {
 101 }
 102 // -------------------------------------------------------------------------
 103 void OResultSet::disposing(void)
 104 {
 105     OPropertySetHelper::disposing();
 106
 107     ::osl::MutexGuard aGuard(m_aMutex);
 108
 109     m_aStatement        = NULL;
 110     m_xMetaData         = NULL;
 111 }
 112 // -------------------------------------------------------------------------
 113 Any SAL_CALL OResultSet::queryInterface( const Type & rType ) throw(RuntimeException)
 114 {
 115     Any aRet = OPropertySetHelper::queryInterface(rType);
 116     if(!aRet.hasValue())
 117         aRet = OResultSet_BASE::queryInterface(rType);
 118     return aRet;
 119 }
 120 // -------------------------------------------------------------------------
 121  Sequence<  Type > SAL_CALL OResultSet::getTypes(  ) throw( RuntimeException)
 122 {
 123     OTypeCollection aTypes(
 124         ::cppu::UnoType< Reference< ::com::sun::star::beans::XMultiPropertySet > >::get(),
 125         ::cppu::UnoType< Reference< ::com::sun::star::beans::XFastPropertySet > >::get(),
 126         ::cppu::UnoType< Reference< ::com::sun::star::beans::XPropertySet > >::get());
 127
 128     return concatSequences(aTypes.getTypes(),OResultSet_BASE::getTypes());
 129 }
 130 // -------------------------------------------------------------------------
 131
 132 sal_Int32 SAL_CALL OResultSet::findColumn( const ::rtl::OUString& columnName ) throw(SQLException, RuntimeException)
 133 {
 134
 135     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 136
 137     // find the first column with the name columnName
 138
 139     ::osl::MutexGuard aGuard( m_aMutex );
 140
 141     Reference< XResultSetMetaData > xMeta = getMetaData();
 142     sal_Int32 nLen = xMeta->getColumnCount();
 143     sal_Int32 i = 1;
 144     for(;i<=nLen;++i)
 145         if(xMeta->isCaseSensitive(i) ? columnName == xMeta->getColumnName(i) :
 146                 columnName.equalsIgnoreAsciiCase(xMeta->getColumnName(i)))
 147             break;
 148     return i;
 149 }
 150 // -------------------------------------------------------------------------
 151 Reference< XInputStream > SAL_CALL OResultSet::getBinaryStream( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 152 {
 153     ::osl::MutexGuard aGuard( m_aMutex );
 154     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 155
 156
 157     return NULL;
 158 }
 159 // -------------------------------------------------------------------------
 160 Reference< XInputStream > SAL_CALL OResultSet::getCharacterStream( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 161 {
 162     ::osl::MutexGuard aGuard( m_aMutex );
 163     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 164
 165
 166     return NULL;
 167 }
 168
 169 // -------------------------------------------------------------------------
 170 sal_Bool SAL_CALL OResultSet::getBoolean( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 171 {
 172     ::osl::MutexGuard aGuard( m_aMutex );
 173     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 174
 175     return sal_False;
 176 }
 177 // -------------------------------------------------------------------------
 178
 179 sal_Int8 SAL_CALL OResultSet::getByte( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 180 {
 181     ::osl::MutexGuard aGuard( m_aMutex );
 182     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 183
 184
 185     sal_Int8 nRet = 0;
 186     return nRet;
 187 }
 188 // -------------------------------------------------------------------------
 189
 190 Sequence< sal_Int8 > SAL_CALL OResultSet::getBytes( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 191 {
 192
 193     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 194     ::osl::MutexGuard aGuard( m_aMutex );
 195
 196     return Sequence< sal_Int8 >();
 197 }
 198 // -------------------------------------------------------------------------
 199
 200 Date SAL_CALL OResultSet::getDate( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 201 {
 202     ::osl::MutexGuard aGuard( m_aMutex );
 203     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 204
 205
 206     Date nRet;
 207     return nRet;
 208 }
 209 // -------------------------------------------------------------------------
 210
 211 double SAL_CALL OResultSet::getDouble( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 212 {
 213     ::osl::MutexGuard aGuard( m_aMutex );
 214     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 215
 216
 217     double nRet = 0;
 218     return nRet;
 219 }
 220 // -------------------------------------------------------------------------
 221
 222 float SAL_CALL OResultSet::getFloat( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 223 {
 224     ::osl::MutexGuard aGuard( m_aMutex );
 225     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 226
 227
 228     float nVal(0);
 229     return nVal;
 230 }
 231 // -------------------------------------------------------------------------
 232
 233 sal_Int32 SAL_CALL OResultSet::getInt( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 234 {
 235     ::osl::MutexGuard aGuard( m_aMutex );
 236     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 237
 238     sal_Int32 nRet=0;
 239     return nRet;
 240 }
 241 // -------------------------------------------------------------------------
 242
 243 sal_Int32 SAL_CALL OResultSet::getRow(  ) throw(SQLException, RuntimeException)
 244 {
 245     ::osl::MutexGuard aGuard( m_aMutex );
 246     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 247
 248     sal_Int32 nValue = 0;
 249     return nValue;
 250 }
 251 // -------------------------------------------------------------------------
 252
 253 sal_Int64 SAL_CALL OResultSet::getLong( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 254 {
 255     ::osl::MutexGuard aGuard( m_aMutex );
 256     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 257
 258     return sal_Int64();
 259 }
 260 // -------------------------------------------------------------------------
 261
 262 Reference< XResultSetMetaData > SAL_CALL OResultSet::getMetaData(  ) throw(SQLException, RuntimeException)
 263 {
 264     ::osl::MutexGuard aGuard( m_aMutex );
 265     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 266
 267
 268     if(!m_xMetaData.is())
 269         m_xMetaData = new OResultSetMetaData(m_pStatement->getOwnConnection());
 270     return m_xMetaData;
 271 }
 272 // -------------------------------------------------------------------------
 273 Reference< XArray > SAL_CALL OResultSet::getArray( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 274 {
 275     ::osl::MutexGuard aGuard( m_aMutex );
 276     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 277
 278     return NULL;
 279 }
 280
 281 // -------------------------------------------------------------------------
 282
 283 Reference< XClob > SAL_CALL OResultSet::getClob( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 284 {
 285     ::osl::MutexGuard aGuard( m_aMutex );
 286     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 287
 288     return NULL;
 289 }
 290 // -------------------------------------------------------------------------
 291 Reference< XBlob > SAL_CALL OResultSet::getBlob( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 292 {
 293     ::osl::MutexGuard aGuard( m_aMutex );
 294     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 295
 296     return NULL;
 297 }
 298 // -------------------------------------------------------------------------
 299
 300 Reference< XRef > SAL_CALL OResultSet::getRef( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 301 {
 302     ::osl::MutexGuard aGuard( m_aMutex );
 303     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 304
 305     return NULL;
 306 }
 307 // -------------------------------------------------------------------------
 308
 309 Any SAL_CALL OResultSet::getObject( sal_Int32 columnIndex, const Reference< ::com::sun::star::container::XNameAccess >& typeMap ) throw(SQLException, RuntimeException)
 310 {
 311     ::osl::MutexGuard aGuard( m_aMutex );
 312     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 313
 314     return Any();
 315 }
 316 // -------------------------------------------------------------------------
 317
 318 sal_Int16 SAL_CALL OResultSet::getShort( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 319 {
 320     ::osl::MutexGuard aGuard( m_aMutex );
 321     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 322
 323
 324     sal_Int16 nRet=0;
 325     return nRet;
 326 }
 327 // -------------------------------------------------------------------------
 328
 329
 330 ::rtl::OUString SAL_CALL OResultSet::getString( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 331 {
 332     ::osl::MutexGuard aGuard( m_aMutex );
 333     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 334
 335
 336     ::rtl::OUString nRet;
 337     return nRet;
 338 }
 339 // -------------------------------------------------------------------------
 340
 341 Time SAL_CALL OResultSet::getTime( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 342 {
 343     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 344
 345     ::osl::MutexGuard aGuard( m_aMutex );
 346
 347     Time nRet;
 348     return nRet;
 349 }
 350 // -------------------------------------------------------------------------
 351
 352
 353 DateTime SAL_CALL OResultSet::getTimestamp( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 354 {
 355     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 356
 357
 358     ::osl::MutexGuard aGuard( m_aMutex );
 359
 360     DateTime nRet;
 361     return nRet;
 362 }
 363 // -------------------------------------------------------------------------
 364
 365 sal_Bool SAL_CALL OResultSet::isBeforeFirst(  ) throw(SQLException, RuntimeException)
 366 {
 367     ::osl::MutexGuard aGuard( m_aMutex );
 368     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 369
 370
 371     // here you have to implement your movements
 372     // return true means there is no data
 373     return sal_True;
 374 }
 375 // -------------------------------------------------------------------------
 376 sal_Bool SAL_CALL OResultSet::isAfterLast(  ) throw(SQLException, RuntimeException)
 377 {
 378     ::osl::MutexGuard aGuard( m_aMutex );
 379     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 380
 381     return sal_True;
 382 }
 383 // -------------------------------------------------------------------------
 384 sal_Bool SAL_CALL OResultSet::isFirst(  ) throw(SQLException, RuntimeException)
 385 {
 386     ::osl::MutexGuard aGuard( m_aMutex );
 387     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 388
 389
 390     return sal_False;
 391 }
 392 // -------------------------------------------------------------------------
 393 sal_Bool SAL_CALL OResultSet::isLast(  ) throw(SQLException, RuntimeException)
 394 {
 395     ::osl::MutexGuard aGuard( m_aMutex );
 396     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 397
 398
 399     return sal_False;
 400 }
 401 // -------------------------------------------------------------------------
 402 void SAL_CALL OResultSet::beforeFirst(  ) throw(SQLException, RuntimeException)
 403 {
 404     ::osl::MutexGuard aGuard( m_aMutex );
 405     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 406
 407     // move before the first row so that isBeforeFirst returns false
 408     // the smae for other movement methods
 409 }
 410 // -------------------------------------------------------------------------
 411 void SAL_CALL OResultSet::afterLast(  ) throw(SQLException, RuntimeException)
 412 {
 413     ::osl::MutexGuard aGuard( m_aMutex );
 414     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 415 }
 416 // -------------------------------------------------------------------------
 417
 418 void SAL_CALL OResultSet::close(  ) throw(SQLException, RuntimeException)
 419 {
 420     {
 421         ::osl::MutexGuard aGuard( m_aMutex );
 422         checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 423
 424     }
 425     dispose();
 426 }
 427 // -------------------------------------------------------------------------
 428
 429 sal_Bool SAL_CALL OResultSet::first(  ) throw(SQLException, RuntimeException)
 430 {
 431     ::osl::MutexGuard aGuard( m_aMutex );
 432     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 433
 434     return sal_False;
 435 }
 436 // -------------------------------------------------------------------------
 437
 438 sal_Bool SAL_CALL OResultSet::last(  ) throw(SQLException, RuntimeException)
 439 {
 440     ::osl::MutexGuard aGuard( m_aMutex );
 441     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 442
 443     return sal_False;
 444 }
 445 // -------------------------------------------------------------------------
 446 sal_Bool SAL_CALL OResultSet::absolute( sal_Int32 row ) throw(SQLException, RuntimeException)
 447 {
 448     ::osl::MutexGuard aGuard( m_aMutex );
 449     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 450
 451     return sal_False;
 452 }
 453 // -------------------------------------------------------------------------
 454 sal_Bool SAL_CALL OResultSet::relative( sal_Int32 row ) throw(SQLException, RuntimeException)
 455 {
 456     ::osl::MutexGuard aGuard( m_aMutex );
 457     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 458
 459     return sal_False;
 460 }
 461 // -------------------------------------------------------------------------
 462 sal_Bool SAL_CALL OResultSet::previous(  ) throw(SQLException, RuntimeException)
 463 {
 464     ::osl::MutexGuard aGuard( m_aMutex );
 465     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 466
 467     return sal_False;
 468 }
 469 // -------------------------------------------------------------------------
 470 Reference< XInterface > SAL_CALL OResultSet::getStatement(  ) throw(SQLException, RuntimeException)
 471 {
 472     ::osl::MutexGuard aGuard( m_aMutex );
 473     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 474
 475
 476     return m_aStatement.get();
 477 }
 478 // -------------------------------------------------------------------------
 479
 480 sal_Bool SAL_CALL OResultSet::rowDeleted(  ) throw(SQLException, RuntimeException)
 481 {
 482     ::osl::MutexGuard aGuard( m_aMutex );
 483     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 484
 485
 486     return sal_False;
 487 }
 488 // -------------------------------------------------------------------------
 489 sal_Bool SAL_CALL OResultSet::rowInserted(  ) throw(SQLException, RuntimeException)
 490 {
 491     ::osl::MutexGuard aGuard( m_aMutex );
 492     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 493
 494
 495     return sal_False;
 496 }
 497 // -------------------------------------------------------------------------
 498 sal_Bool SAL_CALL OResultSet::rowUpdated(  ) throw(SQLException, RuntimeException)
 499 {
 500     ::osl::MutexGuard aGuard( m_aMutex );
 501     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 502
 503
 504     return sal_False;
 505 }
 506 // -------------------------------------------------------------------------
 507
 508 sal_Bool SAL_CALL OResultSet::next(  ) throw(SQLException, RuntimeException)
 509 {
 510     ::osl::MutexGuard aGuard( m_aMutex );
 511     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 512
 513
 514     return sal_False;
 515 }
 516 // -------------------------------------------------------------------------
 517
 518 sal_Bool SAL_CALL OResultSet::wasNull(  ) throw(SQLException, RuntimeException)
 519 {
 520     ::osl::MutexGuard aGuard( m_aMutex );
 521     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 522
 523
 524     return m_bWasNull;
 525 }
 526 // -------------------------------------------------------------------------
 527
 528 void SAL_CALL OResultSet::cancel(  ) throw(RuntimeException)
 529 {
 530     ::osl::MutexGuard aGuard( m_aMutex );
 531     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 532
 533 }
 534 // -------------------------------------------------------------------------
 535 void SAL_CALL OResultSet::clearWarnings(  ) throw(SQLException, RuntimeException)
 536 {
 537 }
 538 // -------------------------------------------------------------------------
 539 Any SAL_CALL OResultSet::getWarnings(  ) throw(SQLException, RuntimeException)
 540 {
 541     return Any();
 542 }
 543 // -------------------------------------------------------------------------
 544 void SAL_CALL OResultSet::insertRow(  ) throw(SQLException, RuntimeException)
 545 {
 546     ::osl::MutexGuard aGuard( m_aMutex );
 547     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 548
 549     // you only have to implement this if you want to insert new rows
 550 }
 551 // -------------------------------------------------------------------------
 552 void SAL_CALL OResultSet::updateRow(  ) throw(SQLException, RuntimeException)
 553 {
 554     ::osl::MutexGuard aGuard( m_aMutex );
 555     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 556
 557
 558     // only when you allow updates
 559 }
 560 // -------------------------------------------------------------------------
 561 void SAL_CALL OResultSet::deleteRow(  ) throw(SQLException, RuntimeException)
 562 {
 563     ::osl::MutexGuard aGuard( m_aMutex );
 564     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 565 }
 566 // -------------------------------------------------------------------------
 567
 568 void SAL_CALL OResultSet::cancelRowUpdates(  ) throw(SQLException, RuntimeException)
 569 {
 570     ::osl::MutexGuard aGuard( m_aMutex );
 571     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 572 }
 573 // -------------------------------------------------------------------------
 574
 575 void SAL_CALL OResultSet::moveToInsertRow(  ) throw(SQLException, RuntimeException)
 576 {
 577     ::osl::MutexGuard aGuard( m_aMutex );
 578     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 579
 580
 581     // only when you allow insert's
 582 }
 583 // -------------------------------------------------------------------------
 584
 585 void SAL_CALL OResultSet::moveToCurrentRow(  ) throw(SQLException, RuntimeException)
 586 {
 587     ::osl::MutexGuard aGuard( m_aMutex );
 588     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 589 }
 590 // -------------------------------------------------------------------------
 591
 592 void SAL_CALL OResultSet::updateNull( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
 593 {
 594     ::osl::MutexGuard aGuard( m_aMutex );
 595     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 596 }
 597 // -------------------------------------------------------------------------
 598
 599 void SAL_CALL OResultSet::updateBoolean( sal_Int32 columnIndex, sal_Bool x ) throw(SQLException, RuntimeException)
 600 {
 601     ::osl::MutexGuard aGuard( m_aMutex );
 602     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 603
 604 }
 605 // -------------------------------------------------------------------------
 606 void SAL_CALL OResultSet::updateByte( sal_Int32 columnIndex, sal_Int8 x ) throw(SQLException, RuntimeException)
 607 {
 608     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 609     ::osl::MutexGuard aGuard( m_aMutex );
 610
 611 }
 612 // -------------------------------------------------------------------------
 613
 614 void SAL_CALL OResultSet::updateShort( sal_Int32 columnIndex, sal_Int16 x ) throw(SQLException, RuntimeException)
 615 {
 616     ::osl::MutexGuard aGuard( m_aMutex );
 617     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 618
 619 }
 620 // -------------------------------------------------------------------------
 621 void SAL_CALL OResultSet::updateInt( sal_Int32 columnIndex, sal_Int32 x ) throw(SQLException, RuntimeException)
 622 {
 623     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 624     ::osl::MutexGuard aGuard( m_aMutex );
 625
 626 }
 627 // -------------------------------------------------------------------------
 628 void SAL_CALL OResultSet::updateLong( sal_Int32 columnIndex, sal_Int64 x ) throw(SQLException, RuntimeException)
 629 {
 630     ::osl::MutexGuard aGuard( m_aMutex );
 631     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 632
 633 }
 634 // -----------------------------------------------------------------------
 635 void SAL_CALL OResultSet::updateFloat( sal_Int32 columnIndex, float x ) throw(SQLException, RuntimeException)
 636 {
 637     ::osl::MutexGuard aGuard( m_aMutex );
 638     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 639
 640 }
 641 // -------------------------------------------------------------------------
 642
 643 void SAL_CALL OResultSet::updateDouble( sal_Int32 columnIndex, double x ) throw(SQLException, RuntimeException)
 644 {
 645     ::osl::MutexGuard aGuard( m_aMutex );
 646     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 647
 648 }
 649 // -------------------------------------------------------------------------
 650 void SAL_CALL OResultSet::updateString( sal_Int32 columnIndex, const ::rtl::OUString& x ) throw(SQLException, RuntimeException)
 651 {
 652     ::osl::MutexGuard aGuard( m_aMutex );
 653     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 654
 655 }
 656 // -------------------------------------------------------------------------
 657 void SAL_CALL OResultSet::updateBytes( sal_Int32 columnIndex, const Sequence< sal_Int8 >& x ) throw(SQLException, RuntimeException)
 658 {
 659     ::osl::MutexGuard aGuard( m_aMutex );
 660     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 661
 662 }
 663 // -------------------------------------------------------------------------
 664 void SAL_CALL OResultSet::updateDate( sal_Int32 columnIndex, const Date& x ) throw(SQLException, RuntimeException)
 665 {
 666     ::osl::MutexGuard aGuard( m_aMutex );
 667     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 668
 669 }
 670 // -------------------------------------------------------------------------
 671
 672 void SAL_CALL OResultSet::updateTime( sal_Int32 columnIndex, const Time& x ) throw(SQLException, RuntimeException)
 673 {
 674     ::osl::MutexGuard aGuard( m_aMutex );
 675     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 676
 677 }
 678 // -------------------------------------------------------------------------
 679
 680 void SAL_CALL OResultSet::updateTimestamp( sal_Int32 columnIndex, const DateTime& x ) throw(SQLException, RuntimeException)
 681 {
 682     ::osl::MutexGuard aGuard( m_aMutex );
 683     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 684
 685 }
 686 // -------------------------------------------------------------------------
 687
 688 void SAL_CALL OResultSet::updateBinaryStream( sal_Int32 columnIndex, const Reference< XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
 689 {
 690     ::osl::MutexGuard aGuard( m_aMutex );
 691     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 692
 693 }
 694 // -------------------------------------------------------------------------
 695 void SAL_CALL OResultSet::updateCharacterStream( sal_Int32 columnIndex, const Reference< XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
 696 {
 697     ::osl::MutexGuard aGuard( m_aMutex );
 698     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 699
 700 }
 701 // -------------------------------------------------------------------------
 702 void SAL_CALL OResultSet::refreshRow(  ) throw(SQLException, RuntimeException)
 703 {
 704     ::osl::MutexGuard aGuard( m_aMutex );
 705     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 706
 707 }
 708 // -------------------------------------------------------------------------
 709 void SAL_CALL OResultSet::updateObject( sal_Int32 columnIndex, const Any& x ) throw(SQLException, RuntimeException)
 710 {
 711     ::osl::MutexGuard aGuard( m_aMutex );
 712     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 713
 714 }
 715 // -------------------------------------------------------------------------
 716
 717 void SAL_CALL OResultSet::updateNumericObject( sal_Int32 columnIndex, const Any& x, sal_Int32 scale ) throw(SQLException, RuntimeException)
 718 {
 719     ::osl::MutexGuard aGuard( m_aMutex );
 720     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 721
 722 }
 723 // -------------------------------------------------------------------------
 724 // XRowLocate
 725 Any SAL_CALL OResultSet::getBookmark(  ) throw( SQLException,  RuntimeException)
 726 {
 727      ::osl::MutexGuard aGuard( m_aMutex );
 728     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 729
 730     // if you don't want to support bookmark you must remove the XRowLocate interface
 731
 732      return Any();
 733 }
 734 // -------------------------------------------------------------------------
 735 sal_Bool SAL_CALL OResultSet::moveToBookmark( const  Any& bookmark ) throw( SQLException,  RuntimeException)
 736 {
 737     ::osl::MutexGuard aGuard( m_aMutex );
 738     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 739
 740     return sal_False;
 741 }
 742 // -------------------------------------------------------------------------
 743 sal_Bool SAL_CALL OResultSet::moveRelativeToBookmark( const  Any& bookmark, sal_Int32 rows ) throw( SQLException,  RuntimeException)
 744 {
 745     ::osl::MutexGuard aGuard( m_aMutex );
 746     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 747
 748     return sal_False;
 749 }
 750 // -------------------------------------------------------------------------
 751 sal_Int32 SAL_CALL OResultSet::compareBookmarks( const  Any& first, const  Any& second ) throw( SQLException,  RuntimeException)
 752 {
 753     ::osl::MutexGuard aGuard( m_aMutex );
 754     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 755
 756
 757     return CompareBookmark::NOT_EQUAL;
 758 }
 759 // -------------------------------------------------------------------------
 760 sal_Bool SAL_CALL OResultSet::hasOrderedBookmarks(  ) throw( SQLException,  RuntimeException)
 761 {
 762     return sal_False;
 763 }
 764 // -------------------------------------------------------------------------
 765 sal_Int32 SAL_CALL OResultSet::hashBookmark( const  Any& bookmark ) throw( SQLException,  RuntimeException)
 766 {
 767     throw SQLException();
 768 }
 769 // -------------------------------------------------------------------------
 770 // XDeleteRows
 771 Sequence< sal_Int32 > SAL_CALL OResultSet::deleteRows( const  Sequence<  Any >& rows ) throw( SQLException,  RuntimeException)
 772 {
 773     ::osl::MutexGuard aGuard( m_aMutex );
 774     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
 775
 776     return Sequence< sal_Int32 >();
 777 }
 778 // -------------------------------------------------------------------------
 779 IPropertyArrayHelper* OResultSet::createArrayHelper( ) const
 780 {
 781     Sequence< Property > aProps(6);
 782     Property* pProperties = aProps.getArray();
 783     sal_Int32 nPos = 0;
 784     DECL_PROP1IMPL(CURSORNAME,                  ::rtl::OUString) PropertyAttribute::READONLY);
 785     DECL_PROP0(FETCHDIRECTION,                  sal_Int32);
 786     DECL_PROP0(FETCHSIZE,                               sal_Int32);
 787     DECL_BOOL_PROP1IMPL(ISBOOKMARKABLE) PropertyAttribute::READONLY);
 788     DECL_PROP1IMPL(RESULTSETCONCURRENCY,sal_Int32) PropertyAttribute::READONLY);
 789     DECL_PROP1IMPL(RESULTSETTYPE,               sal_Int32) PropertyAttribute::READONLY);
 790
 791     return new OPropertyArrayHelper(aProps);
 792 }
 793 // -------------------------------------------------------------------------
 794 IPropertyArrayHelper & OResultSet::getInfoHelper()
 795 {
 796     return *const_cast<OResultSet*>(this)->getArrayHelper();
 797 }
 798 // -------------------------------------------------------------------------
 799 sal_Bool OResultSet::convertFastPropertyValue(
 800                             Any & rConvertedValue,
 801                             Any & rOldValue,
 802                             sal_Int32 nHandle,
 803                             const Any& rValue )
 804                                 throw (::com::sun::star::lang::IllegalArgumentException)
 805 {
 806     switch(nHandle)
 807     {
 808         case PROPERTY_ID_ISBOOKMARKABLE:
 809         case PROPERTY_ID_CURSORNAME:
 810         case PROPERTY_ID_RESULTSETCONCURRENCY:
 811         case PROPERTY_ID_RESULTSETTYPE:
 812             throw ::com::sun::star::lang::IllegalArgumentException();
 813             break;
 814         case PROPERTY_ID_FETCHDIRECTION:
 815         case PROPERTY_ID_FETCHSIZE:
 816         default:
 817             ;
 818     }
 819     return sal_False;
 820 }
 821 // -------------------------------------------------------------------------
 822 void OResultSet::setFastPropertyValue_NoBroadcast(
 823                                 sal_Int32 nHandle,
 824                                 const Any& rValue
 825                                                  )
 826                                                  throw (Exception)
 827 {
 828     switch(nHandle)
 829     {
 830         case PROPERTY_ID_ISBOOKMARKABLE:
 831         case PROPERTY_ID_CURSORNAME:
 832         case PROPERTY_ID_RESULTSETCONCURRENCY:
 833         case PROPERTY_ID_RESULTSETTYPE:
 834             throw Exception();
 835             break;
 836         case PROPERTY_ID_FETCHDIRECTION:
 837             break;
 838         case PROPERTY_ID_FETCHSIZE:
 839             break;
 840         default:
 841             ;
 842     }
 843 }
 844 // -------------------------------------------------------------------------
 845 void OResultSet::getFastPropertyValue(
 846                                 Any& rValue,
 847                                 sal_Int32 nHandle
 848                                      ) const
 849 {
 850     switch(nHandle)
 851     {
 852         case PROPERTY_ID_ISBOOKMARKABLE:
 853         case PROPERTY_ID_CURSORNAME:
 854         case PROPERTY_ID_RESULTSETCONCURRENCY:
 855         case PROPERTY_ID_RESULTSETTYPE:
 856         case PROPERTY_ID_FETCHDIRECTION:
 857         case PROPERTY_ID_FETCHSIZE:
 858             ;
 859     }
 860 }
 861 // -----------------------------------------------------------------------------
 862 void SAL_CALL OResultSet::acquire() throw()
 863 {
 864     OResultSet_BASE::acquire();
 865 }
 866 // -----------------------------------------------------------------------------
 867 void SAL_CALL OResultSet::release() throw()
 868 {
 869     OResultSet_BASE::release();
 870 }
 871 // -----------------------------------------------------------------------------
 872 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL OResultSet::getPropertySetInfo(  ) throw(::com::sun::star::uno::RuntimeException)
 873 {
 874     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 875 }
 876 // -----------------------------------------------------------------------------
 877
 878
 879