connectivity/source/drivers/postgresql/pq_preparedstatement.cxx

   1 /*************************************************************************
   2  *
   3  *  $RCSfile: pq_preparedstatement.cxx,v $
   4  *
   5  *  $Revision: 1.1.2.10 $
   6  *
   7  *  last change: $Author: jbu $ $Date: 2008/07/07 21:37:11 $
   8  *
   9  *  The Contents of this file are made available subject to the terms of
  10  *  either of the following licenses
  11  *
  12  *         - GNU Lesser General Public License Version 2.1
  13  *         - Sun Industry Standards Source License Version 1.1
  14  *
  15  *  Sun Microsystems Inc., October, 2000
  16  *
  17  *  GNU Lesser General Public License Version 2.1
  18  *  =============================================
  19  *  Copyright 2000 by Sun Microsystems, Inc.
  20  *  901 San Antonio Road, Palo Alto, CA 94303, USA
  21  *
  22  *  This library is free software; you can redistribute it and/or
  23  *  modify it under the terms of the GNU Lesser General Public
  24  *  License version 2.1, as published by the Free Software Foundation.
  25  *
  26  *  This library is distributed in the hope that it will be useful,
  27  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  28  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  29  *  Lesser General Public License for more details.
  30  *
  31  *  You should have received a copy of the GNU Lesser General Public
  32  *  License along with this library; if not, write to the Free Software
  33  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  34  *  MA  02111-1307  USA
  35  *
  36  *
  37  *  Sun Industry Standards Source License Version 1.1
  38  *  =================================================
  39  *  The contents of this file are subject to the Sun Industry Standards
  40  *  Source License Version 1.1 (the "License"); You may not use this file
  41  *  except in compliance with the License. You may obtain a copy of the
  42  *  License at http://www.openoffice.org/license.html.
  43  *
  44  *  Software provided under this License is provided on an "AS IS" basis,
  45  *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  46  *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
  47  *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
  48  *  See the License for the specific provisions governing your rights and
  49  *  obligations concerning the Software.
  50  *
  51  *  The Initial Developer of the Original Code is: Joerg Budischewski
  52  *
  53  *   Copyright: 2000 by Sun Microsystems, Inc.
  54  *
  55  *   All Rights Reserved.
  56  *
  57  *   Contributor(s): Joerg Budischewski
  58  *
  59  *
  60  ************************************************************************/
  61
  62 #include "pq_preparedstatement.hxx"
  63 #include "pq_resultset.hxx"
  64 #include "pq_tools.hxx"
  65 #include "pq_statics.hxx"
  66 #include "pq_statement.hxx"
  67
  68 #include <rtl/strbuf.hxx>
  69 #include <rtl/ustrbuf.hxx>
  70
  71
  72 #include <cppuhelper/typeprovider.hxx>
  73 #include <cppuhelper/queryinterface.hxx>
  74
  75 #include <com/sun/star/beans/PropertyAttribute.hpp>
  76
  77 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
  78 #include <com/sun/star/sdbc/ResultSetType.hpp>
  79
  80 #include <string.h>
  81
  82 using osl::Mutex;
  83 using osl::MutexGuard;
  84
  85 using rtl::OUString;
  86 using rtl::OUStringToOString;
  87 using rtl::OStringToOUString;
  88 using rtl::OUStringBuffer;
  89 using rtl::OStringBuffer;
  90 using rtl::OString;
  91
  92 using com::sun::star::uno::Any;
  93 using com::sun::star::uno::makeAny;
  94 using com::sun::star::uno::Type;
  95 using com::sun::star::uno::RuntimeException;
  96 using com::sun::star::uno::Exception;
  97 using com::sun::star::uno::Sequence;
  98 using com::sun::star::uno::Reference;
  99 using com::sun::star::uno::XInterface;
 100 using com::sun::star::uno::UNO_QUERY;
 101
 102 using com::sun::star::lang::IllegalArgumentException;
 103
 104 using com::sun::star::sdbc::XWarningsSupplier;
 105 using com::sun::star::sdbc::XCloseable;
 106 using com::sun::star::sdbc::XPreparedStatement;
 107 using com::sun::star::sdbc::XParameters;
 108 using com::sun::star::sdbc::XResultSet;
 109 using com::sun::star::sdbc::XRef;
 110 using com::sun::star::sdbc::XBlob;
 111 using com::sun::star::sdbc::XClob;
 112 using com::sun::star::sdbc::XArray;
 113 using com::sun::star::sdbc::XConnection;
 114 using com::sun::star::sdbc::XGeneratedResultSet;
 115 using com::sun::star::sdbc::SQLException;
 116
 117 using com::sun::star::beans::Property;
 118 using com::sun::star::beans::XPropertySetInfo;
 119 using com::sun::star::beans::XPropertySet;
 120 using com::sun::star::beans::XMultiPropertySet;
 121 using com::sun::star::beans::XFastPropertySet;
 122
 123 #define ASCII_STR(x) OUString( RTL_CONSTASCII_USTRINGPARAM( x ) )
 124 namespace pq_sdbc_driver
 125 {
 126 static ::cppu::IPropertyArrayHelper & getPreparedStatementPropertyArrayHelper()
 127 {
 128     static ::cppu::IPropertyArrayHelper *pArrayHelper;
 129         if( ! pArrayHelper )
 130     {
 131                 MutexGuard guard( Mutex::getGlobalMutex() );
 132                 if( ! pArrayHelper )
 133         {
 134             static Property aTable[] =
 135                 {
 136                     Property(
 137                         OUString( RTL_CONSTASCII_USTRINGPARAM("CursorName") ), 0,
 138                         ::getCppuType( (OUString *)0) , 0 ),
 139                     Property(
 140                         OUString( RTL_CONSTASCII_USTRINGPARAM("EscapeProcessing") ), 1,
 141                         ::getBooleanCppuType() , 0 ),
 142                     Property(
 143                         OUString( RTL_CONSTASCII_USTRINGPARAM("FetchDirection") ), 2,
 144                         ::getCppuType( (sal_Int32 *)0) , 0 ),
 145                     Property(
 146                         OUString( RTL_CONSTASCII_USTRINGPARAM("FetchSize") ), 3,
 147                         ::getCppuType( (sal_Int32 *)0) , 0 ),
 148                     Property(
 149                         OUString( RTL_CONSTASCII_USTRINGPARAM("MaxFieldSize") ), 4,
 150                         ::getCppuType( (sal_Int32 *)0) , 0 ),
 151                     Property(
 152                         OUString( RTL_CONSTASCII_USTRINGPARAM("MaxRows") ), 5,
 153                         ::getCppuType( (sal_Int32 *)0) , 0 ),
 154                     Property(
 155                         OUString( RTL_CONSTASCII_USTRINGPARAM("QueryTimeOut") ), 6,
 156                         ::getCppuType( (sal_Int32 *)0) , 0 ),
 157                     Property(
 158                         OUString( RTL_CONSTASCII_USTRINGPARAM("ResultSetConcurrency") ), 7,
 159                         ::getCppuType( (sal_Int32 *)0) , 0 ),
 160                     Property(
 161                         OUString( RTL_CONSTASCII_USTRINGPARAM("ResultSetType") ), 8,
 162                         ::getCppuType( (sal_Int32 *)0) , 0 )
 163                 };
 164             OSL_ASSERT( sizeof(aTable)/ sizeof(Property)  == PREPARED_STATEMENT_SIZE );
 165                         static ::cppu::OPropertyArrayHelper arrayHelper( aTable, PREPARED_STATEMENT_SIZE, sal_True );
 166             pArrayHelper = &arrayHelper;
 167         }
 168     }
 169     return *pArrayHelper;
 170 }
 171
 172 static bool isOperator( char c )
 173 {
 174     static const char * operators = "<>=()!/&%.,;";
 175
 176     const char * w = operators;
 177     for( ; *w && *w != c ; w ++);
 178     return *w != 0;
 179 }
 180
 181 static bool isNamedParameterStart( const rtl::OString & o , int index )
 182 {
 183     return o[index] == ':' && (
 184         isWhitespace( o[index-1] ) || isOperator(o[index-1]) );
 185 }
 186
 187 static bool isQuoted( const rtl::OString & str )
 188 {
 189     return str[0] == '"' || str[0] == '\'';
 190 }
 191
 192 PreparedStatement::PreparedStatement(
 193     const ::rtl::Reference< RefCountedMutex > & refMutex,
 194     const Reference< XConnection > & conn,
 195     struct ConnectionSettings *pSettings,
 196     const ::rtl::OString & stmt )
 197     : OComponentHelper( refMutex->mutex ),
 198       OPropertySetHelper( OComponentHelper::rBHelper ),
 199       m_refMutex( refMutex ),
 200       m_connection( conn ),
 201       m_pSettings( pSettings ),
 202       m_stmt( stmt ),
 203       m_lastOidInserted( InvalidOid )
 204 {
 205     m_props[PREPARED_STATEMENT_QUERY_TIME_OUT] = makeAny( (sal_Int32)0 );
 206     m_props[PREPARED_STATEMENT_MAX_ROWS] = makeAny( (sal_Int32)0 );
 207     m_props[PREPARED_STATEMENT_RESULT_SET_CONCURRENCY] = makeAny(
 208         com::sun::star::sdbc::ResultSetConcurrency::READ_ONLY );
 209     m_props[PREPARED_STATEMENT_RESULT_SET_TYPE] = makeAny(
 210         com::sun::star::sdbc::ResultSetType::SCROLL_INSENSITIVE );
 211
 212     splitSQL( m_stmt, m_splittedStatement );
 213     int elements = 0;
 214     for( int i = 0, max = m_splittedStatement.size(); i < max ; i ++ )
 215     {
 216         const OString &str = m_splittedStatement[i];
 217         // ignore quoted strings ....
 218         if( ! isQuoted( str ) )
 219         {
 220             // the ':' cannot be the first or the last part of the
 221             // token,
 222             // the ? cannot be the first part of the token , so we start
 223             // at one
 224             for( int index = 1 ; index < str.getLength() ; index ++ )
 225             {
 226                 if( str[index] == '?' ||
 227                     isNamedParameterStart( str , index )
 228                     )
 229                 {
 230                     elements ++;
 231                 }
 232             }
 233         }
 234     }
 235     m_vars = OStringVector ( elements );
 236 }
 237
 238 PreparedStatement::~PreparedStatement()
 239 {
 240     POSTGRE_TRACE( "dtor PreparedStatement" );
 241 }
 242
 243 void PreparedStatement::checkColumnIndex( sal_Int32 parameterIndex )
 244 {
 245     if( parameterIndex < 1 || parameterIndex > (sal_Int32) m_vars.size() )
 246     {
 247         OUStringBuffer buf( 128 );
 248         buf.appendAscii( "pq_preparedstatement: parameter index out of range (expected 1 to " );
 249         buf.append( (sal_Int32 ) m_vars.size() );
 250         buf.appendAscii( ", got " );
 251         buf.append( parameterIndex );
 252         buf.appendAscii( ", statement '" );
 253         buf.append( OStringToOUString( m_stmt, m_pSettings->encoding ) );
 254         buf.appendAscii( "')" );
 255         throw SQLException( buf.makeStringAndClear(), *this, OUString(), 1, Any () );
 256     }
 257 }
 258 void PreparedStatement::checkClosed() throw (SQLException, RuntimeException )
 259 {
 260     if( ! m_pSettings || ! m_pSettings->pConnection )
 261         throw SQLException(
 262             ASCII_STR("pq_driver: PreparedStatement or connection has already been closed !" ),
 263             *this, OUString(),1,Any());
 264 }
 265
 266 Any PreparedStatement::queryInterface( const Type & reqType ) throw (RuntimeException)
 267 {
 268     Any ret;
 269
 270     ret = OComponentHelper::queryInterface( reqType );
 271     if( ! ret.hasValue() )
 272         ret = ::cppu::queryInterface( reqType,
 273                                     static_cast< XWarningsSupplier * > ( this  ),
 274                                     static_cast< XPreparedStatement * > ( this ),
 275                                     static_cast< com::sun::star::sdbc::XResultSetMetaDataSupplier * > ( this ),
 276                                     static_cast< XParameters * > ( this ),
 277                                     static_cast< XCloseable * > ( this ),
 278                                     static_cast< XGeneratedResultSet * > ( this ),
 279                                     static_cast< XPropertySet * > ( this ),
 280                                     static_cast< XMultiPropertySet * > ( this ),
 281                                     static_cast< XFastPropertySet * > ( this ) );
 282     return ret;
 283 }
 284
 285
 286 Sequence< Type > PreparedStatement::getTypes() throw ( RuntimeException )
 287 {
 288     static cppu::OTypeCollection *pCollection;
 289     if( ! pCollection )
 290     {
 291         MutexGuard guard( osl::Mutex::getGlobalMutex() );
 292         if( !pCollection )
 293         {
 294             static cppu::OTypeCollection collection(
 295                 getCppuType( (Reference< XWarningsSupplier> *) 0 ),
 296                 getCppuType( (Reference< XPreparedStatement> *) 0 ),
 297                 getCppuType( (Reference< com::sun::star::sdbc::XResultSetMetaDataSupplier> *) 0 ),
 298                 getCppuType( (Reference< XParameters> *) 0 ),
 299                 getCppuType( (Reference< XCloseable> *) 0 ),
 300                 getCppuType( (Reference< XGeneratedResultSet> *) 0 ),
 301                 getCppuType( (Reference< XPropertySet >*) 0 ),
 302                 getCppuType( (Reference< XFastPropertySet > *) 0 ),
 303                 getCppuType( (Reference< XMultiPropertySet > *) 0 ),
 304                 OComponentHelper::getTypes());
 305             pCollection = &collection;
 306         }
 307     }
 308     return pCollection->getTypes();
 309 }
 310
 311 Sequence< sal_Int8> PreparedStatement::getImplementationId() throw ( RuntimeException )
 312 {
 313     static cppu::OImplementationId *pId;
 314     if( ! pId )
 315     {
 316         MutexGuard guard( osl::Mutex::getGlobalMutex() );
 317         if( ! pId )
 318         {
 319             static cppu::OImplementationId id(sal_False);
 320             pId = &id;
 321         }
 322     }
 323     return pId->getImplementationId();
 324 }
 325
 326 void PreparedStatement::close(  ) throw (SQLException, RuntimeException)
 327 {
 328     // let the connection die without acquired mutex !
 329     Reference< XConnection > r;
 330     Reference< XCloseable > resultSet;
 331     {
 332         MutexGuard guard( m_refMutex->mutex );
 333         m_pSettings = 0;
 334         r = m_connection;
 335         m_connection.clear();
 336
 337         resultSet = m_lastResultset;
 338         m_lastResultset.clear();
 339     }
 340     if( resultSet.is() )
 341     {
 342         resultSet->close();
 343     }
 344 }
 345
 346 void PreparedStatement::raiseSQLException(
 347     const char * errorMsg, const char *errorType )
 348     throw( SQLException )
 349 {
 350     OUStringBuffer buf(128);
 351     buf.appendAscii( "pq_driver: ");
 352     if( errorType )
 353     {
 354         buf.appendAscii( "[" );
 355         buf.appendAscii( errorType );
 356         buf.appendAscii( "]" );
 357     }
 358     buf.append(
 359         rtl::OUString( errorMsg, strlen(errorMsg) , m_pSettings->encoding ) );
 360     buf.appendAscii( " (caused by statement '" );
 361     buf.appendAscii( m_executedStatement );
 362     buf.appendAscii( "')" );
 363     OUString error = buf.makeStringAndClear();
 364     log( m_pSettings, LogLevel::ERROR, error );
 365     throw SQLException( buf.makeStringAndClear(), *this, OUString(), 1, Any() );
 366 }
 367
 368 Reference< XResultSet > PreparedStatement::executeQuery( )
 369         throw (SQLException, RuntimeException)
 370 {
 371     Reference< XCloseable > lastResultSet = m_lastResultset;
 372     if( lastResultSet.is() )
 373         lastResultSet->close();
 374
 375     if( ! execute( ) )
 376     {
 377         raiseSQLException(  "not a query" );
 378     }
 379     return Reference< XResultSet > ( m_lastResultset, com::sun::star::uno::UNO_QUERY );
 380 }
 381
 382 sal_Int32 PreparedStatement::executeUpdate( )
 383         throw (SQLException, RuntimeException)
 384 {
 385     if( execute( ) )
 386     {
 387         raiseSQLException( "not a command" );
 388     }
 389     return m_multipleResultUpdateCount;
 390 }
 391
 392 sal_Bool PreparedStatement::execute( )
 393         throw (SQLException, RuntimeException)
 394 {
 395     osl::MutexGuard guard( m_refMutex->mutex );
 396
 397     OStringBuffer buf( m_stmt.getLength() *2 );
 398
 399     int vars = 0;
 400     for( int i = 0 ; i < m_splittedStatement.size() ; i ++ )
 401     {
 402         const OString &str = m_splittedStatement[i];
 403 //         printf( "Splitted %d %s\n" , i , str.getStr() );
 404         if( isQuoted( str ) )
 405         {
 406             buf.append( str );
 407         }
 408         else
 409         {
 410             int start = 0,index;
 411             for( index = 1 ; index < str.getLength() ; index ++ )
 412             {
 413                 if( str[index] == '?' )
 414                 {
 415                     buf.append( str.getStr()+start, index - start );
 416                     buf.append( m_vars[vars] );
 417                     vars ++;
 418                     start =index+1;
 419                 }
 420                 else
 421                 {
 422                     if ( isNamedParameterStart( str, index ) )
 423                     {
 424                         buf.append( str.getStr()+start, index -start );
 425                         buf.append( m_vars[vars] );
 426
 427                         // skip to the end of the named parameter
 428                         for( ; index < str.getLength() &&
 429                                  ! ( isWhitespace( str[index] ) || isOperator( str[index] ) ) ; index ++ );
 430                         start = index;
 431                         vars ++;
 432                     }
 433                 }
 434             }
 435 //             if( index +1 >= str.getLength() )
 436 //             {
 437             buf.append( str.getStr() + start, index -start );
 438 //             }
 439         }
 440     }
 441
 442     m_executedStatement = buf.makeStringAndClear();
 443
 444     m_lastResultset.clear();
 445     m_lastTableInserted  = rtl::OUString();
 446
 447     struct CommandData data;
 448     data.refMutex = m_refMutex;
 449     data.ppSettings = &m_pSettings;
 450     data.pLastOidInserted = &m_lastOidInserted;
 451     data.pLastQuery = &m_lastQuery;
 452     data.pMultipleResultUpdateCount = &m_multipleResultUpdateCount;
 453     data.pMultipleResultAvailable = &m_multipleResultAvailable;
 454     data.pLastTableInserted = &m_lastTableInserted;
 455     data.pLastResultset = &m_lastResultset;
 456     data.owner = *this;
 457     data.tableSupplier = Reference< com::sun::star::sdbcx::XTablesSupplier >( m_connection, UNO_QUERY );
 458     data.concurrency = extractIntProperty( this, getStatics().RESULT_SET_CONCURRENCY );
 459
 460     return executePostgresCommand( m_executedStatement , &data );   // see pq_statement.cxx
 461 }
 462
 463 Reference< XConnection > PreparedStatement::getConnection(  )
 464         throw (SQLException, RuntimeException)
 465 {
 466     Reference< XConnection > ret;
 467     {
 468         MutexGuard guard( m_refMutex->mutex );
 469         checkClosed();
 470         ret = m_connection;
 471     }
 472     return ret;
 473 }
 474
 475
 476 void PreparedStatement::setNull( sal_Int32 parameterIndex, sal_Int32 sqlType )
 477     throw (SQLException, RuntimeException)
 478 {
 479     MutexGuard guard( m_refMutex->mutex );
 480     checkClosed();
 481     checkColumnIndex( parameterIndex );
 482     m_vars[parameterIndex-1] = OString( "NULL" );
 483 }
 484
 485 void PreparedStatement::setObjectNull(
 486     sal_Int32 parameterIndex, sal_Int32 sqlType, const ::rtl::OUString& typeName )
 487     throw (SQLException, RuntimeException)
 488 {
 489     MutexGuard guard( m_refMutex->mutex );
 490     checkClosed();
 491     checkColumnIndex( parameterIndex );
 492     m_vars[parameterIndex-1] = OString( "NULL" );
 493 }
 494
 495
 496 void PreparedStatement::setBoolean( sal_Int32 parameterIndex, sal_Bool x )
 497     throw (SQLException, RuntimeException)
 498 {
 499     MutexGuard guard(m_refMutex->mutex );
 500     checkClosed();
 501     checkColumnIndex( parameterIndex );
 502     if( x )
 503         m_vars[parameterIndex-1] = OString( "'t'" );
 504     else
 505         m_vars[parameterIndex-1] = OString( "'f'" );
 506 }
 507
 508 void PreparedStatement::setByte( sal_Int32 parameterIndex, sal_Int8 x )
 509     throw (SQLException, RuntimeException)
 510 {
 511     setInt(parameterIndex,x);
 512 }
 513
 514 void PreparedStatement::setShort( sal_Int32 parameterIndex, sal_Int16 x )
 515     throw (SQLException, RuntimeException)
 516 {
 517     setInt(parameterIndex, x );
 518 }
 519
 520 void PreparedStatement::setInt( sal_Int32 parameterIndex, sal_Int32 x )
 521     throw (SQLException, RuntimeException)
 522 {
 523 //     printf( "setString %d %d\n ",  parameterIndex, x);
 524     MutexGuard guard(m_refMutex->mutex );
 525     checkClosed();
 526     checkColumnIndex( parameterIndex );
 527     OStringBuffer buf( 20 );
 528     buf.append( "'" );
 529     buf.append( (sal_Int32) x );
 530     buf.append( "'" );
 531     m_vars[parameterIndex-1] = buf.makeStringAndClear();
 532 }
 533
 534 void PreparedStatement::setLong( sal_Int32 parameterIndex, sal_Int64 x )
 535     throw (SQLException, RuntimeException)
 536 {
 537     MutexGuard guard(m_refMutex->mutex );
 538     checkClosed();
 539     checkColumnIndex( parameterIndex );
 540     OStringBuffer buf( 20 );
 541     buf.append( "'" );
 542     buf.append( (sal_Int64) x );
 543     buf.append( "'" );
 544     m_vars[parameterIndex-1] = buf.makeStringAndClear();
 545 }
 546
 547 void PreparedStatement::setFloat( sal_Int32 parameterIndex, float x )
 548     throw (SQLException, RuntimeException)
 549 {
 550     MutexGuard guard(m_refMutex->mutex );
 551     checkClosed();
 552     checkColumnIndex( parameterIndex );
 553     OStringBuffer buf( 20 );
 554     buf.append( "'" );
 555     buf.append( x );
 556     buf.append( "'" );
 557     m_vars[parameterIndex-1] = buf.makeStringAndClear();
 558 }
 559
 560 void PreparedStatement::setDouble( sal_Int32 parameterIndex, double x )
 561     throw (SQLException, RuntimeException)
 562 {
 563     MutexGuard guard(m_refMutex->mutex );
 564     checkClosed();
 565     checkColumnIndex( parameterIndex );
 566     OStringBuffer buf( 20 );
 567     buf.append( "'" );
 568     buf.append( x );
 569     buf.append( "'" );
 570     m_vars[parameterIndex-1] = buf.makeStringAndClear();
 571 }
 572
 573 void PreparedStatement::setString( sal_Int32 parameterIndex, const ::rtl::OUString& x )
 574     throw (SQLException, RuntimeException)
 575 {
 576 //     printf( "setString %d %s\n ", parameterIndex,
 577 //             OUStringToOString( x , RTL_TEXTENCODING_ASCII_US ).getStr());
 578     MutexGuard guard(m_refMutex->mutex );
 579     checkClosed();
 580     checkColumnIndex( parameterIndex );
 581     OStringBuffer buf( 20 );
 582     buf.append( "'" );
 583     OString y = OUStringToOString( x, m_pSettings->encoding );
 584     buf.ensureCapacity( y.getLength() * 2 + 2 );
 585     int len = PQescapeString( ((char*)buf.getStr())+1, y.getStr() , y.getLength() );
 586     buf.setLength( 1 + len );
 587     buf.append( "'" );
 588     m_vars[parameterIndex-1] = buf.makeStringAndClear();
 589 }
 590
 591 void PreparedStatement::setBytes(
 592     sal_Int32 parameterIndex, const Sequence< sal_Int8 >& x )
 593     throw (SQLException, RuntimeException)
 594 {
 595     MutexGuard guard(m_refMutex->mutex );
 596     checkClosed();
 597     checkColumnIndex( parameterIndex );
 598     OStringBuffer buf( 20 );
 599     buf.append( "'" );
 600     size_t len;
 601     unsigned char * escapedString =
 602         PQescapeBytea( (unsigned char *)x.getConstArray(), x.getLength(), &len);
 603     if( ! escapedString )
 604     {
 605         throw SQLException(
 606             ASCII_STR("pq_preparedstatement.setBytes: Error during converting bytesequence to an SQL conform string" ),
 607             *this, OUString(), 1, Any() );
 608     }
 609     buf.append( (const sal_Char *)escapedString, len -1 );
 610     free( escapedString );
 611     buf.append( "'" );
 612     m_vars[parameterIndex-1] = buf.makeStringAndClear();
 613 }
 614
 615
 616 void PreparedStatement::setDate( sal_Int32 parameterIndex, const ::com::sun::star::util::Date& x )
 617     throw (SQLException, RuntimeException)
 618 {
 619     setString( parameterIndex, date2String( x ) );
 620 }
 621
 622 void PreparedStatement::setTime( sal_Int32 parameterIndex, const ::com::sun::star::util::Time& x )
 623     throw (SQLException, RuntimeException)
 624 {
 625     setString( parameterIndex, time2String( x ) );
 626 }
 627
 628 void PreparedStatement::setTimestamp(
 629     sal_Int32 parameterIndex, const ::com::sun::star::util::DateTime& x )
 630     throw (SQLException, RuntimeException)
 631 {
 632     setString( parameterIndex, dateTime2String( x ) );
 633 }
 634
 635 void PreparedStatement::setBinaryStream(
 636     sal_Int32 parameterIndex,
 637     const Reference< ::com::sun::star::io::XInputStream >& x,
 638     sal_Int32 length )
 639     throw (SQLException, RuntimeException)
 640 {
 641     throw SQLException(
 642         ASCII_STR( "pq_preparedstatement: setBinaryStream not implemented" ),
 643         *this, OUString(), 1, Any () );
 644 }
 645
 646 void PreparedStatement::setCharacterStream(
 647     sal_Int32 parameterIndex,
 648     const Reference< ::com::sun::star::io::XInputStream >& x,
 649     sal_Int32 length )
 650     throw (SQLException, RuntimeException)
 651 {
 652     throw SQLException(
 653         ASCII_STR( "pq_preparedstatement: setCharacterStream not implemented" ),
 654         *this, OUString(), 1, Any () );
 655 }
 656
 657 void PreparedStatement::setObject( sal_Int32 parameterIndex, const Any& x )
 658     throw (SQLException, RuntimeException)
 659 {
 660     if( ! implSetObject( this, parameterIndex, x ))
 661     {
 662         OUStringBuffer buf;
 663         buf.append( ASCII_STR("pq_preparedstatement::setObject: can't convert value of type " ) );
 664         buf.append( x.getValueTypeName() );
 665         throw SQLException( buf.makeStringAndClear(), *this, OUString(), 1, Any () );
 666     }
 667 }
 668
 669 void PreparedStatement::setObjectWithInfo(
 670     sal_Int32 parameterIndex,
 671     const Any& x,
 672     sal_Int32 targetSqlType,
 673     sal_Int32 scale )
 674     throw (SQLException, RuntimeException)
 675 {
 676     if( com::sun::star::sdbc::DataType::DECIMAL == targetSqlType ||
 677         com::sun::star::sdbc::DataType::NUMERIC == targetSqlType )
 678     {
 679         double myDouble;
 680         OUString myString;
 681         if( x >>= myDouble )
 682         {
 683             myString = OUString::valueOf( myDouble );
 684         }
 685         else
 686         {
 687             x >>= myString;
 688         }
 689         if( myString.getLength() )
 690         {
 691 //              printf( "setObjectWithInfo %s\n", OUStringToOString(myString,RTL_TEXTENCODING_ASCII_US).getStr());
 692             setString( parameterIndex, myString );
 693         }
 694         else
 695         {
 696             OUStringBuffer buf;
 697             buf.append( ASCII_STR("pq_preparedstatement::setObjectWithInfo: can't convert value of type " ) );
 698             buf.append( x.getValueTypeName() );
 699             buf.append( ASCII_STR(" to type DECIMAL or NUMERIC" ) );
 700             throw SQLException( buf.makeStringAndClear(), *this, OUString(), 1, Any () );
 701         }
 702     }
 703     else
 704     {
 705         setObject( parameterIndex, x );
 706     }
 707
 708 }
 709
 710 void PreparedStatement::setRef(
 711     sal_Int32 parameterIndex,
 712     const Reference< XRef >& x )
 713     throw (SQLException, RuntimeException)
 714 {
 715     throw SQLException(
 716         ASCII_STR( "pq_preparedstatement: setRef not implemented" ),
 717         *this, OUString(), 1, Any () );
 718
 719 }
 720
 721 void PreparedStatement::setBlob(
 722     sal_Int32 parameterIndex,
 723     const Reference< XBlob >& x )
 724     throw (SQLException, RuntimeException)
 725 {
 726     throw SQLException(
 727         ASCII_STR( "pq_preparedstatement: setBlob not implemented" ),
 728         *this, OUString(), 1, Any () );
 729 }
 730
 731 void PreparedStatement::setClob(
 732     sal_Int32 parameterIndex,
 733     const Reference< XClob >& x )
 734     throw (SQLException, RuntimeException)
 735 {
 736     throw SQLException(
 737         ASCII_STR( "pq_preparedstatement: setClob not implemented" ),
 738         *this, OUString(), 1, Any () );
 739 }
 740
 741 void PreparedStatement::setArray(
 742     sal_Int32 parameterIndex,
 743     const Reference< XArray >& x )
 744     throw (SQLException, RuntimeException)
 745 {
 746     setString( parameterIndex, array2String( x->getArray( 0 ) ) );
 747
 748 //     throw SQLException(
 749 //         ASCII_STR( "pq_preparedstatement: setArray not implemented" ),
 750 //         *this, OUString(), 1, Any () );
 751 }
 752
 753 void PreparedStatement::clearParameters(  )
 754     throw (SQLException, RuntimeException)
 755 {
 756     MutexGuard guard(m_refMutex->mutex );
 757     m_vars = OStringVector ( m_vars.size() );
 758 }
 759
 760 Any PreparedStatement::getWarnings(  )
 761         throw (SQLException,RuntimeException)
 762 {
 763     return Any();
 764 }
 765
 766 void PreparedStatement::clearWarnings(  )
 767         throw (SQLException, RuntimeException)
 768 {
 769 }
 770
 771 Reference< ::com::sun::star::sdbc::XResultSetMetaData > PreparedStatement::getMetaData()
 772             throw (SQLException,RuntimeException)
 773 {
 774     Reference< com::sun::star::sdbc::XResultSetMetaData > ret;
 775     Reference< com::sun::star::sdbc::XResultSetMetaDataSupplier > supplier( m_lastResultset, UNO_QUERY );
 776     if( supplier.is() )
 777         ret = supplier->getMetaData();
 778     return ret;
 779 }
 780
 781 ::cppu::IPropertyArrayHelper & PreparedStatement::getInfoHelper()
 782 {
 783     return getPreparedStatementPropertyArrayHelper();
 784 }
 785
 786
 787 sal_Bool PreparedStatement::convertFastPropertyValue(
 788                 Any & rConvertedValue, Any & rOldValue, sal_Int32 nHandle, const Any& rValue )
 789                 throw (IllegalArgumentException)
 790 {
 791     sal_Bool bRet;
 792     rOldValue = m_props[nHandle];
 793     switch( nHandle )
 794     {
 795     case PREPARED_STATEMENT_CURSOR_NAME:
 796     {
 797         OUString val;
 798         bRet = ( rValue >>= val );
 799         rConvertedValue = makeAny( val );
 800         break;
 801     }
 802     case PREPARED_STATEMENT_ESCAPE_PROCESSING:
 803     {
 804         sal_Bool val;
 805         bRet = ( rValue >>= val );
 806         rConvertedValue = makeAny( val );
 807         break;
 808     }
 809     case PREPARED_STATEMENT_FETCH_DIRECTION:
 810     case PREPARED_STATEMENT_FETCH_SIZE:
 811     case PREPARED_STATEMENT_MAX_FIELD_SIZE:
 812     case PREPARED_STATEMENT_MAX_ROWS:
 813     case PREPARED_STATEMENT_QUERY_TIME_OUT:
 814     case PREPARED_STATEMENT_RESULT_SET_CONCURRENCY:
 815     case PREPARED_STATEMENT_RESULT_SET_TYPE:
 816     {
 817         sal_Int32 val;
 818         bRet = ( rValue >>= val );
 819         rConvertedValue = makeAny( val );
 820         break;
 821     }
 822     default:
 823     {
 824         OUStringBuffer buf(128);
 825         buf.appendAscii( "pq_statement: Invalid property handle (" );
 826         buf.append( nHandle );
 827         buf.appendAscii( ")" );
 828         throw IllegalArgumentException( buf.makeStringAndClear(), *this, 2 );
 829     }
 830     }
 831     return bRet;
 832 }
 833
 834
 835 void PreparedStatement::setFastPropertyValue_NoBroadcast(
 836     sal_Int32 nHandle,const Any& rValue ) throw (Exception)
 837 {
 838     m_props[nHandle] = rValue;
 839 }
 840
 841 void PreparedStatement::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
 842 {
 843     rValue = m_props[nHandle];
 844 }
 845
 846 Reference < XPropertySetInfo >  PreparedStatement::getPropertySetInfo()
 847         throw(RuntimeException)
 848 {
 849     return OPropertySetHelper::createPropertySetInfo( getPreparedStatementPropertyArrayHelper() );
 850 }
 851
 852 void PreparedStatement::disposing()
 853 {
 854     close();
 855 }
 856
 857
 858 Reference< XResultSet > PreparedStatement::getResultSet(  )
 859     throw (::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 860 {
 861     return Reference< XResultSet > ( m_lastResultset, com::sun::star::uno::UNO_QUERY );
 862 }
 863 sal_Int32 PreparedStatement::getUpdateCount(  )
 864     throw (::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 865 {
 866     return m_multipleResultUpdateCount;
 867 }
 868 sal_Bool PreparedStatement::getMoreResults(  )
 869     throw (::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 870 {
 871     return sal_False;
 872 }
 873
 874 Reference< XResultSet > PreparedStatement::getGeneratedValues(  )
 875         throw (SQLException, RuntimeException)
 876 {
 877     osl::MutexGuard guard( m_refMutex->mutex );
 878     return getGeneratedValuesFromLastInsert(
 879         m_pSettings, m_connection, m_lastOidInserted, m_lastTableInserted, m_lastQuery );
 880 }
 881
 882
 883 }
 884