connectivity/source/drivers/mozab/MPreparedStatement.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #include <stdio.h>
  30 #include <osl/diagnose.h>
  31 #include "connectivity/sdbcx/VColumn.hxx"
  32 #include "MPreparedStatement.hxx"
  33 #include <com/sun/star/sdbc/DataType.hpp>
  34 #include "MResultSetMetaData.hxx"
  35 #include <cppuhelper/typeprovider.hxx>
  36 #include <comphelper/sequence.hxx>
  37 #include <com/sun/star/lang/DisposedException.hpp>
  38 #include "connectivity/dbexception.hxx"
  39 #include "connectivity/dbtools.hxx"
  40 #include <comphelper/types.hxx>
  41 #include <com/sun/star/sdbc/ColumnValue.hpp>
  42 #include "diagnose_ex.h"
  43
  44 #if OSL_DEBUG_LEVEL > 0
  45 # define OUtoCStr( x ) ( ::rtl::OUStringToOString ( (x), RTL_TEXTENCODING_ASCII_US).getStr())
  46 #else /* OSL_DEBUG_LEVEL */
  47 # define OUtoCStr( x ) ("dummy")
  48 #endif /* OSL_DEBUG_LEVEL */
  49
  50 using namespace ::comphelper;
  51 using namespace connectivity;
  52 using namespace connectivity::mozab;
  53 using namespace com::sun::star::uno;
  54 using namespace com::sun::star::lang;
  55 using namespace com::sun::star::beans;
  56 using namespace com::sun::star::sdbc;
  57 using namespace com::sun::star::sdbcx;
  58 using namespace com::sun::star::container;
  59 using namespace com::sun::star::io;
  60 using namespace com::sun::star::util;
  61
  62 IMPLEMENT_SERVICE_INFO(OPreparedStatement,"com.sun.star.sdbcx.mozab.PreparedStatement","com.sun.star.sdbc.PreparedStatement");
  63
  64
  65 OPreparedStatement::OPreparedStatement( OConnection* _pConnection,const ::rtl::OUString& sql)
  66     :OCommonStatement(_pConnection)
  67     ,m_nNumParams(0)
  68     ,m_sSqlStatement(sql)
  69     ,m_bPrepared(sal_False)
  70     ,m_pResultSet()
  71 {
  72 }
  73 // -----------------------------------------------------------------------------
  74 OPreparedStatement::~OPreparedStatement()
  75 {
  76 }
  77 // -----------------------------------------------------------------------------
  78 void OPreparedStatement::lateInit()
  79 {
  80     if ( eSelect != parseSql( m_sSqlStatement ) )
  81         throw SQLException();
  82 }
  83 // -------------------------------------------------------------------------
  84 void SAL_CALL OPreparedStatement::disposing()
  85 {
  86     ::osl::MutexGuard aGuard(m_aMutex);
  87
  88     OCommonStatement::disposing();
  89
  90     m_xMetaData.clear();
  91     if(m_aParameterRow.is())
  92     {
  93         m_aParameterRow->get().clear();
  94         m_aParameterRow = NULL;
  95     }
  96     m_xParamColumns = NULL;
  97 }
  98 // -----------------------------------------------------------------------------
  99
 100 OCommonStatement::StatementType OPreparedStatement::parseSql( const ::rtl::OUString& sql , sal_Bool bAdjusted )
 101     throw ( ::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException )
 102 {
 103     StatementType eStatementType = OCommonStatement::parseSql( sql, bAdjusted );
 104     if ( eStatementType != eSelect )
 105         return eStatementType;
 106
 107     m_xParamColumns = new OSQLColumns();
 108
 109     // describe all parameters need for the resultset
 110     describeParameter();
 111
 112     Reference<XIndexAccess> xNames(m_xColNames,UNO_QUERY);
 113     OResultSet::setBoundedColumns( m_aRow, m_xParamColumns, xNames, sal_False, m_xDBMetaData, m_aColMapping );
 114
 115     return eStatementType;
 116 }
 117
 118 // -----------------------------------------------------------------------------
 119 void OPreparedStatement::initializeResultSet( OResultSet* _pResult )
 120 {
 121     OCommonStatement::initializeResultSet( _pResult );
 122     _pResult->setParameterColumns( m_xParamColumns );
 123     _pResult->setParameterRow( m_aParameterRow );
 124 }
 125
 126 // -----------------------------------------------------------------------------
 127 void OPreparedStatement::clearCachedResultSet()
 128 {
 129     OCommonStatement::clearCachedResultSet();
 130     m_pResultSet.clear();
 131     m_xMetaData.clear();
 132 }
 133 // -----------------------------------------------------------------------------
 134 void OPreparedStatement::cacheResultSet( const ::rtl::Reference< OResultSet >& _pResult )
 135 {
 136     OCommonStatement::cacheResultSet( _pResult );
 137     OSL_PRECOND( m_pResultSet == NULL, "OPreparedStatement::parseSql: you should call clearCachedResultSet before!" );
 138     m_pResultSet = _pResult;
 139 }
 140
 141 // -----------------------------------------------------------------------------
 142 void SAL_CALL OPreparedStatement::acquire() throw()
 143 {
 144     OCommonStatement::acquire();
 145 }
 146 // -----------------------------------------------------------------------------
 147 void SAL_CALL OPreparedStatement::release() throw()
 148 {
 149     OCommonStatement::release();
 150 }
 151 // -----------------------------------------------------------------------------
 152 Any SAL_CALL OPreparedStatement::queryInterface( const Type & rType ) throw(RuntimeException)
 153 {
 154     Any aRet = OCommonStatement::queryInterface(rType);
 155     if(!aRet.hasValue())
 156         aRet = OPreparedStatement_BASE::queryInterface(rType);
 157     return aRet;
 158 }
 159 // -------------------------------------------------------------------------
 160 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL OPreparedStatement::getTypes(  ) throw(::com::sun::star::uno::RuntimeException)
 161 {
 162     return ::comphelper::concatSequences(OPreparedStatement_BASE::getTypes(),OCommonStatement::getTypes());
 163 }
 164 // -------------------------------------------------------------------------
 165
 166 Reference< XResultSetMetaData > SAL_CALL OPreparedStatement::getMetaData(  ) throw(SQLException, RuntimeException)
 167 {
 168     ::osl::MutexGuard aGuard( m_aMutex );
 169     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 170
 171     sal_Bool bReadOnly = sal_True;
 172     if ( m_pResultSet.is() )
 173         bReadOnly = m_pResultSet->determineReadOnly();
 174     // if we do not have a result set, then we have not been executed, yet. In this case, assuming readonly=true is
 175     // okay, /me thinks.
 176
 177     if ( !m_xMetaData.is() )
 178         m_xMetaData = new OResultSetMetaData( m_pSQLIterator->getSelectColumns(), m_pSQLIterator->getTables().begin()->first ,m_pTable,bReadOnly );
 179
 180     return m_xMetaData;
 181 }
 182
 183 // -------------------------------------------------------------------------
 184 sal_Bool SAL_CALL OPreparedStatement::execute(  ) throw(SQLException, RuntimeException)
 185 {
 186     ::osl::MutexGuard aGuard( m_aMutex );
 187     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 188
 189     Reference< XResultSet> xResult = executeQuery();
 190     return xResult.is();
 191 }
 192 // -------------------------------------------------------------------------
 193
 194 sal_Int32 SAL_CALL OPreparedStatement::executeUpdate(  ) throw(SQLException, RuntimeException)
 195 {
 196     ::dbtools::throwFeatureNotImplementedException( "XStatement::executeUpdate", *this );
 197     return 0;
 198 }
 199 // -------------------------------------------------------------------------
 200
 201 void SAL_CALL OPreparedStatement::setString( sal_Int32 parameterIndex, const ::rtl::OUString& x ) throw(SQLException, RuntimeException)
 202 {
 203     ::osl::MutexGuard aGuard( m_aMutex );
 204     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 205
 206     OSL_TRACE("prepStmt::setString( %s )", OUtoCStr( x ) );
 207     setParameter( parameterIndex, x );
 208 }
 209 // -------------------------------------------------------------------------
 210
 211 Reference< XConnection > SAL_CALL OPreparedStatement::getConnection(  ) throw(SQLException, RuntimeException)
 212 {
 213     ::osl::MutexGuard aGuard( m_aMutex );
 214     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 215
 216     return (Reference< XConnection >)m_pConnection;
 217 }
 218 // -------------------------------------------------------------------------
 219
 220 Reference< XResultSet > SAL_CALL OPreparedStatement::executeQuery(  ) throw(SQLException, RuntimeException)
 221 {
 222     ::osl::MutexGuard aGuard( m_aMutex );
 223     OSL_TRACE("In: OPreparedStatement::executeQuery" );
 224     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 225
 226     // our statement has already been parsed in lateInit, no need to do all this (potentially expensive)
 227     // stuff again. Just execute.
 228     return impl_executeCurrentQuery();
 229 }
 230 // -------------------------------------------------------------------------
 231
 232 void SAL_CALL OPreparedStatement::setBoolean( sal_Int32 /*parameterIndex*/, sal_Bool /*x*/ ) throw(SQLException, RuntimeException)
 233 {
 234     ::dbtools::throwFeatureNotImplementedException( "XParameters::setBoolean", *this );
 235 }
 236 // -------------------------------------------------------------------------
 237 void SAL_CALL OPreparedStatement::setByte( sal_Int32 /*parameterIndex*/, sal_Int8 /*x*/ ) throw(SQLException, RuntimeException)
 238 {
 239     ::dbtools::throwFeatureNotImplementedException( "XParameters::setByte", *this );
 240 }
 241 // -------------------------------------------------------------------------
 242
 243 void SAL_CALL OPreparedStatement::setDate( sal_Int32 /*parameterIndex*/, const Date& /*aData*/ ) throw(SQLException, RuntimeException)
 244 {
 245     ::dbtools::throwFeatureNotImplementedException( "XParameters::setDate", *this );
 246 }
 247 // -------------------------------------------------------------------------
 248
 249
 250 void SAL_CALL OPreparedStatement::setTime( sal_Int32 /*parameterIndex*/, const Time& /*aVal*/ ) throw(SQLException, RuntimeException)
 251 {
 252     ::dbtools::throwFeatureNotImplementedException( "XParameters::setTime", *this );
 253 }
 254 // -------------------------------------------------------------------------
 255
 256 void SAL_CALL OPreparedStatement::setTimestamp( sal_Int32 /*parameterIndex*/, const DateTime& /*aVal*/ ) throw(SQLException, RuntimeException)
 257 {
 258     ::dbtools::throwFeatureNotImplementedException( "XParameters::setTimestamp", *this );
 259 }
 260 // -------------------------------------------------------------------------
 261
 262 void SAL_CALL OPreparedStatement::setDouble( sal_Int32 /*parameterIndex*/, double /*x*/ ) throw(SQLException, RuntimeException)
 263 {
 264     ::dbtools::throwFeatureNotImplementedException( "XParameters::setDouble", *this );
 265 }
 266
 267 // -------------------------------------------------------------------------
 268
 269 void SAL_CALL OPreparedStatement::setFloat( sal_Int32 /*parameterIndex*/, float /*x*/ ) throw(SQLException, RuntimeException)
 270 {
 271     ::dbtools::throwFeatureNotImplementedException( "XParameters::setFloat", *this );
 272 }
 273 // -------------------------------------------------------------------------
 274
 275 void SAL_CALL OPreparedStatement::setInt( sal_Int32 /*parameterIndex*/, sal_Int32 /*x*/ ) throw(SQLException, RuntimeException)
 276 {
 277     ::dbtools::throwFeatureNotImplementedException( "XParameters::setInt", *this );
 278 }
 279 // -------------------------------------------------------------------------
 280
 281 void SAL_CALL OPreparedStatement::setLong( sal_Int32 /*parameterIndex*/, sal_Int64 /*aVal*/ ) throw(SQLException, RuntimeException)
 282 {
 283     ::dbtools::throwFeatureNotImplementedException( "XParameters::setLong", *this );
 284 }
 285 // -------------------------------------------------------------------------
 286
 287 void SAL_CALL OPreparedStatement::setNull( sal_Int32 parameterIndex, sal_Int32 /*sqlType*/ ) throw(SQLException, RuntimeException)
 288 {
 289     ::osl::MutexGuard aGuard( m_aMutex );
 290     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 291
 292     checkAndResizeParameters(parameterIndex);
 293
 294     (m_aParameterRow->get())[parameterIndex].setNull();
 295 }
 296 // -------------------------------------------------------------------------
 297
 298 void SAL_CALL OPreparedStatement::setClob( sal_Int32 /*parameterIndex*/, const Reference< XClob >& /*x*/ ) throw(SQLException, RuntimeException)
 299 {
 300     ::dbtools::throwFeatureNotImplementedException( "XParameters::setClob", *this );
 301 }
 302 // -------------------------------------------------------------------------
 303
 304 void SAL_CALL OPreparedStatement::setBlob( sal_Int32 /*parameterIndex*/, const Reference< XBlob >& /*x*/ ) throw(SQLException, RuntimeException)
 305 {
 306     ::dbtools::throwFeatureNotImplementedException( "XParameters::setBlob", *this );
 307 }
 308 // -------------------------------------------------------------------------
 309
 310 void SAL_CALL OPreparedStatement::setArray( sal_Int32 /*parameterIndex*/, const Reference< XArray >& /*x*/ ) throw(SQLException, RuntimeException)
 311 {
 312     ::dbtools::throwFeatureNotImplementedException( "XParameters::setArray", *this );
 313 }
 314 // -------------------------------------------------------------------------
 315
 316 void SAL_CALL OPreparedStatement::setRef( sal_Int32 /*parameterIndex*/, const Reference< XRef >& /*x*/ ) throw(SQLException, RuntimeException)
 317 {
 318     ::dbtools::throwFeatureNotImplementedException( "XParameters::setRef", *this );
 319 }
 320 // -------------------------------------------------------------------------
 321
 322 void SAL_CALL OPreparedStatement::setObjectWithInfo( sal_Int32 /*parameterIndex*/, const Any& /*x*/, sal_Int32 /*sqlType*/, sal_Int32 /*scale*/ ) throw(SQLException, RuntimeException)
 323 {
 324     ::dbtools::throwFeatureNotImplementedException( "XParameters::setObjectWithInfo", *this );
 325 }
 326 // -------------------------------------------------------------------------
 327
 328 void SAL_CALL OPreparedStatement::setObjectNull( sal_Int32 parameterIndex, sal_Int32 sqlType, const ::rtl::OUString& /*typeName*/ ) throw(SQLException, RuntimeException)
 329 {
 330     setNull(parameterIndex,sqlType);
 331 }
 332 // -------------------------------------------------------------------------
 333
 334 void SAL_CALL OPreparedStatement::setObject( sal_Int32 parameterIndex, const Any& x ) throw(SQLException, RuntimeException)
 335 {
 336     ::dbtools::implSetObject(this,parameterIndex,x);
 337 }
 338 // -------------------------------------------------------------------------
 339
 340 void SAL_CALL OPreparedStatement::setShort( sal_Int32 /*parameterIndex*/, sal_Int16 /*x*/ ) throw(SQLException, RuntimeException)
 341 {
 342     ::dbtools::throwFeatureNotImplementedException( "XParameters::setShort", *this );
 343 }
 344 // -------------------------------------------------------------------------
 345
 346 void SAL_CALL OPreparedStatement::setBytes( sal_Int32 /*parameterIndex*/, const Sequence< sal_Int8 >& /*x*/ ) throw(SQLException, RuntimeException)
 347 {
 348     ::dbtools::throwFeatureNotImplementedException( "XParameters::setBytes", *this );
 349 }
 350 // -------------------------------------------------------------------------
 351
 352
 353 void SAL_CALL OPreparedStatement::setCharacterStream( sal_Int32 /*parameterIndex*/, const Reference< ::com::sun::star::io::XInputStream >& /*x*/, sal_Int32 /*length*/ ) throw(SQLException, RuntimeException)
 354 {
 355     ::dbtools::throwFeatureNotImplementedException( "XParameters::setCharacterStream", *this );
 356 }
 357 // -------------------------------------------------------------------------
 358
 359 void SAL_CALL OPreparedStatement::setBinaryStream( sal_Int32 /*parameterIndex*/, const Reference< ::com::sun::star::io::XInputStream >& /*x*/, sal_Int32 /*length*/ ) throw(SQLException, RuntimeException)
 360 {
 361     ::dbtools::throwFeatureNotImplementedException( "XParameters::setBinaryStream", *this );
 362 }
 363 // -------------------------------------------------------------------------
 364
 365 void SAL_CALL OPreparedStatement::clearParameters(  ) throw(SQLException, RuntimeException)
 366 {
 367 }
 368 // -------------------------------------------------------------------------
 369 void OPreparedStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue) throw (Exception)
 370 {
 371     switch(nHandle)
 372     {
 373         case PROPERTY_ID_RESULTSETCONCURRENCY:
 374             break;
 375         case PROPERTY_ID_RESULTSETTYPE:
 376             break;
 377         case PROPERTY_ID_FETCHDIRECTION:
 378             break;
 379         case PROPERTY_ID_USEBOOKMARKS:
 380             break;
 381         default:
 382             OCommonStatement::setFastPropertyValue_NoBroadcast(nHandle,rValue);
 383     }
 384 }
 385
 386 // -----------------------------------------------------------------------------
 387 void OPreparedStatement::checkAndResizeParameters(sal_Int32 parameterIndex)
 388 {
 389     ::connectivity::checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 390
 391     if ( !m_aParameterRow.is() ) {
 392         m_aParameterRow = new OValueVector();
 393         m_aParameterRow->get().push_back(sal_Int32(0));
 394     }
 395
 396     if ((sal_Int32)(m_aParameterRow->get()).size() <= parameterIndex)
 397         (m_aParameterRow->get()).resize(parameterIndex+1);
 398 }
 399 // -----------------------------------------------------------------------------
 400 void OPreparedStatement::setParameter(sal_Int32 parameterIndex, const
 401 ORowSetValue& x)
 402 {
 403     ::osl::MutexGuard aGuard( m_aMutex );
 404     checkAndResizeParameters(parameterIndex);
 405
 406     OSL_TRACE("setParameter( %d, '%s')", parameterIndex, OUtoCStr(x) );
 407     (m_aParameterRow->get())[parameterIndex] = x;
 408 }
 409
 410 //------------------------------------------------------------------
 411 size_t OPreparedStatement::AddParameter(OSQLParseNode * pParameter, const Reference<XPropertySet>& _xCol)
 412 {
 413     OSL_UNUSED( pParameter );
 414     // Count of the newly added Parameters
 415     size_t nParameter = m_xParamColumns->get().size()+1;
 416
 417     OSL_ENSURE(SQL_ISRULE(pParameter,parameter),"OResultSet::AddParameter: Argument is not a Parameter");
 418     OSL_ENSURE(pParameter->count() > 0,"OResultSet: error in parse tree");
 419 #if OSL_DEBUG_LEVEL > 0
 420     OSQLParseNode * pMark = pParameter->getChild(0);
 421     OSL_UNUSED( pMark );
 422 #endif
 423
 424     ::rtl::OUString sParameterName;
 425
 426     // set up Parameter-Column:
 427     sal_Int32 eType = DataType::VARCHAR;
 428     sal_uInt32 nPrecision = 255;
 429     sal_Int32 nScale = 0;
 430     sal_Int32 nNullable = ColumnValue::NULLABLE;
 431
 432     if (_xCol.is())
 433     {
 434         // Type, Precision, Scale ... utilize the selected Columns,
 435         // then this Column will get the value assigned or with this
 436         // Column will the value be compared.
 437         eType = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE)));
 438         nPrecision = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION)));
 439         nScale = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE)));
 440         nNullable = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISNULLABLE)));
 441         _xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= sParameterName;
 442     }
 443
 444     Reference<XPropertySet> xParaColumn = new connectivity::sdbcx::OColumn(sParameterName
 445                                                     ,::rtl::OUString()
 446                                                     ,::rtl::OUString()
 447                                                     ,::rtl::OUString()
 448                                                     ,nNullable
 449                                                     ,nPrecision
 450                                                     ,nScale
 451                                                     ,eType
 452                                                     ,sal_False
 453                                                     ,sal_False
 454                                                     ,sal_False
 455                                                     ,m_pSQLIterator->isCaseSensitive());
 456     m_xParamColumns->get().push_back(xParaColumn);
 457     return nParameter;
 458 }
 459 // -----------------------------------------------------------------------------
 460 void OPreparedStatement::describeColumn(OSQLParseNode*
 461 _pParameter,OSQLParseNode* _pNode,const OSQLTable& _xTable)
 462 {
 463     Reference<XPropertySet> xProp;
 464     if(SQL_ISRULE(_pNode,column_ref))
 465     {
 466         ::rtl::OUString sColumnName,sTableRange;
 467         m_pSQLIterator->getColumnRange(_pNode,sColumnName,sTableRange);
 468         if(!sColumnName.isEmpty())
 469         {
 470             Reference<XNameAccess> xNameAccess = _xTable->getColumns();
 471             if(xNameAccess->hasByName(sColumnName))
 472                 xNameAccess->getByName(sColumnName) >>= xProp;
 473             AddParameter(_pParameter,xProp);
 474         }
 475     }
 476     //  else
 477         //  AddParameter(_pParameter,xProp);
 478 }
 479 // -------------------------------------------------------------------------
 480 void OPreparedStatement::describeParameter()
 481 {
 482     ::std::vector< OSQLParseNode*> aParseNodes;
 483     scanParameter(m_pParseTree,aParseNodes);
 484     if(!aParseNodes.empty())
 485     {
 486         m_xParamColumns = new OSQLColumns();
 487         const OSQLTables& xTabs = m_pSQLIterator->getTables();
 488         if(xTabs.size())
 489         {
 490             OSQLTable xTable = xTabs.begin()->second;
 491             ::std::vector< OSQLParseNode*>::const_iterator aIter =
 492 aParseNodes.begin();
 493             for (;aIter != aParseNodes.end();++aIter )
 494             {
 495                 describeColumn(*aIter,(*aIter)->getParent()->getChild(0),xTable);
 496             }
 497         }
 498     }
 499 }
 500
 501 // -----------------------------------------------------------------------------
 502 void OPreparedStatement::scanParameter(OSQLParseNode* pParseNode,::std::vector< OSQLParseNode*>& _rParaNodes)
 503 {
 504     OSL_ENSURE(pParseNode != NULL,"OResultSet: internal error: invalid ParseNode");
 505
 506     // Parameter Name-Row found?
 507     if (SQL_ISRULE(pParseNode,parameter))
 508     {
 509         OSL_ENSURE(pParseNode->count() >= 1,"OResultSet: Faulty Parse Tree");
 510         OSL_ENSURE(pParseNode->getChild(0)->getNodeType() == SQL_NODE_PUNCTUATION,"OResultSet: Faulty Parse Tree");
 511
 512         _rParaNodes.push_back(pParseNode);
 513         // further search isn't necessary
 514         return;
 515     }
 516
 517     // Search on in Parse Tree
 518     for (sal_uInt32 i = 0; i < pParseNode->count(); i++)
 519         scanParameter(pParseNode->getChild(i),_rParaNodes);
 520 }
 521 // -----------------------------------------------------------------------------
 522 ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XResultSet > SAL_CALL OPreparedStatement::getResultSet(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 523 {
 524     return NULL;
 525 }
 526 // -----------------------------------------------------------------------------
 527 sal_Int32 SAL_CALL OPreparedStatement::getUpdateCount(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 528 {
 529     return 0;
 530 }
 531 // -----------------------------------------------------------------------------
 532 sal_Bool SAL_CALL OPreparedStatement::getMoreResults(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 533 {
 534     return sal_False;
 535 }
 536 // -----------------------------------------------------------------------------
 537
 538
 539 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */