connectivity/source/drivers/postgresql/pq_preparedstatement.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 <sal/log.hxx>
  38 #include "pq_preparedstatement.hxx"
  39 #include "pq_tools.hxx"
  40 #include "pq_statics.hxx"
  41 #include "pq_statement.hxx"
  42
  43 #include <o3tl/deleter.hxx>
  44 #include <rtl/strbuf.hxx>
  45 #include <rtl/ustrbuf.hxx>
  46
  47
  48 #include <comphelper/sequence.hxx>
  49
  50 #include <com/sun/star/sdbc/DataType.hpp>
  51 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
  52 #include <com/sun/star/sdbc/ResultSetType.hpp>
  53 #include <com/sun/star/sdbc/SQLException.hpp>
  54
  55 #include <memory>
  56 #include <string.h>
  57 #include <string_view>
  58
  59 #include <connectivity/dbconversion.hxx>
  60
  61 using osl::MutexGuard;
  62
  63
  64 using com::sun::star::uno::Any;
  65 using com::sun::star::uno::Type;
  66 using com::sun::star::uno::Sequence;
  67 using com::sun::star::uno::Reference;
  68 using com::sun::star::uno::UNO_QUERY;
  69
  70 using com::sun::star::lang::IllegalArgumentException;
  71
  72 using com::sun::star::sdbc::XCloseable;
  73 using com::sun::star::sdbc::XResultSet;
  74 using com::sun::star::sdbc::XRef;
  75 using com::sun::star::sdbc::XBlob;
  76 using com::sun::star::sdbc::XClob;
  77 using com::sun::star::sdbc::XArray;
  78 using com::sun::star::sdbc::XConnection;
  79 using com::sun::star::sdbc::SQLException;
  80
  81 using com::sun::star::beans::Property;
  82 using com::sun::star::beans::XPropertySetInfo;
  83
  84 using namespace dbtools;
  85
  86 namespace pq_sdbc_driver
  87 {
  88 static ::cppu::IPropertyArrayHelper & getPreparedStatementPropertyArrayHelper()
  89 {
  90     static ::cppu::OPropertyArrayHelper arrayHelper(
  91         Sequence<Property>{
  92             Property(
  93                 "CursorName", 0,
  94                 ::cppu::UnoType<OUString>::get() , 0 ),
  95             Property(
  96                 "EscapeProcessing", 1,
  97                 cppu::UnoType<bool>::get() , 0 ),
  98             Property(
  99                 "FetchDirection", 2,
 100                 ::cppu::UnoType<sal_Int32>::get() , 0 ),
 101             Property(
 102                 "FetchSize", 3,
 103                 ::cppu::UnoType<sal_Int32>::get() , 0 ),
 104             Property(
 105                 "MaxFieldSize", 4,
 106                 ::cppu::UnoType<sal_Int32>::get() , 0 ),
 107             Property(
 108                 "MaxRows", 5,
 109                 ::cppu::UnoType<sal_Int32>::get() , 0 ),
 110             Property(
 111                 "QueryTimeOut", 6,
 112                 ::cppu::UnoType<sal_Int32>::get() , 0 ),
 113             Property(
 114                 "ResultSetConcurrency", 7,
 115                 ::cppu::UnoType<sal_Int32>::get() , 0 ),
 116             Property(
 117                 "ResultSetType", 8,
 118                 ::cppu::UnoType<sal_Int32>::get() , 0 )},
 119         true );
 120     static ::cppu::IPropertyArrayHelper *pArrayHelper = &arrayHelper;
 121
 122     return *pArrayHelper;
 123 }
 124
 125 static bool isOperator( char c )
 126 {
 127     static const char * const operators = "<>=()!/&%.,;";
 128
 129     const char * w = operators;
 130     while (*w && *w != c)
 131     {
 132         ++w;
 133     }
 134     return *w != 0;
 135 }
 136
 137 static bool isNamedParameterStart( std::string_view o , int index )
 138 {
 139     return o[index] == ':' && (
 140         isWhitespace( o[index-1] ) || isOperator(o[index-1]) );
 141 }
 142
 143 static bool isQuoted( std::string_view str )
 144 {
 145     return str[0] == '"' || str[0] == '\'';
 146 }
 147
 148 PreparedStatement::PreparedStatement(
 149     const ::rtl::Reference< comphelper::RefCountedMutex > & refMutex,
 150     const Reference< XConnection > & conn,
 151     struct ConnectionSettings *pSettings,
 152     const OString & stmt )
 153     : PreparedStatement_BASE(refMutex->GetMutex())
 154     , OPropertySetHelper(PreparedStatement_BASE::rBHelper)
 155     , m_connection(conn)
 156     , m_pSettings(pSettings)
 157     , m_stmt(stmt)
 158     , m_xMutex(refMutex)
 159     , m_multipleResultAvailable(false)
 160     , m_multipleResultUpdateCount(0)
 161     , m_lastOidInserted( InvalidOid )
 162 {
 163     m_props[PREPARED_STATEMENT_QUERY_TIME_OUT] <<= sal_Int32(0);
 164     m_props[PREPARED_STATEMENT_MAX_ROWS] <<= sal_Int32(0);
 165     m_props[PREPARED_STATEMENT_RESULT_SET_CONCURRENCY] <<=
 166         css::sdbc::ResultSetConcurrency::READ_ONLY;
 167     m_props[PREPARED_STATEMENT_RESULT_SET_TYPE] <<=
 168         css::sdbc::ResultSetType::SCROLL_INSENSITIVE;
 169
 170     splitSQL( m_stmt, m_splittedStatement );
 171     int elements = 0;
 172     for(const OString & str : m_splittedStatement)
 173     {
 174         // ignore quoted strings...
 175         if( ! isQuoted( str ) )
 176         {
 177             // the ':' cannot be the first or the last part of the
 178             // token,
 179             // the ? cannot be the first part of the token , so we start
 180             // at one
 181             for( int index = 1 ; index < str.getLength() ; index ++ )
 182             {
 183                 if( str[index] == '?' ||
 184                     isNamedParameterStart( str , index )
 185                     )
 186                 {
 187                     elements ++;
 188                 }
 189             }
 190         }
 191     }
 192     m_vars = std::vector< OString >( elements );
 193 }
 194
 195 PreparedStatement::~PreparedStatement()
 196 {
 197 }
 198
 199 void PreparedStatement::checkColumnIndex( sal_Int32 parameterIndex )
 200 {
 201     if( parameterIndex < 1 || parameterIndex > static_cast<sal_Int32>(m_vars.size()) )
 202     {
 203         throw SQLException(
 204             "pq_preparedstatement: parameter index out of range (expected 1 to "
 205             + OUString::number( m_vars.size() )
 206             + ", got " + OUString::number( parameterIndex )
 207             + ", statement '" + OStringToOUString( m_stmt, ConnectionSettings::encoding )
 208             + "')",
 209             *this, OUString(), 1, Any () );
 210     }
 211 }
 212 void PreparedStatement::checkClosed()
 213 {
 214     if( ! m_pSettings || ! m_pSettings->pConnection )
 215         throw SQLException(
 216             "pq_driver: PreparedStatement or connection has already been closed !",
 217             *this, OUString(),1,Any());
 218 }
 219
 220 Any PreparedStatement::queryInterface( const Type & rType )
 221 {
 222     Any aRet = PreparedStatement_BASE::queryInterface(rType);
 223     return aRet.hasValue() ? aRet : OPropertySetHelper::queryInterface(rType);
 224 }
 225
 226
 227 Sequence< Type > PreparedStatement::getTypes()
 228 {
 229     static Sequence< Type > collection(
 230         ::comphelper::concatSequences(
 231             OPropertySetHelper::getTypes(),
 232             PreparedStatement_BASE::getTypes()));
 233
 234     return collection;
 235 }
 236
 237 Sequence< sal_Int8> PreparedStatement::getImplementationId()
 238 {
 239     return css::uno::Sequence<sal_Int8>();
 240 }
 241
 242 void PreparedStatement::close(  )
 243 {
 244     // let the connection die without acquired mutex !
 245     Reference< XConnection > r;
 246     Reference< XCloseable > resultSet;
 247     {
 248         MutexGuard guard( m_xMutex->GetMutex() );
 249         m_pSettings = nullptr;
 250         r = m_connection;
 251         m_connection.clear();
 252
 253         resultSet = m_lastResultset;
 254         m_lastResultset.clear();
 255     }
 256     if( resultSet.is() )
 257     {
 258         resultSet->close();
 259     }
 260 }
 261
 262 void PreparedStatement::raiseSQLException( const char * errorMsg )
 263 {
 264     OUStringBuffer buf(128);
 265     buf.append( "pq_driver: ");
 266     buf.append(
 267         OUString( errorMsg, strlen(errorMsg) , ConnectionSettings::encoding ) );
 268     buf.append( " (caused by statement '" );
 269     buf.appendAscii( m_executedStatement.getStr() );
 270     buf.append( "')" );
 271     OUString error = buf.makeStringAndClear();
 272     SAL_WARN("connectivity.postgresql", error);
 273     throw SQLException( error, *this, OUString(), 1, Any() );
 274 }
 275
 276 Reference< XResultSet > PreparedStatement::executeQuery( )
 277 {
 278     if( ! execute( ) )
 279     {
 280         raiseSQLException(  "not a query" );
 281     }
 282     return Reference< XResultSet > ( m_lastResultset, css::uno::UNO_QUERY );
 283 }
 284
 285 sal_Int32 PreparedStatement::executeUpdate( )
 286 {
 287     if( execute( ) )
 288     {
 289         raiseSQLException( "not a command" );
 290     }
 291     return m_multipleResultUpdateCount;
 292 }
 293
 294 sal_Bool PreparedStatement::execute( )
 295 {
 296     osl::MutexGuard guard( m_xMutex->GetMutex() );
 297
 298     OStringBuffer buf( m_stmt.getLength() *2 );
 299
 300     std::vector< OString >::size_type vars = 0;
 301     for(const OString & str : m_splittedStatement)
 302     {
 303         // LEM TODO: instead of this manual mucking with SQL
 304         // could we use PQexecParams / PQExecPrepared / ...?
 305         // Only snafu is giving the types of the parameters and
 306         // that it needs $1, $2, etc instead of "?"
 307
 308 //         printf( "Split %d %s\n" , i , str.getStr() );
 309         if( isQuoted( str ) )
 310         {
 311             buf.append( str );
 312         }
 313         else
 314         {
 315             int start = 0,index;
 316             for( index = 1 ; index < str.getLength() ; index ++ )
 317             {
 318                 if( str[index] == '?' )
 319                 {
 320                     buf.append( str.getStr()+start, index - start );
 321                     buf.append( m_vars[vars] );
 322                     vars ++;
 323                     start =index+1;
 324                 }
 325                 else
 326                 {
 327                     if ( isNamedParameterStart( str, index ) )
 328                     {
 329                         buf.append( str.getStr()+start, index -start );
 330                         buf.append( m_vars[vars] );
 331
 332                         // skip to the end of the named parameter
 333                         while (   index < str.getLength()
 334                                && !(   isWhitespace(str[index])
 335                                     || isOperator  (str[index])))
 336                         {
 337                             ++index;
 338                         }
 339                         start = index;
 340                         vars ++;
 341                     }
 342                 }
 343             }
 344 //             if( index +1 >= str.getLength() )
 345 //             {
 346             buf.append( str.getStr() + start, index -start );
 347 //             }
 348         }
 349     }
 350
 351     m_executedStatement = buf.makeStringAndClear();
 352
 353     Reference< XCloseable > lastResultSet = m_lastResultset;
 354     if( lastResultSet.is() )
 355         lastResultSet->close();
 356
 357     m_lastResultset.clear();
 358     m_lastTableInserted.clear();
 359
 360     struct CommandData data;
 361     data.refMutex = m_xMutex;
 362     data.ppSettings = &m_pSettings;
 363     data.pLastOidInserted = &m_lastOidInserted;
 364     data.pLastQuery = &m_lastQuery;
 365     data.pMultipleResultUpdateCount = &m_multipleResultUpdateCount;
 366     data.pMultipleResultAvailable = &m_multipleResultAvailable;
 367     data.pLastTableInserted = &m_lastTableInserted;
 368     data.pLastResultset = &m_lastResultset;
 369     data.owner = *this;
 370     data.tableSupplier.set( m_connection, UNO_QUERY );
 371     data.concurrency = extractIntProperty( this, getStatics().RESULT_SET_CONCURRENCY );
 372
 373     return executePostgresCommand( m_executedStatement , &data );   // see pq_statement.cxx
 374 }
 375
 376 Reference< XConnection > PreparedStatement::getConnection(  )
 377 {
 378     Reference< XConnection > ret;
 379     {
 380         MutexGuard guard( m_xMutex->GetMutex() );
 381         checkClosed();
 382         ret = m_connection;
 383     }
 384     return ret;
 385 }
 386
 387
 388 void PreparedStatement::setNull( sal_Int32 parameterIndex, sal_Int32 )
 389 {
 390     MutexGuard guard( m_xMutex->GetMutex() );
 391     checkClosed();
 392     checkColumnIndex( parameterIndex );
 393     m_vars[parameterIndex-1] = OString( "NULL" );
 394 }
 395
 396 void PreparedStatement::setObjectNull(
 397     sal_Int32 parameterIndex, sal_Int32, const OUString& )
 398 {
 399     MutexGuard guard( m_xMutex->GetMutex() );
 400     checkClosed();
 401     checkColumnIndex( parameterIndex );
 402     m_vars[parameterIndex-1] = OString( "NULL" );
 403 }
 404
 405
 406 void PreparedStatement::setBoolean( sal_Int32 parameterIndex, sal_Bool x )
 407 {
 408     MutexGuard guard(m_xMutex->GetMutex() );
 409     checkClosed();
 410     checkColumnIndex( parameterIndex );
 411     if( x )
 412         m_vars[parameterIndex-1] = OString( "'t'" );
 413     else
 414         m_vars[parameterIndex-1] = OString( "'f'" );
 415 }
 416
 417 void PreparedStatement::setByte( sal_Int32 parameterIndex, sal_Int8 x )
 418 {
 419     setInt(parameterIndex,x);
 420 }
 421
 422 void PreparedStatement::setShort( sal_Int32 parameterIndex, sal_Int16 x )
 423 {
 424     setInt(parameterIndex, x );
 425 }
 426
 427 void PreparedStatement::setInt( sal_Int32 parameterIndex, sal_Int32 x )
 428 {
 429 //     printf( "setString %d %d\n ",  parameterIndex, x);
 430     MutexGuard guard(m_xMutex->GetMutex() );
 431     checkClosed();
 432     checkColumnIndex( parameterIndex );
 433     m_vars[parameterIndex-1] = "'" + OString::number(x) + "'";
 434 }
 435
 436 void PreparedStatement::setLong( sal_Int32 parameterIndex, sal_Int64 x )
 437 {
 438     MutexGuard guard(m_xMutex->GetMutex() );
 439     checkClosed();
 440     checkColumnIndex( parameterIndex );
 441     m_vars[parameterIndex-1] = "'" + OString::number(x) + "'";
 442 }
 443
 444 void PreparedStatement::setFloat( sal_Int32 parameterIndex, float x )
 445 {
 446     MutexGuard guard(m_xMutex->GetMutex() );
 447     checkClosed();
 448     checkColumnIndex( parameterIndex );
 449     m_vars[parameterIndex-1] = "'" + OString::number(x) + "'";
 450 }
 451
 452 void PreparedStatement::setDouble( sal_Int32 parameterIndex, double x )
 453 {
 454     MutexGuard guard(m_xMutex->GetMutex() );
 455     checkClosed();
 456     checkColumnIndex( parameterIndex );
 457     m_vars[parameterIndex-1] = "'" + OString::number(x) + "'";
 458 }
 459
 460 void PreparedStatement::setString( sal_Int32 parameterIndex, const OUString& x )
 461 {
 462 //     printf( "setString %d %s\n ", parameterIndex,
 463 //             OUStringToOString( x , RTL_TEXTENCODING_ASCII_US ).getStr());
 464     MutexGuard guard(m_xMutex->GetMutex() );
 465     checkClosed();
 466     checkColumnIndex( parameterIndex );
 467     OStringBuffer buf( 20 );
 468     buf.append( "'" );
 469     OString y = OUStringToOString( x, ConnectionSettings::encoding );
 470     buf.ensureCapacity( y.getLength() * 2 + 2 );
 471     int len = PQescapeString( const_cast<char*>(buf.getStr())+1, y.getStr() , y.getLength() );
 472     buf.setLength( 1 + len );
 473     buf.append( "'" );
 474     m_vars[parameterIndex-1] = buf.makeStringAndClear();
 475 }
 476
 477 void PreparedStatement::setBytes(
 478     sal_Int32 parameterIndex, const Sequence< sal_Int8 >& x )
 479 {
 480     MutexGuard guard(m_xMutex->GetMutex() );
 481     checkClosed();
 482     checkColumnIndex( parameterIndex );
 483     size_t len;
 484     const std::unique_ptr<unsigned char, deleter_from_fn<PQfreemem>> escapedString(
 485         PQescapeBytea( reinterpret_cast<unsigned char const *>(x.getConstArray()), x.getLength(), &len));
 486     if( ! escapedString )
 487     {
 488         throw SQLException(
 489             "pq_preparedstatement.setBytes: Error during converting bytesequence to an SQL conform string",
 490             *this, OUString(), 1, Any() );
 491     }
 492     m_vars[parameterIndex-1]
 493         = OString::Concat("'") + std::string_view(reinterpret_cast<char *>(escapedString.get()), len -1) + "'";
 494 }
 495
 496
 497 void PreparedStatement::setDate( sal_Int32 parameterIndex, const css::util::Date& x )
 498 {
 499     setString( parameterIndex, DBTypeConversion::toDateString( x ) );
 500 }
 501
 502 void PreparedStatement::setTime( sal_Int32 parameterIndex, const css::util::Time& x )
 503 {
 504     setString( parameterIndex, DBTypeConversion::toTimeString( x ) );
 505 }
 506
 507 void PreparedStatement::setTimestamp(
 508     sal_Int32 parameterIndex, const css::util::DateTime& x )
 509 {
 510     setString( parameterIndex, DBTypeConversion::toDateTimeString( x ) );
 511 }
 512
 513 void PreparedStatement::setBinaryStream(
 514     sal_Int32,
 515     const Reference< css::io::XInputStream >&,
 516     sal_Int32 )
 517 {
 518     throw SQLException(
 519         "pq_preparedstatement: setBinaryStream not implemented",
 520         *this, OUString(), 1, Any () );
 521 }
 522
 523 void PreparedStatement::setCharacterStream(
 524     sal_Int32,
 525     const Reference< css::io::XInputStream >&,
 526     sal_Int32 )
 527 {
 528     throw SQLException(
 529         "pq_preparedstatement: setCharacterStream not implemented",
 530         *this, OUString(), 1, Any () );
 531 }
 532
 533 void PreparedStatement::setObject( sal_Int32 parameterIndex, const Any& x )
 534 {
 535     if( ! implSetObject( this, parameterIndex, x ))
 536     {
 537         throw SQLException(
 538             "pq_preparedstatement::setObject: can't convert value of type " + x.getValueTypeName(),
 539             *this, OUString(), 1, Any () );
 540     }
 541 }
 542
 543 void PreparedStatement::setObjectWithInfo(
 544     sal_Int32 parameterIndex,
 545     const Any& x,
 546     sal_Int32 targetSqlType,
 547     sal_Int32 )
 548 {
 549     if( css::sdbc::DataType::DECIMAL == targetSqlType ||
 550         css::sdbc::DataType::NUMERIC == targetSqlType )
 551     {
 552         double myDouble = 0.0;
 553         OUString myString;
 554         if( x >>= myDouble )
 555         {
 556             myString = OUString::number( myDouble );
 557         }
 558         else
 559         {
 560             x >>= myString;
 561         }
 562         if( myString.isEmpty() )
 563         {
 564             throw SQLException(
 565                 "pq_preparedstatement::setObjectWithInfo: can't convert value of type "
 566                 +  x.getValueTypeName() + " to type DECIMAL or NUMERIC",
 567                 *this, OUString(), 1, Any () );
 568         }
 569
 570         setString( parameterIndex, myString );
 571     }
 572     else
 573     {
 574         setObject( parameterIndex, x );
 575     }
 576
 577 }
 578
 579 void PreparedStatement::setRef(
 580     sal_Int32,
 581     const Reference< XRef >& )
 582 {
 583     throw SQLException(
 584         "pq_preparedstatement: setRef not implemented",
 585         *this, OUString(), 1, Any () );
 586 }
 587
 588 void PreparedStatement::setBlob(
 589     sal_Int32,
 590     const Reference< XBlob >& )
 591 {
 592     throw SQLException(
 593         "pq_preparedstatement: setBlob not implemented",
 594         *this, OUString(), 1, Any () );
 595 }
 596
 597 void PreparedStatement::setClob(
 598     sal_Int32,
 599     const Reference< XClob >& )
 600 {
 601     throw SQLException(
 602         "pq_preparedstatement: setClob not implemented",
 603         *this, OUString(), 1, Any () );
 604 }
 605
 606 void PreparedStatement::setArray(
 607     sal_Int32 parameterIndex,
 608     const Reference< XArray >& x )
 609 {
 610     setString( parameterIndex, array2String( x->getArray( nullptr ) ) );
 611 }
 612
 613 void PreparedStatement::clearParameters(  )
 614 {
 615     MutexGuard guard(m_xMutex->GetMutex() );
 616     m_vars = std::vector< OString >( m_vars.size() );
 617 }
 618
 619 Any PreparedStatement::getWarnings(  )
 620 {
 621     return Any();
 622 }
 623
 624 void PreparedStatement::clearWarnings(  )
 625 {
 626 }
 627
 628 Reference< css::sdbc::XResultSetMetaData > PreparedStatement::getMetaData()
 629 {
 630     Reference< css::sdbc::XResultSetMetaData > ret;
 631     Reference< css::sdbc::XResultSetMetaDataSupplier > supplier( m_lastResultset, UNO_QUERY );
 632     if( supplier.is() )
 633         ret = supplier->getMetaData();
 634     return ret;
 635 }
 636
 637 ::cppu::IPropertyArrayHelper & PreparedStatement::getInfoHelper()
 638 {
 639     return getPreparedStatementPropertyArrayHelper();
 640 }
 641
 642
 643 sal_Bool PreparedStatement::convertFastPropertyValue(
 644         Any & rConvertedValue, Any & rOldValue, sal_Int32 nHandle, const Any& rValue )
 645 {
 646     bool bRet;
 647     rOldValue = m_props[nHandle];
 648     switch( nHandle )
 649     {
 650     case PREPARED_STATEMENT_CURSOR_NAME:
 651     {
 652         OUString val;
 653         bRet = ( rValue >>= val );
 654         rConvertedValue <<= val;
 655         break;
 656     }
 657     case PREPARED_STATEMENT_ESCAPE_PROCESSING:
 658     {
 659         bool val(false);
 660         bRet = ( rValue >>= val );
 661         rConvertedValue <<= val;
 662         break;
 663     }
 664     case PREPARED_STATEMENT_FETCH_DIRECTION:
 665     case PREPARED_STATEMENT_FETCH_SIZE:
 666     case PREPARED_STATEMENT_MAX_FIELD_SIZE:
 667     case PREPARED_STATEMENT_MAX_ROWS:
 668     case PREPARED_STATEMENT_QUERY_TIME_OUT:
 669     case PREPARED_STATEMENT_RESULT_SET_CONCURRENCY:
 670     case PREPARED_STATEMENT_RESULT_SET_TYPE:
 671     {
 672         sal_Int32 val;
 673         bRet = ( rValue >>= val );
 674         rConvertedValue <<= val;
 675         break;
 676     }
 677     default:
 678     {
 679         throw IllegalArgumentException(
 680             "pq_statement: Invalid property handle ("
 681             + OUString::number( nHandle ) +  ")",
 682             *this, 2 );
 683     }
 684     }
 685     return bRet;
 686 }
 687
 688
 689 void PreparedStatement::setFastPropertyValue_NoBroadcast(
 690     sal_Int32 nHandle,const Any& rValue )
 691 {
 692     m_props[nHandle] = rValue;
 693 }
 694
 695 void PreparedStatement::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
 696 {
 697     rValue = m_props[nHandle];
 698 }
 699
 700 Reference < XPropertySetInfo >  PreparedStatement::getPropertySetInfo()
 701 {
 702     return OPropertySetHelper::createPropertySetInfo( getPreparedStatementPropertyArrayHelper() );
 703 }
 704
 705 void PreparedStatement::disposing()
 706 {
 707     close();
 708 }
 709
 710
 711 Reference< XResultSet > PreparedStatement::getResultSet(  )
 712 {
 713     return Reference< XResultSet > ( m_lastResultset, css::uno::UNO_QUERY );
 714 }
 715 sal_Int32 PreparedStatement::getUpdateCount(  )
 716 {
 717     return m_multipleResultUpdateCount;
 718 }
 719 sal_Bool PreparedStatement::getMoreResults(  )
 720 {
 721     Reference< XCloseable > lastResultSet = m_lastResultset;
 722     if( lastResultSet.is() )
 723         lastResultSet->close();
 724     m_multipleResultUpdateCount = -1;
 725     return false;
 726 }
 727
 728 Reference< XResultSet > PreparedStatement::getGeneratedValues(  )
 729 {
 730     osl::MutexGuard guard( m_xMutex->GetMutex() );
 731     return getGeneratedValuesFromLastInsert(
 732         m_pSettings, m_connection, m_lastOidInserted, m_lastTableInserted, m_lastQuery );
 733 }
 734
 735
 736 }
 737
 738 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */