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

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