connectivity/source/drivers/mork/MStatement.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 <tools/diagnose_ex.h>
  22 #include <cppuhelper/queryinterface.hxx>
  23 #include <comphelper/processfactory.hxx>
  24 #include <connectivity/dbexception.hxx>
  25
  26 #include <algorithm>
  27
  28 #include "MDriver.hxx"
  29 #include "MStatement.hxx"
  30 #include "sqlbison.hxx"
  31 #include "MResultSet.hxx"
  32
  33 #include "resource/mork_res.hrc"
  34 #include "resource/common_res.hrc"
  35
  36 #if OSL_DEBUG_LEVEL > 0
  37 # define OUtoCStr( x ) ( OUStringToOString ( (x), RTL_TEXTENCODING_ASCII_US).getStr())
  38 #else /* OSL_DEBUG_LEVEL */
  39 # define OUtoCStr( x ) ("dummy")
  40 #endif /* OSL_DEBUG_LEVEL */
  41
  42 static ::osl::Mutex m_ThreadMutex;
  43
  44 using namespace ::comphelper;
  45 using namespace connectivity::mork;
  46 using namespace connectivity;
  47
  48 using namespace com::sun::star::uno;
  49 using namespace com::sun::star::lang;
  50 using namespace com::sun::star::beans;
  51 using namespace com::sun::star::sdbc;
  52 using namespace com::sun::star::container;
  53 using namespace com::sun::star::io;
  54 using namespace com::sun::star::util;
  55
  56
  57 OStatement::OStatement( OConnection* _pConnection) : OCommonStatement( _pConnection)
  58 {
  59 }
  60
  61 OCommonStatement::OCommonStatement(OConnection* _pConnection )
  62     :OCommonStatement_IBASE(m_aMutex)
  63     ,OPropertySetHelper(OCommonStatement_IBASE::rBHelper)
  64     ,OCommonStatement_SBASE(static_cast<cppu::OWeakObject*>(_pConnection), this)
  65     ,m_pTable(nullptr)
  66     ,m_pConnection(_pConnection)
  67     ,m_aParser( comphelper::getComponentContext(_pConnection->getDriver()->getFactory()) )
  68     ,m_pSQLIterator( new OSQLParseTreeIterator( _pConnection, _pConnection->createCatalog()->getTables(), m_aParser ) )
  69 {
  70     m_xDBMetaData = _pConnection->getMetaData();
  71     m_pParseTree = nullptr;
  72 }
  73
  74
  75 OCommonStatement::~OCommonStatement()
  76 {
  77 }
  78
  79
  80 void OCommonStatement::disposing()
  81 {
  82     ::osl::MutexGuard aGuard(m_aMutex);
  83
  84     clearWarnings();
  85     clearCachedResultSet();
  86
  87     m_pConnection.clear();
  88
  89     m_pSQLIterator->dispose();
  90     delete m_pParseTree;
  91
  92     dispose_ChildImpl();
  93     OCommonStatement_IBASE::disposing();
  94 }
  95
  96 Any SAL_CALL OCommonStatement::queryInterface( const Type & rType ) throw(RuntimeException, std::exception)
  97 {
  98     Any aRet = OCommonStatement_IBASE::queryInterface(rType);
  99     if(!aRet.hasValue())
 100         aRet = OPropertySetHelper::queryInterface(rType);
 101     return aRet;
 102 }
 103
 104 Sequence< Type > SAL_CALL OCommonStatement::getTypes(  ) throw(RuntimeException, std::exception)
 105 {
 106     ::cppu::OTypeCollection aTypes( cppu::UnoType<XMultiPropertySet>::get(),
 107                                     cppu::UnoType<XFastPropertySet>::get(),
 108                                     cppu::UnoType<XPropertySet>::get());
 109
 110     return ::comphelper::concatSequences(aTypes.getTypes(),OCommonStatement_IBASE::getTypes());
 111 }
 112
 113 void SAL_CALL OCommonStatement::close(  ) throw(SQLException, RuntimeException, std::exception)
 114 {
 115     {
 116         ::osl::MutexGuard aGuard( m_aMutex );
 117         checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 118     }
 119     dispose();
 120 }
 121
 122 OCommonStatement::StatementType OCommonStatement::parseSql( const OUString& sql , bool bAdjusted)
 123     throw ( SQLException, RuntimeException, std::exception )
 124 {
 125     OUString aErr;
 126
 127     m_pParseTree = m_aParser.parseTree(aErr,sql);
 128
 129 #if OSL_DEBUG_LEVEL > 0
 130     {
 131         OSL_TRACE("ParseSQL: %s", OUtoCStr( sql ) );
 132     }
 133 #endif // OSL_DEBUG_LEVEL
 134
 135     if(m_pParseTree)
 136     {
 137         m_pSQLIterator->setParseTree(m_pParseTree);
 138         m_pSQLIterator->traverseAll();
 139         const OSQLTables& rTabs = m_pSQLIterator->getTables();
 140
 141         if (rTabs.empty())
 142         {
 143             getOwnConnection()->throwSQLException( STR_QUERY_AT_LEAST_ONE_TABLES, *this );
 144         }
 145
 146 #if OSL_DEBUG_LEVEL > 0
 147         OSQLTables::const_iterator citer;
 148         for( citer = rTabs.begin(); citer != rTabs.end(); ++citer ) {
 149             OSL_TRACE("SELECT Table : %s", OUtoCStr(citer->first) );
 150         }
 151 #endif
 152
 153         Reference<XIndexAccess> xNames;
 154         switch(m_pSQLIterator->getStatementType())
 155         {
 156         case OSQLStatementType::Select:
 157
 158             // at this moment we support only one table per select statement
 159
 160             OSL_ENSURE( rTabs.begin() != rTabs.end(), "Need a Table");
 161
 162             m_pTable = static_cast< OTable* > (rTabs.begin()->second.get());
 163             m_xColNames     = m_pTable->getColumns();
 164             xNames.set(m_xColNames,UNO_QUERY);
 165             // set the binding of the resultrow
 166             m_aRow          = new OValueVector(xNames->getCount());
 167             (m_aRow->get())[0].setBound(true);
 168             ::std::for_each(m_aRow->get().begin()+1,m_aRow->get().end(),TSetBound(false));
 169             // create the column mapping
 170             createColumnMapping();
 171
 172             analyseSQL();
 173             return eSelect;
 174
 175         case OSQLStatementType::CreateTable:
 176             return eCreateTable;
 177
 178         default:
 179             break;
 180         }
 181     }
 182     else if(!bAdjusted) //Our sql parser does not support a statement like "create table foo"
 183                         // So we append ("E-mail" varchar) to the last of it to make it work
 184     {
 185         return parseSql(sql + "(""E-mail"" character)", true);
 186     }
 187
 188     getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this );
 189     OSL_FAIL( "OCommonStatement::parseSql: unreachable!" );
 190     return eSelect;
 191
 192 }
 193
 194 Reference< XResultSet > OCommonStatement::impl_executeCurrentQuery()
 195 {
 196     clearCachedResultSet();
 197
 198     ::rtl::Reference< OResultSet > pResult( new OResultSet( this, m_pSQLIterator ) );
 199     initializeResultSet( pResult.get() );
 200
 201     pResult->executeQuery();
 202     cacheResultSet( pResult );  // only cache if we survived the execution
 203
 204     return pResult.get();
 205
 206 }
 207
 208
 209 void OCommonStatement::initializeResultSet( OResultSet* _pResult )
 210 {
 211     ENSURE_OR_THROW( _pResult, "invalid result set" );
 212
 213     _pResult->setColumnMapping(m_aColMapping);
 214     _pResult->setOrderByColumns(m_aOrderbyColumnNumber);
 215     _pResult->setOrderByAscending(m_aOrderbyAscending);
 216     _pResult->setBindingRow(m_aRow);
 217     _pResult->setTable(m_pTable);
 218 }
 219
 220
 221 void OCommonStatement::clearCachedResultSet()
 222 {
 223     Reference< XResultSet > xResultSet( m_xResultSet.get(), UNO_QUERY );
 224     if ( !xResultSet.is() )
 225         return;
 226
 227     Reference< XCloseable >( xResultSet, UNO_QUERY_THROW )->close();
 228
 229     m_xResultSet.clear();
 230 }
 231
 232
 233 void OCommonStatement::cacheResultSet( const ::rtl::Reference< OResultSet >& _pResult )
 234 {
 235     ENSURE_OR_THROW( _pResult.is(), "invalid result set" );
 236     m_xResultSet = Reference< XResultSet >( _pResult.get() );
 237 }
 238
 239
 240 sal_Bool SAL_CALL OCommonStatement::execute( const OUString& sql ) throw(SQLException, RuntimeException, std::exception)
 241 {
 242     ::osl::MutexGuard aGuard( m_aMutex );
 243     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 244
 245     OSL_TRACE("Statement::execute( %s )", OUtoCStr( sql ) );
 246
 247     Reference< XResultSet > xRS = executeQuery( sql );
 248     // returns true when a resultset is available
 249     return xRS.is();
 250 }
 251
 252
 253 Reference< XResultSet > SAL_CALL OCommonStatement::executeQuery( const OUString& sql ) throw(SQLException, RuntimeException, std::exception)
 254 {
 255     ::osl::MutexGuard aGuard( m_ThreadMutex );
 256     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 257
 258     OSL_TRACE("Statement::executeQuery( %s )", OUtoCStr( sql ) );
 259
 260     // parse the statement
 261     StatementType eStatementType = parseSql( sql );
 262     if ( eStatementType != eSelect )
 263         return nullptr;
 264
 265     return impl_executeCurrentQuery();
 266 }
 267
 268
 269 Reference< XConnection > SAL_CALL OCommonStatement::getConnection(  ) throw(SQLException, RuntimeException, std::exception)
 270 {
 271     ::osl::MutexGuard aGuard( m_aMutex );
 272     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 273
 274     // just return our connection here
 275     return Reference< XConnection >(m_pConnection.get());
 276 }
 277
 278 Any SAL_CALL OStatement::queryInterface( const Type & rType ) throw(RuntimeException, std::exception)
 279 {
 280     Any aRet = ::cppu::queryInterface(rType,static_cast< XServiceInfo*> (this));
 281     if(!aRet.hasValue())
 282         aRet = OCommonStatement::queryInterface(rType);
 283     return aRet;
 284 }
 285
 286 sal_Int32 SAL_CALL OCommonStatement::executeUpdate( const OUString& /*sql*/ ) throw(SQLException, RuntimeException, std::exception)
 287 {
 288     ::dbtools::throwFeatureNotImplementedSQLException( "XStatement::executeUpdate", *this );
 289     return 0;
 290
 291 }
 292
 293 Any SAL_CALL OCommonStatement::getWarnings(  ) throw(SQLException, RuntimeException, std::exception)
 294 {
 295     ::osl::MutexGuard aGuard( m_aMutex );
 296     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 297
 298     return makeAny(m_aLastWarning);
 299 }
 300
 301
 302 void SAL_CALL OCommonStatement::clearWarnings(  ) throw(SQLException, RuntimeException, std::exception)
 303 {
 304     ::osl::MutexGuard aGuard( m_aMutex );
 305     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 306
 307
 308     m_aLastWarning = SQLWarning();
 309 }
 310
 311 ::cppu::IPropertyArrayHelper* OCommonStatement::createArrayHelper( ) const
 312 {
 313     // this properties are define by the service resultset
 314     // they must in alphabetic order
 315     Sequence< Property > aProps(9);
 316     Property* pProperties = aProps.getArray();
 317     sal_Int32 nPos = 0;
 318     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CURSORNAME),
 319         PROPERTY_ID_CURSORNAME, cppu::UnoType<OUString>::get(), 0);
 320     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ESCAPEPROCESSING),
 321         PROPERTY_ID_ESCAPEPROCESSING, cppu::UnoType<bool>::get(), 0);
 322     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHDIRECTION),
 323         PROPERTY_ID_FETCHDIRECTION, cppu::UnoType<sal_Int32>::get(), 0);
 324     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHSIZE),
 325         PROPERTY_ID_FETCHSIZE, cppu::UnoType<sal_Int32>::get(), 0);
 326     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_MAXFIELDSIZE),
 327         PROPERTY_ID_MAXFIELDSIZE, cppu::UnoType<sal_Int32>::get(), 0);
 328     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_MAXROWS),
 329         PROPERTY_ID_MAXROWS, cppu::UnoType<sal_Int32>::get(), 0);
 330     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_QUERYTIMEOUT),
 331         PROPERTY_ID_QUERYTIMEOUT, cppu::UnoType<sal_Int32>::get(), 0);
 332     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETCONCURRENCY),
 333         PROPERTY_ID_RESULTSETCONCURRENCY, cppu::UnoType<sal_Int32>::get(), 0);
 334     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETTYPE),
 335         PROPERTY_ID_RESULTSETTYPE, cppu::UnoType<sal_Int32>::get(), 0);
 336
 337     return new ::cppu::OPropertyArrayHelper(aProps);
 338 }
 339
 340
 341 ::cppu::IPropertyArrayHelper & OCommonStatement::getInfoHelper()
 342 {
 343     return *getArrayHelper();
 344 }
 345
 346 sal_Bool OCommonStatement::convertFastPropertyValue(
 347                             Any & /*rConvertedValue*/,
 348                             Any & /*rOldValue*/,
 349                             sal_Int32 /*nHandle*/,
 350                             const Any& /*rValue*/ )
 351                                 throw (css::lang::IllegalArgumentException)
 352 {
 353     bool bConverted = false;
 354     // here we have to try to convert
 355     return bConverted;
 356 }
 357
 358 void OCommonStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& /*rValue*/) throw (Exception, std::exception)
 359 {
 360     // set the value to whatever is necessary
 361     switch(nHandle)
 362     {
 363         case PROPERTY_ID_QUERYTIMEOUT:
 364         case PROPERTY_ID_MAXFIELDSIZE:
 365         case PROPERTY_ID_MAXROWS:
 366         case PROPERTY_ID_RESULTSETCONCURRENCY:
 367         case PROPERTY_ID_RESULTSETTYPE:
 368         case PROPERTY_ID_FETCHDIRECTION:
 369         case PROPERTY_ID_FETCHSIZE:
 370         case PROPERTY_ID_ESCAPEPROCESSING:
 371         default:
 372             ;
 373     }
 374 }
 375
 376 void OCommonStatement::getFastPropertyValue(Any& /*rValue*/,sal_Int32 nHandle) const
 377 {
 378     switch(nHandle)
 379     {
 380         case PROPERTY_ID_QUERYTIMEOUT:
 381         case PROPERTY_ID_MAXFIELDSIZE:
 382         case PROPERTY_ID_MAXROWS:
 383         case PROPERTY_ID_RESULTSETCONCURRENCY:
 384         case PROPERTY_ID_RESULTSETTYPE:
 385         case PROPERTY_ID_FETCHDIRECTION:
 386         case PROPERTY_ID_FETCHSIZE:
 387         case PROPERTY_ID_ESCAPEPROCESSING:
 388         default:
 389             ;
 390     }
 391 }
 392
 393 IMPLEMENT_SERVICE_INFO(OStatement,"com.sun.star.sdbcx.OStatement","com.sun.star.sdbc.Statement");
 394
 395 void SAL_CALL OCommonStatement::acquire() throw()
 396 {
 397     OCommonStatement_IBASE::acquire();
 398 }
 399
 400 void SAL_CALL OCommonStatement::release() throw()
 401 {
 402     release_ChildImpl();
 403 }
 404
 405 void SAL_CALL OStatement::acquire() throw()
 406 {
 407     OCommonStatement::acquire();
 408 }
 409
 410 void SAL_CALL OStatement::release() throw()
 411 {
 412     OCommonStatement::release();
 413 }
 414
 415 Reference< css::beans::XPropertySetInfo > SAL_CALL OCommonStatement::getPropertySetInfo(  ) throw(RuntimeException, std::exception)
 416 {
 417     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 418 }
 419
 420 void OCommonStatement::createColumnMapping()
 421 {
 422     size_t i;
 423
 424     // initialize the column index map (mapping select columns to table columns)
 425     ::rtl::Reference<connectivity::OSQLColumns> xColumns = m_pSQLIterator->getSelectColumns();
 426     m_aColMapping.resize(xColumns->get().size() + 1);
 427     for (i=0; i<m_aColMapping.size(); ++i)
 428         m_aColMapping[i] = static_cast<sal_Int32>(i);
 429
 430     Reference<XIndexAccess> xNames(m_xColNames,UNO_QUERY);
 431     // now check which columns are bound
 432 #if OSL_DEBUG_LEVEL > 0
 433     for ( i = 0; i < m_aColMapping.size(); i++ )
 434         SAL_INFO(
 435             "connectivity.mork",
 436             "BEFORE Mapped: " << i << " -> " << m_aColMapping[i]);
 437 #endif
 438     OResultSet::setBoundedColumns(m_aRow,xColumns,xNames,true,m_xDBMetaData,m_aColMapping);
 439 #if OSL_DEBUG_LEVEL > 0
 440     for ( i = 0; i < m_aColMapping.size(); i++ )
 441         SAL_INFO(
 442             "connectivity.mork",
 443             "AFTER  Mapped: " << i << " -> " << m_aColMapping[i]);
 444 #endif
 445 }
 446
 447
 448 void OCommonStatement::analyseSQL()
 449 {
 450     const OSQLParseNode* pOrderbyClause = m_pSQLIterator->getOrderTree();
 451     if(pOrderbyClause)
 452     {
 453         OSQLParseNode * pOrderingSpecCommalist = pOrderbyClause->getChild(2);
 454         OSL_ENSURE(SQL_ISRULE(pOrderingSpecCommalist,ordering_spec_commalist),"OResultSet: Fehler im Parse Tree");
 455
 456         for (size_t m = 0; m < pOrderingSpecCommalist->count(); m++)
 457         {
 458             OSQLParseNode * pOrderingSpec = pOrderingSpecCommalist->getChild(m);
 459             OSL_ENSURE(SQL_ISRULE(pOrderingSpec,ordering_spec),"OResultSet: Fehler im Parse Tree");
 460             OSL_ENSURE(pOrderingSpec->count() == 2,"OResultSet: Fehler im Parse Tree");
 461
 462             OSQLParseNode * pColumnRef = pOrderingSpec->getChild(0);
 463             if(!SQL_ISRULE(pColumnRef,column_ref))
 464             {
 465                 throw SQLException();
 466             }
 467             OSQLParseNode * pAscendingDescending = pOrderingSpec->getChild(1);
 468             setOrderbyColumn(pColumnRef,pAscendingDescending);
 469         }
 470     }
 471 }
 472
 473 void OCommonStatement::setOrderbyColumn(    OSQLParseNode* pColumnRef,
 474                                         OSQLParseNode* pAscendingDescending)
 475 {
 476     OUString aColumnName;
 477     if (pColumnRef->count() == 1)
 478         aColumnName = pColumnRef->getChild(0)->getTokenValue();
 479     else if (pColumnRef->count() == 3)
 480     {
 481         pColumnRef->getChild(2)->parseNodeToStr( aColumnName, getOwnConnection(), nullptr, false, false );
 482     }
 483     else
 484     {
 485         throw SQLException();
 486     }
 487
 488     Reference<XColumnLocate> xColLocate(m_xColNames,UNO_QUERY);
 489     if(!xColLocate.is())
 490         return;
 491
 492     m_aOrderbyColumnNumber.push_back(xColLocate->findColumn(aColumnName));
 493
 494     // Ascending or Descending?
 495     m_aOrderbyAscending.push_back((SQL_ISTOKEN(pAscendingDescending,DESC)) ? TAscendingOrder::DESC : TAscendingOrder::ASC);
 496 }
 497
 498
 499 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */