mysqlc/source/mysqlc_statement.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 #include <sal/config.h>
  21
  22 #include <memory>
  23 #include <stdio.h>
  24
  25 #include "mysqlc_connection.hxx"
  26 #include "mysqlc_propertyids.hxx"
  27 #include "mysqlc_resultset.hxx"
  28 #include "mysqlc_statement.hxx"
  29 #include "mysqlc_general.hxx"
  30
  31 #include <com/sun/star/lang/DisposedException.hpp>
  32 #include <com/sun/star/sdbc/FetchDirection.hpp>
  33 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
  34 #include <com/sun/star/sdbc/ResultSetType.hpp>
  35
  36 #include <cppconn/connection.h>
  37 #include <cppconn/exception.h>
  38 #include <cppconn/statement.h>
  39 #include <cppuhelper/typeprovider.hxx>
  40 #include <cppuhelper/queryinterface.hxx>
  41 #include <osl/diagnose.h>
  42 #include <osl/thread.h>
  43
  44 using namespace connectivity::mysqlc;
  45
  46 using namespace com::sun::star::uno;
  47 using namespace com::sun::star::lang;
  48 using namespace com::sun::star::beans;
  49 using namespace com::sun::star::sdbc;
  50 using namespace com::sun::star::sdbcx;
  51 using namespace com::sun::star::container;
  52 using namespace com::sun::star::io;
  53 using namespace com::sun::star::util;
  54 using ::osl::MutexGuard;
  55
  56 OCommonStatement::OCommonStatement(OConnection* _pConnection, sql::Statement *_cppStatement)
  57     :OCommonStatement_IBase(m_aMutex)
  58     ,OPropertySetHelper(OCommonStatement_IBase::rBHelper)
  59     ,OStatement_CBase( (::cppu::OWeakObject*)_pConnection, this )
  60     ,m_pConnection(_pConnection)
  61     ,cppStatement(_cppStatement)
  62     ,rBHelper(OCommonStatement_IBase::rBHelper)
  63 {
  64     OSL_TRACE("OCommonStatement::OCommonStatement");
  65     m_pConnection->acquire();
  66 }
  67
  68 OCommonStatement::~OCommonStatement()
  69 {
  70     OSL_TRACE("OCommonStatement::~OCommonStatement");
  71 }
  72
  73 void OCommonStatement::disposeResultSet()
  74 {
  75     OSL_TRACE("OCommonStatement::disposeResultSet");
  76     // free the cursor if alive
  77     delete cppStatement;
  78     cppStatement = NULL;
  79 }
  80
  81 void OCommonStatement::disposing()
  82 {
  83     OSL_TRACE("OCommonStatement::disposing");
  84     MutexGuard aGuard(m_aMutex);
  85
  86     disposeResultSet();
  87
  88     if (m_pConnection) {
  89         m_pConnection->release();
  90         m_pConnection = NULL;
  91     }
  92     delete cppStatement;
  93
  94     dispose_ChildImpl();
  95     OCommonStatement_IBase::disposing();
  96 }
  97
  98 Any SAL_CALL OCommonStatement::queryInterface(const Type & rType)
  99     throw(RuntimeException, std::exception)
 100 {
 101     OSL_TRACE("OCommonStatement::queryInterface");
 102     Any aRet = OCommonStatement_IBase::queryInterface(rType);
 103     if (!aRet.hasValue()) {
 104         aRet = OPropertySetHelper::queryInterface(rType);
 105     }
 106     return aRet;
 107 }
 108
 109 Sequence< Type > SAL_CALL OCommonStatement::getTypes()
 110     throw(RuntimeException, std::exception)
 111 {
 112     OSL_TRACE("OCommonStatement::getTypes");
 113     ::cppu::OTypeCollection aTypes( cppu::UnoType<XMultiPropertySet>::get(),
 114                                     cppu::UnoType<XFastPropertySet>::get(),
 115                                     cppu::UnoType<XPropertySet>::get());
 116
 117     return concatSequences(aTypes.getTypes(), OCommonStatement_IBase::getTypes());
 118 }
 119
 120 void SAL_CALL OCommonStatement::cancel()
 121     throw(RuntimeException, std::exception)
 122 {
 123     OSL_TRACE("OCommonStatement::cancel");
 124     MutexGuard aGuard(m_aMutex);
 125     checkDisposed(rBHelper.bDisposed);
 126     // cancel the current sql statement
 127 }
 128
 129 void SAL_CALL OCommonStatement::close()
 130     throw(SQLException, RuntimeException, std::exception)
 131 {
 132     OSL_TRACE("OCommonStatement::close");
 133     /*
 134       We need a block for the checkDisposed call.
 135       After the check we can call dispose() as we are not under lock ??
 136     */
 137     {
 138         MutexGuard aGuard(m_aMutex);
 139         checkDisposed(rBHelper.bDisposed);
 140     }
 141     dispose();
 142 }
 143
 144 void SAL_CALL OStatement::clearBatch()
 145     throw(SQLException, RuntimeException, std::exception)
 146 {
 147     OSL_TRACE("OStatement::clearBatch");
 148     // if you support batches clear it here
 149 }
 150
 151 sal_Bool SAL_CALL OCommonStatement::execute(const rtl::OUString& sql)
 152     throw(SQLException, RuntimeException, std::exception)
 153 {
 154     OSL_TRACE("OCommonStatement::execute");
 155     MutexGuard aGuard(m_aMutex);
 156     checkDisposed(rBHelper.bDisposed);
 157     const rtl::OUString sSqlStatement = m_pConnection->transFormPreparedStatement( sql );
 158
 159     bool success = false;
 160     try {
 161         success = cppStatement->execute(rtl::OUStringToOString(sSqlStatement, m_pConnection->getConnectionSettings().encoding).getStr());
 162     } catch (const sql::SQLException &e) {
 163         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
 164     }
 165     return success;
 166 }
 167
 168 Reference< XResultSet > SAL_CALL OCommonStatement::executeQuery(const rtl::OUString& sql)
 169     throw(SQLException, RuntimeException, std::exception)
 170 {
 171     OSL_TRACE("OCommonStatement::executeQuery");
 172
 173     MutexGuard aGuard(m_aMutex);
 174     checkDisposed(rBHelper.bDisposed);
 175     const rtl::OUString sSqlStatement = m_pConnection->transFormPreparedStatement(sql);
 176
 177     Reference< XResultSet > xResultSet;
 178     try {
 179         std::unique_ptr< sql::ResultSet > rset(cppStatement->executeQuery(rtl::OUStringToOString(sSqlStatement, m_pConnection->getConnectionEncoding()).getStr()));
 180         xResultSet = new OResultSet(this, rset.get(), m_pConnection->getConnectionEncoding());
 181         rset.release();
 182     } catch (const sql::SQLException &e) {
 183         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
 184     }
 185     return xResultSet;
 186 }
 187
 188 Reference< XConnection > SAL_CALL OCommonStatement::getConnection()
 189     throw(SQLException, RuntimeException, std::exception)
 190 {
 191     OSL_TRACE("OCommonStatement::getConnection");
 192     MutexGuard aGuard(m_aMutex);
 193     checkDisposed(rBHelper.bDisposed);
 194
 195     // just return our connection here
 196     return m_pConnection;
 197 }
 198
 199 sal_Int32 SAL_CALL OCommonStatement::getUpdateCount()
 200     throw(SQLException, RuntimeException, std::exception)
 201 {
 202     OSL_TRACE("OCommonStatement::getUpdateCount");
 203     return 0;
 204 }
 205
 206 Any SAL_CALL OStatement::queryInterface(const Type & rType)
 207     throw(RuntimeException, std::exception)
 208 {
 209     OSL_TRACE("OStatement::queryInterface");
 210     Any aRet = ::cppu::queryInterface(rType,static_cast< XBatchExecution*> (this));
 211     if (!aRet.hasValue()) {
 212         aRet = OCommonStatement::queryInterface(rType);
 213     }
 214     return aRet;
 215 }
 216
 217 void SAL_CALL OStatement::addBatch(const rtl::OUString& sql)
 218     throw(SQLException, RuntimeException, std::exception)
 219 {
 220     OSL_TRACE("OStatement::addBatch");
 221     MutexGuard aGuard(m_aMutex);
 222     checkDisposed(rBHelper.bDisposed);
 223
 224     m_aBatchList.push_back(sql);
 225 }
 226
 227 Sequence< sal_Int32 > SAL_CALL OStatement::executeBatch()
 228     throw(SQLException, RuntimeException, std::exception)
 229 {
 230     OSL_TRACE("OStatement::executeBatch");
 231     MutexGuard aGuard(m_aMutex);
 232     checkDisposed(rBHelper.bDisposed);
 233
 234     Sequence< sal_Int32 > aRet = Sequence< sal_Int32 >();
 235     return aRet;
 236 }
 237
 238 sal_Int32 SAL_CALL OCommonStatement::executeUpdate(const rtl::OUString& sql)
 239     throw(SQLException, RuntimeException, std::exception)
 240 {
 241     OSL_TRACE("OCommonStatement::executeUpdate");
 242     MutexGuard aGuard(m_aMutex);
 243     checkDisposed(rBHelper.bDisposed);
 244     const rtl::OUString sSqlStatement = m_pConnection->transFormPreparedStatement(sql);
 245
 246     sal_Int32 affectedRows = 0;
 247     try {
 248         affectedRows = cppStatement->executeUpdate(rtl::OUStringToOString(sSqlStatement, m_pConnection->getConnectionEncoding()).getStr());
 249     } catch (const sql::SQLException &e) {
 250         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
 251     }
 252     return affectedRows;
 253 }
 254
 255 Reference< XResultSet > SAL_CALL OCommonStatement::getResultSet()
 256     throw(SQLException, RuntimeException, std::exception)
 257 {
 258     OSL_TRACE("OCommonStatement::getResultSet");
 259     MutexGuard aGuard(m_aMutex);
 260     checkDisposed(rBHelper.bDisposed);
 261
 262     Reference< XResultSet > xResultSet;
 263     try {
 264         std::unique_ptr< sql::ResultSet > rset(cppStatement->getResultSet());
 265         xResultSet = new OResultSet(this, rset.get(), m_pConnection->getConnectionEncoding());
 266         rset.release();
 267     } catch (const sql::SQLException &e) {
 268         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
 269     }
 270     return xResultSet;
 271 }
 272
 273 sal_Bool SAL_CALL OCommonStatement::getMoreResults()
 274     throw(SQLException, RuntimeException, std::exception)
 275 {
 276     OSL_TRACE("OCommonStatement::getMoreResults");
 277     MutexGuard aGuard(m_aMutex);
 278     checkDisposed(rBHelper.bDisposed);
 279
 280     // if your driver supports more than only one resultset
 281     // and has one more at this moment return true
 282     return sal_False;
 283 }
 284
 285 Any SAL_CALL OCommonStatement::getWarnings()
 286     throw(SQLException, RuntimeException, std::exception)
 287 {
 288     OSL_TRACE("OCommonStatement::getWarnings");
 289     MutexGuard aGuard(m_aMutex);
 290     checkDisposed(rBHelper.bDisposed);
 291
 292     return makeAny(m_aLastWarning);
 293 }
 294
 295 void SAL_CALL OCommonStatement::clearWarnings()
 296     throw(SQLException, RuntimeException, std::exception)
 297 {
 298     OSL_TRACE("OCommonStatement::clearWarnings");
 299     MutexGuard aGuard(m_aMutex);
 300     checkDisposed(rBHelper.bDisposed);
 301
 302     m_aLastWarning = SQLWarning();
 303 }
 304
 305 ::cppu::IPropertyArrayHelper* OCommonStatement::createArrayHelper( ) const
 306 {
 307     OSL_TRACE("OCommonStatement::createArrayHelper");
 308     // this properties are define by the service statement
 309     // they must in alphabetic order
 310     Sequence< Property > aProps(10);
 311     Property* pProperties = aProps.getArray();
 312     sal_Int32 nPos = 0;
 313     pProperties[nPos++] = Property("CursorName", PROPERTY_ID_CURSORNAME, cppu::UnoType<rtl::OUString>::get(), 0);
 314     pProperties[nPos++] = Property("EscapeProcessing", PROPERTY_ID_ESCAPEPROCESSING, cppu::UnoType<bool>::get(), 0);
 315     pProperties[nPos++] = Property("FetchDirection", PROPERTY_ID_FETCHDIRECTION, cppu::UnoType<sal_Int32>::get(), 0);
 316     pProperties[nPos++] = Property("FetchSize", PROPERTY_ID_FETCHSIZE, cppu::UnoType<sal_Int32>::get(), 0);
 317     pProperties[nPos++] = Property("MaxFieldSize", PROPERTY_ID_MAXFIELDSIZE, cppu::UnoType<sal_Int32>::get(), 0);
 318     pProperties[nPos++] = Property("MaxRows", PROPERTY_ID_MAXROWS, cppu::UnoType<sal_Int32>::get(), 0);
 319     pProperties[nPos++] = Property("QueryTimeOut", PROPERTY_ID_QUERYTIMEOUT, cppu::UnoType<sal_Int32>::get(), 0);
 320     pProperties[nPos++] = Property("ResultSetConcurrency", PROPERTY_ID_RESULTSETCONCURRENCY, cppu::UnoType<sal_Int32>::get(), 0);
 321     pProperties[nPos++] = Property("ResultSetType", PROPERTY_ID_RESULTSETTYPE, cppu::UnoType<sal_Int32>::get(), 0);
 322     pProperties[nPos++] = Property("UseBookmarks", PROPERTY_ID_USEBOOKMARKS, cppu::UnoType<bool>::get(), 0);
 323
 324     return new ::cppu::OPropertyArrayHelper(aProps);
 325 }
 326
 327 ::cppu::IPropertyArrayHelper & OCommonStatement::getInfoHelper()
 328 {
 329     OSL_TRACE("OCommonStatement::getInfoHelper");
 330     return *getArrayHelper();
 331 }
 332
 333 sal_Bool OCommonStatement::convertFastPropertyValue(
 334         Any & /* rConvertedValue */, Any & /* rOldValue */,
 335         sal_Int32 /* nHandle */, const Any& /* rValue */)
 336     throw (IllegalArgumentException)
 337 {
 338     OSL_TRACE("OCommonStatement::convertFastPropertyValue");
 339     bool bConverted = false;
 340     // here we have to try to convert
 341     return bConverted;
 342 }
 343
 344 void OCommonStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle, const Any& /* rValue */)
 345     throw (Exception, std::exception)
 346 {
 347     OSL_TRACE("OCommonStatement::setFastPropertyValue_NoBroadcast");
 348     // set the value to what ever is necessary
 349     switch (nHandle) {
 350         case PROPERTY_ID_QUERYTIMEOUT:
 351         case PROPERTY_ID_MAXFIELDSIZE:
 352         case PROPERTY_ID_MAXROWS:
 353         case PROPERTY_ID_CURSORNAME:
 354         case PROPERTY_ID_RESULTSETCONCURRENCY:
 355         case PROPERTY_ID_RESULTSETTYPE:
 356         case PROPERTY_ID_FETCHDIRECTION:
 357         case PROPERTY_ID_FETCHSIZE:
 358         case PROPERTY_ID_ESCAPEPROCESSING:
 359         case PROPERTY_ID_USEBOOKMARKS:
 360         default:
 361             ;
 362     }
 363 }
 364
 365 void OCommonStatement::getFastPropertyValue(Any& _rValue, sal_Int32 nHandle) const
 366 {
 367     OSL_TRACE("OCommonStatement::getFastPropertyValue");
 368     switch (nHandle)    {
 369         case PROPERTY_ID_QUERYTIMEOUT:
 370         case PROPERTY_ID_MAXFIELDSIZE:
 371         case PROPERTY_ID_MAXROWS:
 372         case PROPERTY_ID_CURSORNAME:
 373         case PROPERTY_ID_RESULTSETCONCURRENCY:
 374         case PROPERTY_ID_RESULTSETTYPE:
 375         case PROPERTY_ID_FETCHDIRECTION:
 376         case PROPERTY_ID_FETCHSIZE:
 377         case PROPERTY_ID_ESCAPEPROCESSING:
 378             break;
 379         case PROPERTY_ID_USEBOOKMARKS:
 380             _rValue <<= sal_False;
 381             break;
 382         default:
 383             ;
 384     }
 385 }
 386
 387 rtl::OUString OStatement::getImplementationName() throw (css::uno::RuntimeException, std::exception)
 388 {
 389     return rtl::OUString("com.sun.star.sdbcx.OStatement");
 390 }
 391
 392 css::uno::Sequence<rtl::OUString> OStatement::getSupportedServiceNames()
 393     throw (css::uno::RuntimeException, std::exception)
 394 {
 395     css::uno::Sequence<rtl::OUString> s(1);
 396     s[0] = "com.sun.star.sdbc.Statement";
 397     return s;
 398 }
 399
 400 sal_Bool OStatement::supportsService(rtl::OUString const & ServiceName)
 401     throw (css::uno::RuntimeException, std::exception)
 402 {
 403     return cppu::supportsService(this, ServiceName);
 404 }
 405
 406 void SAL_CALL OCommonStatement::acquire()
 407     throw()
 408 {
 409     OSL_TRACE("OCommonStatement::acquire");
 410     OCommonStatement_IBase::acquire();
 411 }
 412
 413 void SAL_CALL OCommonStatement::release()
 414     throw()
 415 {
 416     OSL_TRACE("OCommonStatement::release");
 417     relase_ChildImpl();
 418 }
 419
 420 void SAL_CALL OStatement::acquire()
 421     throw()
 422 {
 423     OSL_TRACE("OStatement::acquire");
 424     OCommonStatement::acquire();
 425 }
 426
 427 void SAL_CALL OStatement::release()
 428     throw()
 429 {
 430     OSL_TRACE("OStatement::release");
 431     OCommonStatement::release();
 432 }
 433
 434 Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL OCommonStatement::getPropertySetInfo()
 435     throw(RuntimeException, std::exception)
 436 {
 437     OSL_TRACE("OCommonStatement::getPropertySetInfo");
 438     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 439 }
 440
 441 /*
 442  * Local variables:
 443  * tab-width: 4
 444  * c-basic-offset: 4
 445  * End:
 446  * vim600: noet sw=4 ts=4 fdm=marker
 447  * vim<600: noet sw=4 ts=4
 448  */
 449
 450 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */