dbaccess/source/core/api/preparedstatement.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: preparedstatement.cxx,v $
  10  * $Revision: 1.16 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_dbaccess.hxx"
  33 #ifndef _DBA_COREAPI_PREPAREDSTATEMENT_HXX_
  34 #include <preparedstatement.hxx>
  35 #endif
  36 #ifndef _DBA_COREAPI_RESULTSET_HXX_
  37 #include <resultset.hxx>
  38 #endif
  39 #ifndef _DBA_COREAPI_RESULTCOLUMN_HXX_
  40 #include <resultcolumn.hxx>
  41 #endif
  42 #ifndef DBACCESS_SHARED_DBASTRINGS_HRC
  43 #include "dbastrings.hrc"
  44 #endif
  45 #ifndef _COM_SUN_STAR_LANG_DISPOSEDEXCEPTION_HPP_
  46 #include <com/sun/star/lang/DisposedException.hpp>
  47 #endif
  48 #ifndef _COM_SUN_STAR_SDBC_XCONNECTION_HPP_
  49 #include <com/sun/star/sdbc/XConnection.hpp>
  50 #endif
  51 #ifndef _COM_SUN_STAR_SDBC_XDATABASEMETADATA_HPP_
  52 #include <com/sun/star/sdbc/XDatabaseMetaData.hpp>
  53 #endif
  54 #ifndef _COMPHELPER_SEQUENCE_HXX_
  55 #include <comphelper/sequence.hxx>
  56 #endif
  57 #ifndef _CPPUHELPER_TYPEPROVIDER_HXX_
  58 #include <cppuhelper/typeprovider.hxx>
  59 #endif
  60 #ifndef _COMPHELPER_PROPERTY_HXX_
  61 #include <comphelper/property.hxx>
  62 #endif
  63 #ifndef _TOOLS_DEBUG_HXX //autogen
  64 #include <tools/debug.hxx>
  65 #endif
  66
  67 using namespace ::com::sun::star::sdbc;
  68 using namespace ::com::sun::star::sdbcx;
  69 using namespace ::com::sun::star::beans;
  70 using namespace ::com::sun::star::uno;
  71 using namespace ::com::sun::star::lang;
  72 using namespace ::cppu;
  73 using namespace ::osl;
  74 using namespace dbaccess;
  75
  76 DBG_NAME(OPreparedStatement)
  77
  78 //--------------------------------------------------------------------------
  79 OPreparedStatement::OPreparedStatement(const Reference< XConnection > & _xConn,
  80                                       const Reference< XInterface > & _xStatement)
  81                    :OStatementBase(_xConn, _xStatement)
  82 {
  83     DBG_CTOR(OPreparedStatement, NULL);
  84     m_xAggregateAsParameters = Reference< XParameters >( m_xAggregateAsSet, UNO_QUERY_THROW );
  85
  86     Reference<XDatabaseMetaData> xMeta = _xConn->getMetaData();
  87     m_pColumns = new OColumns(*this, m_aMutex, xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers(),::std::vector< ::rtl::OUString>(), NULL,NULL);
  88 }
  89
  90 //--------------------------------------------------------------------------
  91 OPreparedStatement::~OPreparedStatement()
  92 {
  93     m_pColumns->acquire();
  94     m_pColumns->disposing();
  95     delete m_pColumns;
  96
  97     DBG_DTOR(OPreparedStatement, NULL);
  98 }
  99
 100 // com::sun::star::lang::XTypeProvider
 101 //--------------------------------------------------------------------------
 102 Sequence< Type > OPreparedStatement::getTypes() throw (RuntimeException)
 103 {
 104     OTypeCollection aTypes(::getCppuType( (const Reference< XServiceInfo > *)0 ),
 105                            ::getCppuType( (const Reference< XPreparedStatement > *)0 ),
 106                            ::getCppuType( (const Reference< XParameters > *)0 ),
 107                            ::getCppuType( (const Reference< XResultSetMetaDataSupplier > *)0 ),
 108                            ::getCppuType( (const Reference< XColumnsSupplier > *)0 ),
 109                             OStatementBase::getTypes() );
 110
 111     return aTypes.getTypes();
 112 }
 113
 114 //--------------------------------------------------------------------------
 115 Sequence< sal_Int8 > OPreparedStatement::getImplementationId() throw (RuntimeException)
 116 {
 117         static OImplementationId * pId = 0;
 118     if (! pId)
 119     {
 120         MutexGuard aGuard( Mutex::getGlobalMutex() );
 121         if (! pId)
 122         {
 123             static OImplementationId aId;
 124             pId = &aId;
 125         }
 126     }
 127     return pId->getImplementationId();
 128 }
 129
 130 // com::sun::star::uno::XInterface
 131 //--------------------------------------------------------------------------
 132 Any OPreparedStatement::queryInterface( const Type & rType ) throw (RuntimeException)
 133 {
 134     Any aIface = OStatementBase::queryInterface( rType );
 135     if (!aIface.hasValue())
 136         aIface = ::cppu::queryInterface(
 137                     rType,
 138                     static_cast< XServiceInfo * >( this ),
 139                     static_cast< XParameters * >( this ),
 140                     static_cast< XColumnsSupplier * >( this ),
 141                     static_cast< XResultSetMetaDataSupplier * >( this ),
 142                     static_cast< XPreparedBatchExecution * >( this ),
 143                     static_cast< XMultipleResults * >( this ),
 144                     static_cast< XPreparedStatement * >( this ));
 145     return aIface;
 146 }
 147
 148 //--------------------------------------------------------------------------
 149 void OPreparedStatement::acquire() throw ()
 150 {
 151     OStatementBase::acquire();
 152 }
 153
 154 //--------------------------------------------------------------------------
 155 void OPreparedStatement::release() throw ()
 156 {
 157     OStatementBase::release();
 158 }
 159
 160 // XServiceInfo
 161 //------------------------------------------------------------------------------
 162 rtl::OUString OPreparedStatement::getImplementationName(  ) throw(RuntimeException)
 163 {
 164     return rtl::OUString::createFromAscii("com.sun.star.sdb.OPreparedStatement");
 165 }
 166
 167 //------------------------------------------------------------------------------
 168 sal_Bool OPreparedStatement::supportsService( const ::rtl::OUString& _rServiceName ) throw (RuntimeException)
 169 {
 170     return ::comphelper::findValue(getSupportedServiceNames(), _rServiceName, sal_True).getLength() != 0;
 171 }
 172
 173 //------------------------------------------------------------------------------
 174 Sequence< ::rtl::OUString > OPreparedStatement::getSupportedServiceNames(  ) throw (RuntimeException)
 175 {
 176     Sequence< ::rtl::OUString > aSNS( 2 );
 177     aSNS.getArray()[0] = SERVICE_SDBC_PREPAREDSTATEMENT;
 178     aSNS.getArray()[1] = SERVICE_SDB_PREPAREDSTATMENT;
 179     return aSNS;
 180 }
 181
 182 // OComponentHelper
 183 //------------------------------------------------------------------------------
 184 void OPreparedStatement::disposing()
 185 {
 186     {
 187         MutexGuard aGuard(m_aMutex);
 188         m_pColumns->disposing();
 189         m_xAggregateAsParameters = NULL;
 190     }
 191     OStatementBase::disposing();
 192 }
 193
 194 // ::com::sun::star::sdbcx::XColumnsSupplier
 195 //------------------------------------------------------------------------------
 196 Reference< ::com::sun::star::container::XNameAccess > OPreparedStatement::getColumns(void) throw( RuntimeException )
 197 {
 198     MutexGuard aGuard(m_aMutex);
 199     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 200
 201     // do we have to populate the columns
 202     if (!m_pColumns->isInitialized())
 203     {
 204         try
 205         {
 206             // get the metadata
 207             Reference< XResultSetMetaData > xMetaData = Reference< XResultSetMetaDataSupplier >(m_xAggregateAsSet, UNO_QUERY)->getMetaData();
 208             // do we have columns
 209             if ( xMetaData.is() )
 210             {
 211                 Reference< XDatabaseMetaData > xDBMeta;
 212                 Reference< XConnection > xConn( getConnection() );
 213                 if ( xConn.is() )
 214                     xDBMeta = xConn->getMetaData();
 215
 216                 for (sal_Int32 i = 0, nCount = xMetaData->getColumnCount(); i < nCount; ++i)
 217                 {
 218                     // retrieve the name of the column
 219                     rtl::OUString aName = xMetaData->getColumnName(i + 1);
 220                     OResultColumn* pColumn = new OResultColumn(xMetaData, i + 1, xDBMeta);
 221                     m_pColumns->append(aName, pColumn);
 222                 }
 223             }
 224         }
 225         catch (SQLException)
 226         {
 227         }
 228         m_pColumns->setInitialized();
 229     }
 230     return m_pColumns;
 231 }
 232
 233 // XResultSetMetaDataSupplier
 234 //------------------------------------------------------------------------------
 235 Reference< XResultSetMetaData > OPreparedStatement::getMetaData(void) throw( SQLException, RuntimeException )
 236 {
 237     MutexGuard aGuard(m_aMutex);
 238     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 239     return Reference< XResultSetMetaDataSupplier >(m_xAggregateAsSet, UNO_QUERY)->getMetaData();
 240 }
 241
 242 // XPreparedStatement
 243 //------------------------------------------------------------------------------
 244 Reference< XResultSet >  OPreparedStatement::executeQuery() throw( SQLException, RuntimeException )
 245 {
 246     MutexGuard aGuard(m_aMutex);
 247     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 248
 249     disposeResultSet();
 250
 251     Reference< XResultSet > xResultSet;
 252     Reference< XResultSet > xDrvResultSet = Reference< XPreparedStatement >(m_xAggregateAsSet, UNO_QUERY)->executeQuery();
 253     if (xDrvResultSet.is())
 254     {
 255         xResultSet = new OResultSet(xDrvResultSet, *this, m_pColumns->isCaseSensitive());
 256
 257         // keep the resultset weak
 258         m_aResultSet = xResultSet;
 259     }
 260     return xResultSet;
 261 }
 262
 263 //------------------------------------------------------------------------------
 264 sal_Int32 OPreparedStatement::executeUpdate() throw( SQLException, RuntimeException )
 265 {
 266     MutexGuard aGuard(m_aMutex);
 267     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 268
 269     disposeResultSet();
 270
 271     return Reference< XPreparedStatement >(m_xAggregateAsSet, UNO_QUERY)->executeUpdate();
 272 }
 273
 274 //------------------------------------------------------------------------------
 275 sal_Bool OPreparedStatement::execute() throw( SQLException, RuntimeException )
 276 {
 277     MutexGuard aGuard(m_aMutex);
 278     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 279
 280     disposeResultSet();
 281     return Reference< XPreparedStatement >(m_xAggregateAsSet, UNO_QUERY)->execute();
 282 }
 283
 284 //------------------------------------------------------------------------------
 285 Reference< XConnection > OPreparedStatement::getConnection(void) throw( SQLException, RuntimeException )
 286 {
 287     return Reference< XConnection > (m_xParent, UNO_QUERY);
 288 }
 289
 290 // XParameters
 291 //------------------------------------------------------------------------------
 292 void SAL_CALL OPreparedStatement::setNull( sal_Int32 parameterIndex, sal_Int32 sqlType ) throw(SQLException, RuntimeException)
 293 {
 294     MutexGuard aGuard(m_aMutex);
 295     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 296
 297     m_xAggregateAsParameters->setNull(parameterIndex, sqlType);
 298 }
 299
 300 //------------------------------------------------------------------------------
 301 void SAL_CALL OPreparedStatement::setObjectNull( sal_Int32 parameterIndex, sal_Int32 sqlType, const ::rtl::OUString& typeName ) throw(SQLException, RuntimeException)
 302 {
 303     MutexGuard aGuard(m_aMutex);
 304     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 305
 306     m_xAggregateAsParameters->setObjectNull(parameterIndex, sqlType, typeName);
 307 }
 308
 309 //------------------------------------------------------------------------------
 310 void SAL_CALL OPreparedStatement::setBoolean( sal_Int32 parameterIndex, sal_Bool x ) throw(SQLException, RuntimeException)
 311 {
 312     MutexGuard aGuard(m_aMutex);
 313     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 314
 315     m_xAggregateAsParameters->setBoolean(parameterIndex, x);
 316 }
 317
 318 //------------------------------------------------------------------------------
 319 void SAL_CALL OPreparedStatement::setByte( sal_Int32 parameterIndex, sal_Int8 x ) throw(SQLException, RuntimeException)
 320 {
 321     MutexGuard aGuard(m_aMutex);
 322     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 323
 324     m_xAggregateAsParameters->setByte(parameterIndex, x);
 325 }
 326
 327 //------------------------------------------------------------------------------
 328 void SAL_CALL OPreparedStatement::setShort( sal_Int32 parameterIndex, sal_Int16 x ) throw(SQLException, RuntimeException)
 329 {
 330     MutexGuard aGuard(m_aMutex);
 331     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 332
 333     m_xAggregateAsParameters->setShort(parameterIndex, x);
 334 }
 335
 336 //------------------------------------------------------------------------------
 337 void SAL_CALL OPreparedStatement::setInt( sal_Int32 parameterIndex, sal_Int32 x ) throw(SQLException, RuntimeException)
 338 {
 339     MutexGuard aGuard(m_aMutex);
 340     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 341
 342     m_xAggregateAsParameters->setInt(parameterIndex, x);
 343 }
 344
 345 //------------------------------------------------------------------------------
 346 void SAL_CALL OPreparedStatement::setLong( sal_Int32 parameterIndex, sal_Int64 x ) throw(SQLException, RuntimeException)
 347 {
 348     MutexGuard aGuard(m_aMutex);
 349     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 350
 351     m_xAggregateAsParameters->setLong(parameterIndex, x);
 352 }
 353
 354 //------------------------------------------------------------------------------
 355 void SAL_CALL OPreparedStatement::setFloat( sal_Int32 parameterIndex, float x ) throw(SQLException, RuntimeException)
 356 {
 357     MutexGuard aGuard(m_aMutex);
 358     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 359
 360     m_xAggregateAsParameters->setFloat(parameterIndex, x);
 361 }
 362
 363 //------------------------------------------------------------------------------
 364 void SAL_CALL OPreparedStatement::setDouble( sal_Int32 parameterIndex, double x ) throw(SQLException, RuntimeException)
 365 {
 366     MutexGuard aGuard(m_aMutex);
 367     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 368
 369     m_xAggregateAsParameters->setDouble(parameterIndex, x);
 370 }
 371
 372 //------------------------------------------------------------------------------
 373 void SAL_CALL OPreparedStatement::setString( sal_Int32 parameterIndex, const ::rtl::OUString& x ) throw(SQLException, RuntimeException)
 374 {
 375     MutexGuard aGuard(m_aMutex);
 376     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 377
 378     m_xAggregateAsParameters->setString(parameterIndex, x);
 379 }
 380
 381 //------------------------------------------------------------------------------
 382 void SAL_CALL OPreparedStatement::setBytes( sal_Int32 parameterIndex, const Sequence< sal_Int8 >& x ) throw(SQLException, RuntimeException)
 383 {
 384     MutexGuard aGuard(m_aMutex);
 385     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 386
 387     m_xAggregateAsParameters->setBytes(parameterIndex, x);
 388 }
 389
 390 //------------------------------------------------------------------------------
 391 void SAL_CALL OPreparedStatement::setDate( sal_Int32 parameterIndex, const ::com::sun::star::util::Date& x ) throw(SQLException, RuntimeException)
 392 {
 393     MutexGuard aGuard(m_aMutex);
 394     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 395
 396     m_xAggregateAsParameters->setDate(parameterIndex, x);
 397 }
 398
 399 //------------------------------------------------------------------------------
 400 void SAL_CALL OPreparedStatement::setTime( sal_Int32 parameterIndex, const ::com::sun::star::util::Time& x ) throw(SQLException, RuntimeException)
 401 {
 402     MutexGuard aGuard(m_aMutex);
 403     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 404
 405     m_xAggregateAsParameters->setTime(parameterIndex, x);
 406 }
 407
 408 //------------------------------------------------------------------------------
 409 void SAL_CALL OPreparedStatement::setTimestamp( sal_Int32 parameterIndex, const ::com::sun::star::util::DateTime& x ) throw(SQLException, RuntimeException)
 410 {
 411     MutexGuard aGuard(m_aMutex);
 412     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 413
 414     m_xAggregateAsParameters->setTimestamp(parameterIndex, x);
 415 }
 416
 417 //------------------------------------------------------------------------------
 418 void SAL_CALL OPreparedStatement::setBinaryStream( sal_Int32 parameterIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
 419 {
 420     MutexGuard aGuard(m_aMutex);
 421     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 422
 423     m_xAggregateAsParameters->setBinaryStream(parameterIndex, x, length);
 424 }
 425
 426 //------------------------------------------------------------------------------
 427 void SAL_CALL OPreparedStatement::setCharacterStream( sal_Int32 parameterIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
 428 {
 429     MutexGuard aGuard(m_aMutex);
 430     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 431
 432     m_xAggregateAsParameters->setCharacterStream(parameterIndex, x, length);
 433 }
 434
 435 //------------------------------------------------------------------------------
 436 void SAL_CALL OPreparedStatement::setObject( sal_Int32 parameterIndex, const Any& x ) throw(SQLException, RuntimeException)
 437 {
 438     MutexGuard aGuard(m_aMutex);
 439     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 440
 441     m_xAggregateAsParameters->setObject(parameterIndex, x);
 442 }
 443
 444 //------------------------------------------------------------------------------
 445 void SAL_CALL OPreparedStatement::setObjectWithInfo( sal_Int32 parameterIndex, const Any& x, sal_Int32 targetSqlType, sal_Int32 scale ) throw(SQLException, RuntimeException)
 446 {
 447     MutexGuard aGuard(m_aMutex);
 448     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 449
 450     m_xAggregateAsParameters->setObjectWithInfo(parameterIndex, x, targetSqlType, scale);
 451 }
 452
 453 //------------------------------------------------------------------------------
 454 void SAL_CALL OPreparedStatement::setRef( sal_Int32 parameterIndex, const Reference< XRef >& x ) throw(SQLException, RuntimeException)
 455 {
 456     MutexGuard aGuard(m_aMutex);
 457     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 458
 459     m_xAggregateAsParameters->setRef(parameterIndex, x);
 460 }
 461
 462 //------------------------------------------------------------------------------
 463 void SAL_CALL OPreparedStatement::setBlob( sal_Int32 parameterIndex, const Reference< XBlob >& x ) throw(SQLException, RuntimeException)
 464 {
 465     MutexGuard aGuard(m_aMutex);
 466     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 467
 468     m_xAggregateAsParameters->setBlob(parameterIndex, x);
 469 }
 470
 471 //------------------------------------------------------------------------------
 472 void SAL_CALL OPreparedStatement::setClob( sal_Int32 parameterIndex, const Reference< XClob >& x ) throw(SQLException, RuntimeException)
 473 {
 474     MutexGuard aGuard(m_aMutex);
 475     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 476
 477     m_xAggregateAsParameters->setClob(parameterIndex, x);
 478 }
 479
 480 //------------------------------------------------------------------------------
 481 void SAL_CALL OPreparedStatement::setArray( sal_Int32 parameterIndex, const Reference< XArray >& x ) throw(SQLException, RuntimeException)
 482 {
 483     MutexGuard aGuard(m_aMutex);
 484     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 485
 486     m_xAggregateAsParameters->setArray(parameterIndex, x);
 487 }
 488
 489 //------------------------------------------------------------------------------
 490 void SAL_CALL OPreparedStatement::clearParameters(  ) throw(SQLException, RuntimeException)
 491 {
 492     MutexGuard aGuard(m_aMutex);
 493     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 494
 495     m_xAggregateAsParameters->clearParameters();
 496 }
 497