connectivity/source/drivers/postgresql/pq_baseresultset.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  *  Effective License of whole file:
   5  *
   6  *    This library is free software; you can redistribute it and/or
   7  *    modify it under the terms of the GNU Lesser General Public
   8  *    License version 2.1, as published by the Free Software Foundation.
   9  *
  10  *    This library is distributed in the hope that it will be useful,
  11  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *    Lesser General Public License for more details.
  14  *
  15  *    You should have received a copy of the GNU Lesser General Public
  16  *    License along with this library; if not, write to the Free Software
  17  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  18  *    MA  02111-1307  USA
  19  *
  20  *  Parts "Copyright by Sun Microsystems, Inc" prior to August 2011:
  21  *
  22  *    The Contents of this file are made available subject to the terms of
  23  *    the GNU Lesser General Public License Version 2.1
  24  *
  25  *    Copyright: 2000 by Sun Microsystems, Inc.
  26  *
  27  *    Contributor(s): Joerg Budischewski
  28  *
  29  *  All parts contributed on or after August 2011:
  30  *
  31  *    This Source Code Form is subject to the terms of the Mozilla Public
  32  *    License, v. 2.0. If a copy of the MPL was not distributed with this
  33  *    file, You can obtain one at http://mozilla.org/MPL/2.0/.
  34  *
  35  ************************************************************************/
  36
  37 #include <osl/thread.h>
  38
  39 #include <rtl/ustrbuf.hxx>
  40
  41 #include <cppuhelper/typeprovider.hxx>
  42 #include <cppuhelper/queryinterface.hxx>
  43
  44 #include "pq_tools.hxx"
  45 #include "pq_array.hxx"
  46 #include "pq_statement.hxx"
  47 #include "pq_baseresultset.hxx"
  48 #include "pq_resultsetmetadata.hxx"
  49
  50 #include <com/sun/star/lang/DisposedException.hpp>
  51
  52 #include <connectivity/dbconversion.hxx>
  53
  54 using osl::Mutex;
  55 using osl::MutexGuard;
  56
  57
  58 using com::sun::star::beans::XPropertySetInfo;
  59 using com::sun::star::beans::XPropertySet;
  60 using com::sun::star::beans::XMultiPropertySet;
  61 using com::sun::star::beans::XFastPropertySet;
  62
  63 using com::sun::star::uno::Any;
  64 using com::sun::star::uno::makeAny;
  65 using com::sun::star::uno::Type;
  66 using com::sun::star::uno::RuntimeException;
  67 using com::sun::star::uno::Exception;
  68 using com::sun::star::uno::Sequence;
  69 using com::sun::star::uno::Reference;
  70 using com::sun::star::uno::XInterface;
  71
  72 using com::sun::star::lang::IllegalArgumentException;
  73
  74 using com::sun::star::sdbc::XWarningsSupplier;
  75 using com::sun::star::sdbc::XCloseable;
  76 using com::sun::star::sdbc::XStatement;
  77 using com::sun::star::sdbc::XResultSet;
  78 using com::sun::star::sdbc::XConnection;
  79 using com::sun::star::sdbc::SQLException;
  80 using com::sun::star::sdbc::XRow;
  81 using com::sun::star::sdbc::XColumnLocate;
  82 using com::sun::star::sdbc::XResultSetMetaData;
  83 using com::sun::star::sdbc::XResultSetMetaDataSupplier;
  84
  85
  86 using com::sun::star::beans::Property;
  87
  88 using namespace dbtools;
  89
  90 namespace pq_sdbc_driver
  91 {
  92 static ::cppu::IPropertyArrayHelper & getResultSetPropertyArrayHelper()
  93 {
  94     static ::cppu::IPropertyArrayHelper *pArrayHelper;
  95     if( ! pArrayHelper )
  96     {
  97         MutexGuard guard( Mutex::getGlobalMutex() );
  98         if( ! pArrayHelper )
  99         {
 100             static Property aTable[] =
 101                 {
 102                     // LEM TODO: this needs to be kept in sync with other, e.g. pq_statics.css:508
 103                     // Should really share!
 104                     // At least use for the handles the #define'd values in .hxx file...
 105                     Property(
 106                         OUString("CursorName"), 0,
 107                         ::cppu::UnoType<OUString>::get() , 0 ),
 108                     Property(
 109                         OUString("EscapeProcessing"), 1,
 110                         ::getBooleanCppuType() , 0 ),
 111                     Property(
 112                         OUString("FetchDirection"), 2,
 113                         ::cppu::UnoType<sal_Int32>::get() , 0 ),
 114                     Property(
 115                         OUString("FetchSize"), 3,
 116                         ::cppu::UnoType<sal_Int32>::get() , 0 ),
 117                     Property(
 118                         OUString("IsBookmarkable"), 4,
 119                         ::getBooleanCppuType() , 0 ),
 120                     Property(
 121                         OUString("ResultSetConcurrency"), 5,
 122                         ::cppu::UnoType<sal_Int32>::get() , 0 ),
 123                     Property(
 124                         OUString("ResultSetType"), 6,
 125                         ::cppu::UnoType<sal_Int32>::get() , 0 )
 126                 };
 127             OSL_ASSERT( sizeof(aTable) / sizeof(Property) == BASERESULTSET_SIZE );
 128             static ::cppu::OPropertyArrayHelper arrayHelper( aTable, BASERESULTSET_SIZE, sal_True );
 129             pArrayHelper = &arrayHelper;
 130         }
 131     }
 132     return *pArrayHelper;
 133 }
 134
 135 BaseResultSet::BaseResultSet(
 136     const ::rtl::Reference< RefCountedMutex > & refMutex,
 137     const Reference< XInterface > & owner,
 138     sal_Int32 rowCount,
 139     sal_Int32 colCount,
 140     const Reference< com::sun::star::script::XTypeConverter > & tc )
 141     : OComponentHelper( refMutex->mutex )
 142     , OPropertySetHelper( OComponentHelper::rBHelper )
 143     , m_owner( owner )
 144     , m_tc( tc )
 145     , m_refMutex( refMutex )
 146     , m_row( -1 )
 147     , m_rowCount( rowCount )
 148     , m_fieldCount( colCount )
 149     , m_wasNull(false)
 150 {
 151     POSTGRE_TRACE( "ctor BaseResultSet" );
 152 }
 153
 154 // LEM TODO: refMutex->mutex should live longer than OComponentHelper,
 155 // but calling OComponentHelper::dispose explicitly here calls
 156 // BaseResultSet::~BaseResultSet in an infinite loop :(
 157 BaseResultSet::~BaseResultSet()
 158 {
 159     POSTGRE_TRACE( "dtor BaseResultSet" );
 160 }
 161
 162 Any BaseResultSet::queryInterface( const Type & reqType ) throw (RuntimeException, std::exception)
 163 {
 164     Any ret;
 165
 166     ret = OComponentHelper::queryInterface( reqType );
 167     if( ! ret.hasValue() )
 168         ret = ::cppu::queryInterface( reqType,
 169                                     static_cast< XResultSet * > ( this  ),
 170                                     static_cast< XResultSetMetaDataSupplier * > ( this ),
 171                                     static_cast< XRow * > ( this ),
 172                                     static_cast< XColumnLocate * > ( this ),
 173                                     static_cast< XCloseable * > ( this ),
 174                                     static_cast< XPropertySet * > ( this ),
 175                                     static_cast< XMultiPropertySet * > ( this ),
 176                                     static_cast< XFastPropertySet * > ( this ) );
 177     return ret;
 178 }
 179
 180 // void BaseResultSet::close(  ) throw (SQLException, RuntimeException)
 181 // {
 182 //     Reference< XInterface > owner;
 183 //     {
 184 //         ResultSetGuard guard(*this);
 185 //         if( m_result )
 186 //         {
 187 //             PQclear(m_result );
 188 //             m_result = 0;
 189 //             m_row = -1;
 190 //         }
 191 //         owner = m_owner;
 192 //         m_owner.clear();
 193 //     }
 194 // }
 195
 196 Sequence<Type > BaseResultSet::getTypes() throw( RuntimeException, std::exception )
 197 {
 198     static cppu::OTypeCollection *pCollection;
 199     if( ! pCollection )
 200     {
 201         MutexGuard guard( osl::Mutex::getGlobalMutex() );
 202         if( !pCollection )
 203         {
 204             static cppu::OTypeCollection collection(
 205                 getCppuType( (Reference< XResultSet> *) 0 ),
 206                 getCppuType( (Reference< XResultSetMetaDataSupplier> *) 0 ),
 207                 getCppuType( (Reference< XRow> *) 0 ),
 208                 getCppuType( (Reference< XColumnLocate> *) 0 ),
 209                 getCppuType( (Reference< XCloseable> *) 0 ),
 210                 getCppuType( (Reference< XPropertySet >*) 0 ),
 211                 getCppuType( (Reference< XFastPropertySet > *) 0 ),
 212                 getCppuType( (Reference< XMultiPropertySet > *) 0 ),
 213                 OComponentHelper::getTypes());
 214             pCollection = &collection;
 215         }
 216     }
 217     return pCollection->getTypes();
 218 }
 219
 220 Sequence< sal_Int8> BaseResultSet::getImplementationId() throw( RuntimeException, std::exception )
 221 {
 222     return css::uno::Sequence<sal_Int8>();
 223 }
 224
 225 // Reference< XResultSetMetaData > BaseResultSet::getMetaData(  ) throw (SQLException, RuntimeException)
 226 // {
 227 //     ResultSetGuard guard(*this);
 228 //     checkClosed();
 229 //     return new ResultSetMetaData( m_refMutex, this, &m_result );
 230 // }
 231
 232 sal_Bool BaseResultSet::next(  ) throw (SQLException, RuntimeException, std::exception)
 233 {
 234     MutexGuard guard( m_refMutex->mutex );
 235     checkClosed();
 236     m_row ++;
 237     return m_row < m_rowCount;
 238 }
 239
 240 sal_Bool BaseResultSet::isBeforeFirst(  ) throw (SQLException, RuntimeException, std::exception)
 241 {
 242     MutexGuard guard( m_refMutex->mutex );
 243     checkClosed();
 244     return m_row == -1;
 245 }
 246
 247 sal_Bool BaseResultSet::isAfterLast(  ) throw (SQLException, RuntimeException, std::exception)
 248 {
 249     MutexGuard guard( m_refMutex->mutex );
 250     checkClosed();
 251     return m_row >= m_rowCount;
 252 }
 253
 254 sal_Bool BaseResultSet::isFirst(  ) throw (SQLException, RuntimeException, std::exception)
 255 {
 256     MutexGuard guard( m_refMutex->mutex );
 257     checkClosed();
 258     return m_row == 0 && m_rowCount;
 259 }
 260
 261 sal_Bool BaseResultSet::isLast(  ) throw (SQLException, RuntimeException, std::exception)
 262 {
 263     MutexGuard guard( m_refMutex->mutex );
 264     checkClosed();
 265     return m_row >= 0 && m_row + 1 == m_rowCount;
 266 }
 267
 268 void BaseResultSet::beforeFirst(  ) throw (SQLException, RuntimeException, std::exception)
 269 {
 270     MutexGuard guard( m_refMutex->mutex );
 271     checkClosed();
 272     m_row = -1;
 273 }
 274
 275 void BaseResultSet::afterLast(  ) throw (SQLException, RuntimeException, std::exception)
 276 {
 277     MutexGuard guard( m_refMutex->mutex );
 278     checkClosed();
 279     m_row = m_rowCount;
 280 }
 281
 282 sal_Bool BaseResultSet::first(  ) throw (SQLException, RuntimeException, std::exception)
 283 {
 284     MutexGuard guard( m_refMutex->mutex );
 285     checkClosed();
 286     bool bRet = ( m_rowCount > 0 );
 287     if( bRet )
 288         m_row = 0;
 289     return bRet;
 290 }
 291
 292 sal_Bool BaseResultSet::last(  ) throw (SQLException, RuntimeException, std::exception)
 293 {
 294     MutexGuard guard( m_refMutex->mutex );
 295     checkClosed();
 296     bool bRet = ( m_rowCount > 0 );
 297     if( bRet )
 298         m_row = m_rowCount -1;
 299     return bRet;
 300 }
 301
 302 sal_Int32 BaseResultSet::getRow(  ) throw (SQLException, RuntimeException, std::exception)
 303 {
 304     MutexGuard guard( m_refMutex->mutex );
 305     checkClosed();
 306     return m_row +1;
 307 }
 308
 309 sal_Bool BaseResultSet::absolute( sal_Int32 row ) throw (SQLException, RuntimeException, std::exception)
 310 {
 311     MutexGuard guard( m_refMutex->mutex );
 312     checkClosed();
 313     if( row > 0 )
 314     {
 315         m_row = row -1;
 316         if( m_row > m_rowCount )
 317             m_row = m_rowCount;
 318     }
 319     else
 320     {
 321         m_row = m_rowCount + row;
 322         if( m_row < -1 )
 323             m_row = -1;
 324     }
 325     return sal_True;
 326 }
 327
 328 sal_Bool BaseResultSet::relative( sal_Int32 rows ) throw (SQLException, RuntimeException, std::exception)
 329 {
 330     MutexGuard guard( m_refMutex->mutex );
 331     checkClosed();
 332     m_row += rows;
 333
 334     if( m_row > m_rowCount )
 335         m_row = m_rowCount;
 336     else if ( m_row < -1 )
 337         m_row = -1;
 338     return sal_True;
 339 }
 340
 341 sal_Bool BaseResultSet::previous(  ) throw (SQLException, RuntimeException, std::exception)
 342 {
 343     MutexGuard guard( m_refMutex->mutex );
 344     checkClosed();
 345     bool bRet = ( m_row != -1 );
 346     if( bRet )
 347         m_row --;
 348     return bRet;
 349 }
 350
 351 void BaseResultSet::refreshRow(  ) throw (SQLException, RuntimeException, std::exception)
 352 {
 353     // TODO: not supported for now
 354 }
 355
 356 sal_Bool BaseResultSet::rowUpdated(  ) throw (SQLException, RuntimeException, std::exception)
 357 {
 358     return sal_False;
 359 }
 360
 361 sal_Bool BaseResultSet::rowInserted(  ) throw (SQLException, RuntimeException, std::exception)
 362 {
 363     return sal_False;
 364 }
 365
 366 sal_Bool BaseResultSet::rowDeleted(  ) throw (SQLException, RuntimeException, std::exception)
 367 {
 368     return sal_False;
 369 }
 370
 371 Reference< XInterface > BaseResultSet::getStatement() throw (SQLException, RuntimeException, std::exception)
 372 {
 373     MutexGuard guard( m_refMutex->mutex );
 374     checkClosed();
 375     return m_owner;
 376 }
 377
 378
 379 //----------------- XRow interface ----------------------------------------------------
 380
 381 sal_Bool BaseResultSet::wasNull(  ) throw (SQLException, RuntimeException, std::exception)
 382 {
 383     return m_wasNull;
 384 }
 385
 386 Any BaseResultSet::convertTo( const Any & val , const Type & type )
 387 {
 388     Any aRet;
 389     try
 390     {
 391         aRet = m_tc->convertTo( val , type );
 392     }
 393     catch( com::sun::star::lang::IllegalArgumentException & )
 394     {}
 395     catch( com::sun::star::script::CannotConvertException & )
 396     {}
 397     return aRet;
 398 }
 399
 400 sal_Bool BaseResultSet::getBoolean( sal_Int32 columnIndex ) throw (SQLException, RuntimeException, std::exception)
 401 {
 402     MutexGuard guard( m_refMutex->mutex );
 403     checkClosed();
 404     checkColumnIndex( columnIndex );
 405     checkRowIndex( sal_True /* must be on row */ );
 406
 407     OUString str = getString( columnIndex );
 408
 409     if( str.getLength() > 0 )
 410     {
 411         switch(str[0])
 412         {
 413         case '1':
 414         case 't':
 415         case 'T':
 416         case 'y':
 417         case 'Y':
 418
 419             return sal_True;
 420         }
 421     }
 422     return sal_False;
 423 }
 424
 425 sal_Int8 BaseResultSet::getByte( sal_Int32 columnIndex )
 426         throw (SQLException, RuntimeException, std::exception)
 427 {
 428     MutexGuard guard( m_refMutex->mutex );
 429     checkClosed();
 430     checkColumnIndex( columnIndex );
 431     checkRowIndex( sal_True /* must be on row */ );
 432     sal_Int8 b = 0;
 433     convertTo( getValue( columnIndex ), getCppuType( &b )) >>= b;
 434     return b;
 435 }
 436
 437 sal_Int16 BaseResultSet::getShort( sal_Int32 columnIndex )
 438         throw (SQLException, RuntimeException, std::exception)
 439 {
 440     MutexGuard guard( m_refMutex->mutex );
 441     checkClosed();
 442     checkColumnIndex( columnIndex );
 443     checkRowIndex( sal_True /* must be on row */ );
 444     sal_Int16 i = 0;
 445     convertTo( getValue( columnIndex ), getCppuType( &i )) >>= i;
 446     return i;
 447 }
 448
 449 OUString BaseResultSet::getString( sal_Int32 columnIndex ) throw (SQLException, RuntimeException, std::exception)
 450 {
 451     MutexGuard guard(m_refMutex->mutex);
 452     checkClosed();
 453     checkColumnIndex( columnIndex );
 454     checkRowIndex( sal_True /* must be on row */ );
 455     OUString ret;
 456     convertTo( getValue(  columnIndex ), getCppuType( &ret ) ) >>= ret;
 457 //     printf( "BaseResultSet::getString() %s\n" , OUStringToOString( ret, RTL_TEXTENCODING_ASCII_US ).getStr() );
 458     return ret;
 459 }
 460
 461 sal_Int32 BaseResultSet::getInt( sal_Int32 columnIndex )
 462         throw (SQLException, RuntimeException, std::exception)
 463 {
 464     MutexGuard guard( m_refMutex->mutex );
 465     checkClosed();
 466     checkColumnIndex( columnIndex );
 467     checkRowIndex( sal_True /* must be on row */ );
 468     sal_Int32 i = 0;
 469     convertTo( getValue( columnIndex ), getCppuType( &i )) >>= i;
 470     return i;
 471 }
 472
 473 sal_Int64 BaseResultSet::getLong( sal_Int32 columnIndex )
 474         throw (SQLException, RuntimeException, std::exception)
 475 {
 476     MutexGuard guard( m_refMutex->mutex );
 477     checkClosed();
 478     checkColumnIndex( columnIndex );
 479     checkRowIndex( sal_True /* must be on row */ );
 480     sal_Int64 i = 0;
 481     convertTo( getValue( columnIndex ), getCppuType( &i )) >>= i;
 482     return i;
 483 }
 484
 485 float BaseResultSet::getFloat( sal_Int32 columnIndex )
 486         throw (SQLException, RuntimeException, std::exception)
 487 {
 488     MutexGuard guard( m_refMutex->mutex );
 489     checkClosed();
 490     checkColumnIndex( columnIndex );
 491     checkRowIndex( sal_True /* must be on row */ );
 492     float f = 0.;
 493     convertTo( getValue( columnIndex ), getCppuType( &f )) >>= f;
 494     return f;
 495 }
 496
 497 double BaseResultSet::getDouble( sal_Int32 columnIndex )
 498         throw (SQLException, RuntimeException, std::exception)
 499 {
 500     MutexGuard guard( m_refMutex->mutex );
 501     checkClosed();
 502     checkColumnIndex( columnIndex );
 503     double d = 0.;
 504     convertTo( getValue( columnIndex ), getCppuType( &d )) >>= d;
 505     return d;
 506 }
 507
 508 Sequence< sal_Int8 > BaseResultSet::getBytes( sal_Int32 columnIndex )
 509         throw (SQLException, RuntimeException, std::exception)
 510 {
 511     MutexGuard guard( m_refMutex->mutex );
 512     checkClosed();
 513     checkColumnIndex( columnIndex );
 514     checkRowIndex( sal_True /* must be on row */ );
 515
 516     Sequence< sal_Int8 > ret;
 517     OUString ustr;
 518     if( ! (getValue( columnIndex ) >>= ustr) )
 519         m_wasNull = true;
 520     else
 521     {
 522         // if this is a binary, it must contain escaped data !
 523         OString val = OUStringToOString( ustr, RTL_TEXTENCODING_ASCII_US );
 524
 525         size_t length;
 526         char * res = (char*) PQunescapeBytea( (unsigned char *)val.getStr() , &length);
 527         ret = Sequence< sal_Int8 > ( (sal_Int8*)res, length );
 528         if( res )
 529             free( res );
 530     }
 531     return ret;
 532 }
 533
 534
 535 ::com::sun::star::util::Date BaseResultSet::getDate( sal_Int32 columnIndex )
 536         throw (SQLException, RuntimeException, std::exception)
 537 {
 538     return DBTypeConversion::toDate( getString( columnIndex ) );
 539 }
 540
 541 ::com::sun::star::util::Time BaseResultSet::getTime( sal_Int32 columnIndex )
 542         throw (SQLException, RuntimeException, std::exception)
 543 {
 544     return DBTypeConversion::toTime( getString( columnIndex ) );
 545 }
 546
 547 ::com::sun::star::util::DateTime BaseResultSet::getTimestamp( sal_Int32 columnIndex )
 548         throw (SQLException, RuntimeException, std::exception)
 549 {
 550     return DBTypeConversion::toDateTime( getString( columnIndex ) );
 551 }
 552
 553   // LEM TODO: these look like they are missing an actual implementation
 554 Reference< ::com::sun::star::io::XInputStream > BaseResultSet::getBinaryStream( sal_Int32 /* columnIndex */ )
 555         throw (SQLException, RuntimeException, std::exception)
 556 {
 557     return 0;
 558 }
 559
 560 Reference< ::com::sun::star::io::XInputStream > BaseResultSet::getCharacterStream( sal_Int32 /* columnIndex */ )
 561         throw (SQLException, RuntimeException, std::exception)
 562 {
 563     return 0;
 564 }
 565
 566 Any BaseResultSet::getObject(
 567         sal_Int32 /* columnIndex */,
 568         const Reference< ::com::sun::star::container::XNameAccess >& /* typeMap */ )
 569         throw (SQLException, RuntimeException, std::exception)
 570 {
 571     return Any();
 572 }
 573
 574 Reference< ::com::sun::star::sdbc::XRef > BaseResultSet::getRef( sal_Int32 /* columnIndex */ )
 575         throw (SQLException, RuntimeException, std::exception)
 576 {
 577     return Reference< com::sun::star::sdbc::XRef > ();
 578 }
 579
 580 Reference< ::com::sun::star::sdbc::XBlob > BaseResultSet::getBlob( sal_Int32 /* columnIndex */ )
 581         throw (SQLException, RuntimeException, std::exception)
 582 {
 583     return Reference< com::sun::star::sdbc::XBlob > ();
 584 }
 585
 586 Reference< ::com::sun::star::sdbc::XClob > BaseResultSet::getClob( sal_Int32 /* columnIndex */ )
 587         throw (SQLException, RuntimeException, std::exception)
 588 {
 589     return Reference< com::sun::star::sdbc::XClob > ();
 590 }
 591
 592 Reference< ::com::sun::star::sdbc::XArray > BaseResultSet::getArray( sal_Int32 columnIndex )
 593         throw (SQLException, RuntimeException, std::exception)
 594 {
 595     return new Array( m_refMutex, parseArray( getString( columnIndex ) ), *this, m_tc );
 596 }
 597
 598 ::cppu::IPropertyArrayHelper & BaseResultSet::getInfoHelper()
 599 {
 600     return getResultSetPropertyArrayHelper();
 601 }
 602
 603 sal_Bool BaseResultSet::convertFastPropertyValue(
 604         Any & /* rConvertedValue */, Any & /* rOldValue */, sal_Int32 nHandle, const Any& rValue )
 605         throw (IllegalArgumentException)
 606 {
 607     bool bRet;
 608     switch( nHandle )
 609     {
 610     case BASERESULTSET_CURSOR_NAME:
 611     {
 612         OUString val;
 613         bRet = ( rValue >>= val );
 614         m_props[nHandle] = makeAny( val );
 615         break;
 616     }
 617     case BASERESULTSET_ESCAPE_PROCESSING:
 618     case BASERESULTSET_IS_BOOKMARKABLE:
 619     {
 620         bool val(false);
 621         bRet = ( rValue >>= val );
 622         m_props[nHandle] = makeAny( val );
 623         break;
 624     }
 625     case BASERESULTSET_FETCH_DIRECTION:
 626     case BASERESULTSET_FETCH_SIZE:
 627     case BASERESULTSET_RESULT_SET_CONCURRENCY:
 628     case BASERESULTSET_RESULT_SET_TYPE:
 629     {
 630         sal_Int32 val;
 631         bRet = ( rValue >>= val );
 632         m_props[nHandle] = makeAny( val );
 633         break;
 634     }
 635     default:
 636     {
 637         OUStringBuffer buf(128);
 638         buf.appendAscii( "pq_resultset: Invalid property handle (" );
 639         buf.append( nHandle );
 640         buf.appendAscii( ")" );
 641         throw IllegalArgumentException( buf.makeStringAndClear(), *this, 2 );
 642     }
 643     }
 644     return bRet;
 645 }
 646
 647
 648 void BaseResultSet::setFastPropertyValue_NoBroadcast(
 649     sal_Int32 nHandle,const Any& rValue ) throw (Exception, std::exception)
 650 {
 651     m_props[nHandle] = rValue;
 652 }
 653
 654 void BaseResultSet::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
 655 {
 656     rValue = m_props[nHandle];
 657 }
 658
 659 Reference < XPropertySetInfo >  BaseResultSet::getPropertySetInfo()
 660         throw(RuntimeException, std::exception)
 661 {
 662     return OPropertySetHelper::createPropertySetInfo( getResultSetPropertyArrayHelper() );
 663 }
 664
 665 void BaseResultSet::disposing()
 666 {
 667     close();
 668 }
 669
 670 void BaseResultSet::checkColumnIndex(sal_Int32 index ) throw ( SQLException, RuntimeException )
 671 {
 672     if( index < 1 || index > m_fieldCount )
 673     {
 674         OUStringBuffer buf(128);
 675         buf.appendAscii( "pq_resultset: index out of range (" );
 676         buf.append( index );
 677         buf.appendAscii( ", allowed range is 1 to " );
 678         buf.append( m_fieldCount );
 679         buf.appendAscii( ")" );
 680         throw SQLException( buf.makeStringAndClear(), *this, OUString(), 1, Any() );
 681     }
 682
 683 }
 684
 685 void BaseResultSet::checkRowIndex( sal_Bool mustBeOnValidRow )
 686 {
 687     OUStringBuffer buf( 128 );
 688     buf.appendAscii( "pq_baseresultset: row index out of range, allowed is " );
 689     if( mustBeOnValidRow )
 690     {
 691         if( m_row < 0 || m_row >= m_rowCount )
 692         {
 693             buf.appendAscii( "0 to " );
 694             buf.append( ((sal_Int32)(m_rowCount -1)) );
 695             buf.appendAscii( ", got " );
 696             buf.append( m_row );
 697             throw SQLException( buf.makeStringAndClear(), *this, OUString(),1, Any() );
 698         }
 699     }
 700     else
 701     {
 702         if( m_row < -1 || m_row > m_rowCount )
 703         {
 704             buf.appendAscii( "-1 to " );
 705             buf.append( m_rowCount );
 706             buf.appendAscii( ", got " );
 707             buf.append( m_row );
 708             throw SQLException( buf.makeStringAndClear(), *this, OUString(),1, Any() );
 709         }
 710     }
 711 }
 712
 713 }
 714
 715 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */