dbaccess/source/core/api/preparedstatement.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "dbastrings.hrc"
  22
  23 #include <com/sun/star/lang/DisposedException.hpp>
  24 #include <com/sun/star/sdbc/XConnection.hpp>
  25 #include <com/sun/star/sdbc/XDatabaseMetaData.hpp>
  26
  27 #include <comphelper/property.hxx>
  28 #include <comphelper/sequence.hxx>
  29 #include <cppuhelper/supportsservice.hxx>
  30 #include <cppuhelper/queryinterface.hxx>
  31 #include <cppuhelper/typeprovider.hxx>
  32 #include <preparedstatement.hxx>
  33 #include <resultcolumn.hxx>
  34 #include <resultset.hxx>
  35 #include <tools/debug.hxx>
  36 #include <tools/diagnose_ex.h>
  37
  38 using namespace ::com::sun::star::sdbc;
  39 using namespace ::com::sun::star::sdbcx;
  40 using namespace ::com::sun::star::beans;
  41 using namespace ::com::sun::star::uno;
  42 using namespace ::com::sun::star::lang;
  43 using namespace ::cppu;
  44 using namespace ::osl;
  45 using namespace dbaccess;
  46
  47
  48 OPreparedStatement::OPreparedStatement(const Reference< XConnection > & _xConn,
  49                                       const Reference< XInterface > & _xStatement)
  50                    :OStatementBase(_xConn, _xStatement)
  51 {
  52     m_xAggregateAsParameters = Reference< XParameters >( m_xAggregateAsSet, UNO_QUERY_THROW );
  53
  54     Reference<XDatabaseMetaData> xMeta = _xConn->getMetaData();
  55     m_pColumns = new OColumns(*this, m_aMutex, xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers(),::std::vector< OUString>(), NULL,NULL);
  56 }
  57
  58 OPreparedStatement::~OPreparedStatement()
  59 {
  60     m_pColumns->acquire();
  61     m_pColumns->disposing();
  62     delete m_pColumns;
  63
  64 }
  65
  66 // com::sun::star::lang::XTypeProvider
  67 Sequence< Type > OPreparedStatement::getTypes() throw (RuntimeException, std::exception)
  68 {
  69     OTypeCollection aTypes(cppu::UnoType<XServiceInfo>::get(),
  70                            cppu::UnoType<XPreparedStatement>::get(),
  71                            cppu::UnoType<XParameters>::get(),
  72                            cppu::UnoType<XResultSetMetaDataSupplier>::get(),
  73                            cppu::UnoType<XColumnsSupplier>::get(),
  74                             OStatementBase::getTypes() );
  75
  76     return aTypes.getTypes();
  77 }
  78
  79 Sequence< sal_Int8 > OPreparedStatement::getImplementationId() throw (RuntimeException, std::exception)
  80 {
  81     return css::uno::Sequence<sal_Int8>();
  82 }
  83
  84 // com::sun::star::uno::XInterface
  85 Any OPreparedStatement::queryInterface( const Type & rType ) throw (RuntimeException, std::exception)
  86 {
  87     Any aIface = OStatementBase::queryInterface( rType );
  88     if (!aIface.hasValue())
  89         aIface = ::cppu::queryInterface(
  90                     rType,
  91                     static_cast< XServiceInfo * >( this ),
  92                     static_cast< XParameters * >( this ),
  93                     static_cast< XColumnsSupplier * >( this ),
  94                     static_cast< XResultSetMetaDataSupplier * >( this ),
  95                     static_cast< XPreparedBatchExecution * >( this ),
  96                     static_cast< XMultipleResults * >( this ),
  97                     static_cast< XPreparedStatement * >( this ));
  98     return aIface;
  99 }
 100
 101 void OPreparedStatement::acquire() throw ()
 102 {
 103     OStatementBase::acquire();
 104 }
 105
 106 void OPreparedStatement::release() throw ()
 107 {
 108     OStatementBase::release();
 109 }
 110
 111 // XServiceInfo
 112 OUString OPreparedStatement::getImplementationName(  ) throw(RuntimeException, std::exception)
 113 {
 114     return OUString("com.sun.star.sdb.OPreparedStatement");
 115 }
 116
 117 sal_Bool OPreparedStatement::supportsService( const OUString& _rServiceName ) throw (RuntimeException, std::exception)
 118 {
 119     return cppu::supportsService(this, _rServiceName);
 120 }
 121
 122 Sequence< OUString > OPreparedStatement::getSupportedServiceNames(  ) throw (RuntimeException, std::exception)
 123 {
 124     Sequence< OUString > aSNS( 2 );
 125     aSNS.getArray()[0] = SERVICE_SDBC_PREPAREDSTATEMENT;
 126     aSNS.getArray()[1] = SERVICE_SDB_PREPAREDSTATMENT;
 127     return aSNS;
 128 }
 129
 130 // OComponentHelper
 131 void OPreparedStatement::disposing()
 132 {
 133     {
 134         MutexGuard aGuard(m_aMutex);
 135         m_pColumns->disposing();
 136         m_xAggregateAsParameters = NULL;
 137     }
 138     OStatementBase::disposing();
 139 }
 140
 141 // ::com::sun::star::sdbcx::XColumnsSupplier
 142 Reference< ::com::sun::star::container::XNameAccess > OPreparedStatement::getColumns() throw( RuntimeException, std::exception )
 143 {
 144     MutexGuard aGuard(m_aMutex);
 145     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 146
 147     // do we have to populate the columns
 148     if (!m_pColumns->isInitialized())
 149     {
 150         try
 151         {
 152             Reference< XResultSetMetaDataSupplier > xSuppMeta( m_xAggregateAsSet, UNO_QUERY_THROW );
 153             Reference< XResultSetMetaData > xMetaData( xSuppMeta->getMetaData(), UNO_SET_THROW );
 154
 155             Reference< XConnection > xConn( getConnection(), UNO_SET_THROW );
 156             Reference< XDatabaseMetaData > xDBMeta( xConn->getMetaData(), UNO_SET_THROW );
 157
 158             for (sal_Int32 i = 0, nCount = xMetaData->getColumnCount(); i < nCount; ++i)
 159             {
 160                 // retrieve the name of the column
 161                 OUString aName = xMetaData->getColumnName(i + 1);
 162                 OResultColumn* pColumn = new OResultColumn(xMetaData, i + 1, xDBMeta);
 163                 m_pColumns->append(aName, pColumn);
 164             }
 165         }
 166         catch (const SQLException& )
 167         {
 168             DBG_UNHANDLED_EXCEPTION();
 169         }
 170         m_pColumns->setInitialized();
 171     }
 172     return m_pColumns;
 173 }
 174
 175 // XResultSetMetaDataSupplier
 176 Reference< XResultSetMetaData > OPreparedStatement::getMetaData() throw( SQLException, RuntimeException, std::exception )
 177 {
 178     MutexGuard aGuard(m_aMutex);
 179     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 180     return Reference< XResultSetMetaDataSupplier >( m_xAggregateAsSet, UNO_QUERY_THROW )->getMetaData();
 181 }
 182
 183 // XPreparedStatement
 184 Reference< XResultSet >  OPreparedStatement::executeQuery() throw( SQLException, RuntimeException, std::exception )
 185 {
 186     MutexGuard aGuard(m_aMutex);
 187     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 188
 189     disposeResultSet();
 190
 191     Reference< XResultSet > xResultSet;
 192     Reference< XResultSet > xDrvResultSet = Reference< XPreparedStatement >( m_xAggregateAsSet, UNO_QUERY_THROW )->executeQuery();
 193     if (xDrvResultSet.is())
 194     {
 195         xResultSet = new OResultSet(xDrvResultSet, *this, m_pColumns->isCaseSensitive());
 196
 197         // keep the resultset weak
 198         m_aResultSet = xResultSet;
 199     }
 200     return xResultSet;
 201 }
 202
 203 sal_Int32 OPreparedStatement::executeUpdate() throw( SQLException, RuntimeException, std::exception )
 204 {
 205     MutexGuard aGuard(m_aMutex);
 206     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 207
 208     disposeResultSet();
 209
 210     return Reference< XPreparedStatement >( m_xAggregateAsSet, UNO_QUERY_THROW )->executeUpdate();
 211 }
 212
 213 sal_Bool OPreparedStatement::execute() throw( SQLException, RuntimeException, std::exception )
 214 {
 215     MutexGuard aGuard(m_aMutex);
 216     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 217
 218     disposeResultSet();
 219
 220     return Reference< XPreparedStatement >( m_xAggregateAsSet, UNO_QUERY_THROW )->execute();
 221 }
 222
 223 Reference< XConnection > OPreparedStatement::getConnection() throw( SQLException, RuntimeException, std::exception )
 224 {
 225     return Reference< XConnection > (m_xParent, UNO_QUERY);
 226 }
 227
 228 // XParameters
 229 void SAL_CALL OPreparedStatement::setNull( sal_Int32 parameterIndex, sal_Int32 sqlType ) throw(SQLException, RuntimeException, std::exception)
 230 {
 231     MutexGuard aGuard(m_aMutex);
 232     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 233
 234     m_xAggregateAsParameters->setNull(parameterIndex, sqlType);
 235 }
 236
 237 void SAL_CALL OPreparedStatement::setObjectNull( sal_Int32 parameterIndex, sal_Int32 sqlType, const OUString& typeName ) throw(SQLException, RuntimeException, std::exception)
 238 {
 239     MutexGuard aGuard(m_aMutex);
 240     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 241
 242     m_xAggregateAsParameters->setObjectNull(parameterIndex, sqlType, typeName);
 243 }
 244
 245 void SAL_CALL OPreparedStatement::setBoolean( sal_Int32 parameterIndex, sal_Bool x ) throw(SQLException, RuntimeException, std::exception)
 246 {
 247     MutexGuard aGuard(m_aMutex);
 248     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 249
 250     m_xAggregateAsParameters->setBoolean(parameterIndex, x);
 251 }
 252
 253 void SAL_CALL OPreparedStatement::setByte( sal_Int32 parameterIndex, sal_Int8 x ) throw(SQLException, RuntimeException, std::exception)
 254 {
 255     MutexGuard aGuard(m_aMutex);
 256     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 257
 258     m_xAggregateAsParameters->setByte(parameterIndex, x);
 259 }
 260
 261 void SAL_CALL OPreparedStatement::setShort( sal_Int32 parameterIndex, sal_Int16 x ) throw(SQLException, RuntimeException, std::exception)
 262 {
 263     MutexGuard aGuard(m_aMutex);
 264     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 265
 266     m_xAggregateAsParameters->setShort(parameterIndex, x);
 267 }
 268
 269 void SAL_CALL OPreparedStatement::setInt( sal_Int32 parameterIndex, sal_Int32 x ) throw(SQLException, RuntimeException, std::exception)
 270 {
 271     MutexGuard aGuard(m_aMutex);
 272     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 273
 274     m_xAggregateAsParameters->setInt(parameterIndex, x);
 275 }
 276
 277 void SAL_CALL OPreparedStatement::setLong( sal_Int32 parameterIndex, sal_Int64 x ) throw(SQLException, RuntimeException, std::exception)
 278 {
 279     MutexGuard aGuard(m_aMutex);
 280     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 281
 282     m_xAggregateAsParameters->setLong(parameterIndex, x);
 283 }
 284
 285 void SAL_CALL OPreparedStatement::setFloat( sal_Int32 parameterIndex, float x ) throw(SQLException, RuntimeException, std::exception)
 286 {
 287     MutexGuard aGuard(m_aMutex);
 288     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 289
 290     m_xAggregateAsParameters->setFloat(parameterIndex, x);
 291 }
 292
 293 void SAL_CALL OPreparedStatement::setDouble( sal_Int32 parameterIndex, double x ) throw(SQLException, RuntimeException, std::exception)
 294 {
 295     MutexGuard aGuard(m_aMutex);
 296     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 297
 298     m_xAggregateAsParameters->setDouble(parameterIndex, x);
 299 }
 300
 301 void SAL_CALL OPreparedStatement::setString( sal_Int32 parameterIndex, const OUString& x ) throw(SQLException, RuntimeException, std::exception)
 302 {
 303     MutexGuard aGuard(m_aMutex);
 304     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 305
 306     m_xAggregateAsParameters->setString(parameterIndex, x);
 307 }
 308
 309 void SAL_CALL OPreparedStatement::setBytes( sal_Int32 parameterIndex, const Sequence< sal_Int8 >& x ) throw(SQLException, RuntimeException, std::exception)
 310 {
 311     MutexGuard aGuard(m_aMutex);
 312     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 313
 314     m_xAggregateAsParameters->setBytes(parameterIndex, x);
 315 }
 316
 317 void SAL_CALL OPreparedStatement::setDate( sal_Int32 parameterIndex, const ::com::sun::star::util::Date& x ) throw(SQLException, RuntimeException, std::exception)
 318 {
 319     MutexGuard aGuard(m_aMutex);
 320     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 321
 322     m_xAggregateAsParameters->setDate(parameterIndex, x);
 323 }
 324
 325 void SAL_CALL OPreparedStatement::setTime( sal_Int32 parameterIndex, const ::com::sun::star::util::Time& x ) throw(SQLException, RuntimeException, std::exception)
 326 {
 327     MutexGuard aGuard(m_aMutex);
 328     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 329
 330     m_xAggregateAsParameters->setTime(parameterIndex, x);
 331 }
 332
 333 void SAL_CALL OPreparedStatement::setTimestamp( sal_Int32 parameterIndex, const ::com::sun::star::util::DateTime& x ) throw(SQLException, RuntimeException, std::exception)
 334 {
 335     MutexGuard aGuard(m_aMutex);
 336     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 337
 338     m_xAggregateAsParameters->setTimestamp(parameterIndex, x);
 339 }
 340
 341 void SAL_CALL OPreparedStatement::setBinaryStream( sal_Int32 parameterIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException, std::exception)
 342 {
 343     MutexGuard aGuard(m_aMutex);
 344     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 345
 346     m_xAggregateAsParameters->setBinaryStream(parameterIndex, x, length);
 347 }
 348
 349 void SAL_CALL OPreparedStatement::setCharacterStream( sal_Int32 parameterIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException, std::exception)
 350 {
 351     MutexGuard aGuard(m_aMutex);
 352     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 353
 354     m_xAggregateAsParameters->setCharacterStream(parameterIndex, x, length);
 355 }
 356
 357 void SAL_CALL OPreparedStatement::setObject( sal_Int32 parameterIndex, const Any& x ) throw(SQLException, RuntimeException, std::exception)
 358 {
 359     MutexGuard aGuard(m_aMutex);
 360     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 361
 362     m_xAggregateAsParameters->setObject(parameterIndex, x);
 363 }
 364
 365 void SAL_CALL OPreparedStatement::setObjectWithInfo( sal_Int32 parameterIndex, const Any& x, sal_Int32 targetSqlType, sal_Int32 scale ) throw(SQLException, RuntimeException, std::exception)
 366 {
 367     MutexGuard aGuard(m_aMutex);
 368     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 369
 370     m_xAggregateAsParameters->setObjectWithInfo(parameterIndex, x, targetSqlType, scale);
 371 }
 372
 373 void SAL_CALL OPreparedStatement::setRef( sal_Int32 parameterIndex, const Reference< XRef >& x ) throw(SQLException, RuntimeException, std::exception)
 374 {
 375     MutexGuard aGuard(m_aMutex);
 376     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 377
 378     m_xAggregateAsParameters->setRef(parameterIndex, x);
 379 }
 380
 381 void SAL_CALL OPreparedStatement::setBlob( sal_Int32 parameterIndex, const Reference< XBlob >& x ) throw(SQLException, RuntimeException, std::exception)
 382 {
 383     MutexGuard aGuard(m_aMutex);
 384     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 385
 386     m_xAggregateAsParameters->setBlob(parameterIndex, x);
 387 }
 388
 389 void SAL_CALL OPreparedStatement::setClob( sal_Int32 parameterIndex, const Reference< XClob >& x ) throw(SQLException, RuntimeException, std::exception)
 390 {
 391     MutexGuard aGuard(m_aMutex);
 392     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 393
 394     m_xAggregateAsParameters->setClob(parameterIndex, x);
 395 }
 396
 397 void SAL_CALL OPreparedStatement::setArray( sal_Int32 parameterIndex, const Reference< XArray >& x ) throw(SQLException, RuntimeException, std::exception)
 398 {
 399     MutexGuard aGuard(m_aMutex);
 400     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 401
 402     m_xAggregateAsParameters->setArray(parameterIndex, x);
 403 }
 404
 405 void SAL_CALL OPreparedStatement::clearParameters(  ) throw(SQLException, RuntimeException, std::exception)
 406 {
 407     MutexGuard aGuard(m_aMutex);
 408     ::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
 409
 410     m_xAggregateAsParameters->clearParameters();
 411 }
 412
 413 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */