connectivity/source/drivers/mozab/MPreparedStatement.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: MPreparedStatement.cxx,v $
  10  * $Revision: 1.14.56.1 $
  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_connectivity.hxx"
  33 #include <stdio.h>
  34 #include <osl/diagnose.h>
  35 #include "connectivity/sdbcx/VColumn.hxx"
  36 #include "MPreparedStatement.hxx"
  37 #include <com/sun/star/sdbc/DataType.hpp>
  38 #include "MResultSetMetaData.hxx"
  39 #include <cppuhelper/typeprovider.hxx>
  40 #include <comphelper/sequence.hxx>
  41 #include <com/sun/star/lang/DisposedException.hpp>
  42 #include "connectivity/dbexception.hxx"
  43 #include "connectivity/dbtools.hxx"
  44 #include <comphelper/types.hxx>
  45 #include <com/sun/star/sdbc/ColumnValue.hpp>
  46 #include "diagnose_ex.h"
  47
  48 #if OSL_DEBUG_LEVEL > 0
  49 # define OUtoCStr( x ) ( ::rtl::OUStringToOString ( (x), RTL_TEXTENCODING_ASCII_US).getStr())
  50 #else /* OSL_DEBUG_LEVEL */
  51 # define OUtoCStr( x ) ("dummy")
  52 #endif /* OSL_DEBUG_LEVEL */
  53
  54 using namespace ::comphelper;
  55 using namespace connectivity;
  56 using namespace connectivity::mozab;
  57 using namespace com::sun::star::uno;
  58 using namespace com::sun::star::lang;
  59 using namespace com::sun::star::beans;
  60 using namespace com::sun::star::sdbc;
  61 using namespace com::sun::star::sdbcx;
  62 using namespace com::sun::star::container;
  63 using namespace com::sun::star::io;
  64 using namespace com::sun::star::util;
  65
  66 IMPLEMENT_SERVICE_INFO(OPreparedStatement,"com.sun.star.sdbcx.mozab.PreparedStatement","com.sun.star.sdbc.PreparedStatement");
  67
  68
  69 OPreparedStatement::OPreparedStatement( OConnection* _pConnection,const ::rtl::OUString& sql)
  70     :OCommonStatement(_pConnection)
  71     ,m_nNumParams(0)
  72     ,m_sSqlStatement(sql)
  73     ,m_bPrepared(sal_False)
  74     ,m_pResultSet()
  75 {
  76 }
  77 // -----------------------------------------------------------------------------
  78 OPreparedStatement::~OPreparedStatement()
  79 {
  80 }
  81 // -----------------------------------------------------------------------------
  82 void OPreparedStatement::lateInit()
  83 {
  84     if ( eSelect != parseSql( m_sSqlStatement ) )
  85         throw SQLException();
  86 }
  87 // -------------------------------------------------------------------------
  88 void SAL_CALL OPreparedStatement::disposing()
  89 {
  90     ::osl::MutexGuard aGuard(m_aMutex);
  91
  92     OCommonStatement::disposing();
  93
  94     m_xMetaData.clear();
  95     if(m_aParameterRow.isValid())
  96     {
  97         m_aParameterRow->get().clear();
  98         m_aParameterRow = NULL;
  99     }
 100     m_xParamColumns = NULL;
 101 }
 102 // -----------------------------------------------------------------------------
 103
 104 OCommonStatement::StatementType OPreparedStatement::parseSql( const ::rtl::OUString& sql , sal_Bool bAdjusted )
 105     throw ( ::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException )
 106 {
 107     StatementType eStatementType = OCommonStatement::parseSql( sql, bAdjusted );
 108     if ( eStatementType != eSelect )
 109         return eStatementType;
 110
 111     m_xParamColumns = new OSQLColumns();
 112
 113     // describe all parameters need for the resultset
 114     describeParameter();
 115
 116     Reference<XIndexAccess> xNames(m_xColNames,UNO_QUERY);
 117     OResultSet::setBoundedColumns( m_aRow, m_xParamColumns, xNames, sal_False, m_xDBMetaData, m_aColMapping );
 118
 119     return eStatementType;
 120 }
 121
 122 // -----------------------------------------------------------------------------
 123 void OPreparedStatement::initializeResultSet( OResultSet* _pResult )
 124 {
 125     OCommonStatement::initializeResultSet( _pResult );
 126     _pResult->setParameterColumns( m_xParamColumns );
 127     _pResult->setParameterRow( m_aParameterRow );
 128 }
 129
 130 // -----------------------------------------------------------------------------
 131 void OPreparedStatement::clearCachedResultSet()
 132 {
 133     OCommonStatement::clearCachedResultSet();
 134     m_pResultSet.clear();
 135     m_xMetaData.clear();
 136 }
 137 // -----------------------------------------------------------------------------
 138 void OPreparedStatement::cacheResultSet( const ::rtl::Reference< OResultSet >& _pResult )
 139 {
 140     OCommonStatement::cacheResultSet( _pResult );
 141     OSL_PRECOND( m_pResultSet == NULL, "OPreparedStatement::parseSql: you should call clearCachedResultSet before!" );
 142     m_pResultSet = _pResult;
 143 }
 144
 145 // -----------------------------------------------------------------------------
 146 void SAL_CALL OPreparedStatement::acquire() throw()
 147 {
 148     OCommonStatement::acquire();
 149 }
 150 // -----------------------------------------------------------------------------
 151 void SAL_CALL OPreparedStatement::release() throw()
 152 {
 153     OCommonStatement::release();
 154 }
 155 // -----------------------------------------------------------------------------
 156 Any SAL_CALL OPreparedStatement::queryInterface( const Type & rType ) throw(RuntimeException)
 157 {
 158     Any aRet = OCommonStatement::queryInterface(rType);
 159     if(!aRet.hasValue())
 160         aRet = OPreparedStatement_BASE::queryInterface(rType);
 161     return aRet;
 162 }
 163 // -------------------------------------------------------------------------
 164 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL OPreparedStatement::getTypes(  ) throw(::com::sun::star::uno::RuntimeException)
 165 {
 166     return ::comphelper::concatSequences(OPreparedStatement_BASE::getTypes(),OCommonStatement::getTypes());
 167 }
 168 // -------------------------------------------------------------------------
 169
 170 Reference< XResultSetMetaData > SAL_CALL OPreparedStatement::getMetaData(  ) throw(SQLException, RuntimeException)
 171 {
 172     ::osl::MutexGuard aGuard( m_aMutex );
 173     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 174
 175     sal_Bool bReadOnly = sal_True;
 176     if ( m_pResultSet.is() )
 177         bReadOnly = m_pResultSet->determineReadOnly();
 178     // if we do not have a result set, then we have not been executed, yet. In this case, assuming readonly=true is
 179     // okay, /me thinks.
 180
 181     if ( !m_xMetaData.is() )
 182         m_xMetaData = new OResultSetMetaData( m_pSQLIterator->getSelectColumns(), m_pSQLIterator->getTables().begin()->first ,m_pTable,bReadOnly );
 183
 184     return m_xMetaData;
 185 }
 186
 187 // -------------------------------------------------------------------------
 188 sal_Bool SAL_CALL OPreparedStatement::execute(  ) throw(SQLException, RuntimeException)
 189 {
 190     ::osl::MutexGuard aGuard( m_aMutex );
 191     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 192
 193     Reference< XResultSet> xResult = executeQuery();
 194     return xResult.is();
 195 }
 196 // -------------------------------------------------------------------------
 197
 198 sal_Int32 SAL_CALL OPreparedStatement::executeUpdate(  ) throw(SQLException, RuntimeException)
 199 {
 200     ::dbtools::throwFeatureNotImplementedException( "XStatement::executeUpdate", *this );
 201     return 0;
 202 }
 203 // -------------------------------------------------------------------------
 204
 205 void SAL_CALL OPreparedStatement::setString( sal_Int32 parameterIndex, const ::rtl::OUString& x ) throw(SQLException, RuntimeException)
 206 {
 207     ::osl::MutexGuard aGuard( m_aMutex );
 208     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 209
 210     OSL_TRACE("prepStmt::setString( %s )", OUtoCStr( x ) );
 211     setParameter( parameterIndex, x );
 212 }
 213 // -------------------------------------------------------------------------
 214
 215 Reference< XConnection > SAL_CALL OPreparedStatement::getConnection(  ) throw(SQLException, RuntimeException)
 216 {
 217     ::osl::MutexGuard aGuard( m_aMutex );
 218     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 219
 220     return (Reference< XConnection >)m_pConnection;
 221 }
 222 // -------------------------------------------------------------------------
 223
 224 Reference< XResultSet > SAL_CALL OPreparedStatement::executeQuery(  ) throw(SQLException, RuntimeException)
 225 {
 226     ::osl::MutexGuard aGuard( m_aMutex );
 227     OSL_TRACE("In: OPreparedStatement::executeQuery" );
 228     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 229
 230     // our statement has already been parsed in lateInit, no need to do all this (potentially expensive)
 231     // stuff again. Just execute.
 232     return impl_executeCurrentQuery();
 233 }
 234 // -------------------------------------------------------------------------
 235
 236 void SAL_CALL OPreparedStatement::setBoolean( sal_Int32 /*parameterIndex*/, sal_Bool /*x*/ ) throw(SQLException, RuntimeException)
 237 {
 238     ::dbtools::throwFeatureNotImplementedException( "XParameters::setBoolean", *this );
 239 }
 240 // -------------------------------------------------------------------------
 241 void SAL_CALL OPreparedStatement::setByte( sal_Int32 /*parameterIndex*/, sal_Int8 /*x*/ ) throw(SQLException, RuntimeException)
 242 {
 243     ::dbtools::throwFeatureNotImplementedException( "XParameters::setByte", *this );
 244 }
 245 // -------------------------------------------------------------------------
 246
 247 void SAL_CALL OPreparedStatement::setDate( sal_Int32 /*parameterIndex*/, const Date& /*aData*/ ) throw(SQLException, RuntimeException)
 248 {
 249     ::dbtools::throwFeatureNotImplementedException( "XParameters::setDate", *this );
 250 }
 251 // -------------------------------------------------------------------------
 252
 253
 254 void SAL_CALL OPreparedStatement::setTime( sal_Int32 /*parameterIndex*/, const Time& /*aVal*/ ) throw(SQLException, RuntimeException)
 255 {
 256     ::dbtools::throwFeatureNotImplementedException( "XParameters::setTime", *this );
 257 }
 258 // -------------------------------------------------------------------------
 259
 260 void SAL_CALL OPreparedStatement::setTimestamp( sal_Int32 /*parameterIndex*/, const DateTime& /*aVal*/ ) throw(SQLException, RuntimeException)
 261 {
 262     ::dbtools::throwFeatureNotImplementedException( "XParameters::setTimestamp", *this );
 263 }
 264 // -------------------------------------------------------------------------
 265
 266 void SAL_CALL OPreparedStatement::setDouble( sal_Int32 /*parameterIndex*/, double /*x*/ ) throw(SQLException, RuntimeException)
 267 {
 268     ::dbtools::throwFeatureNotImplementedException( "XParameters::setDouble", *this );
 269 }
 270
 271 // -------------------------------------------------------------------------
 272
 273 void SAL_CALL OPreparedStatement::setFloat( sal_Int32 /*parameterIndex*/, float /*x*/ ) throw(SQLException, RuntimeException)
 274 {
 275     ::dbtools::throwFeatureNotImplementedException( "XParameters::setFloat", *this );
 276 }
 277 // -------------------------------------------------------------------------
 278
 279 void SAL_CALL OPreparedStatement::setInt( sal_Int32 /*parameterIndex*/, sal_Int32 /*x*/ ) throw(SQLException, RuntimeException)
 280 {
 281     ::dbtools::throwFeatureNotImplementedException( "XParameters::setInt", *this );
 282 }
 283 // -------------------------------------------------------------------------
 284
 285 void SAL_CALL OPreparedStatement::setLong( sal_Int32 /*parameterIndex*/, sal_Int64 /*aVal*/ ) throw(SQLException, RuntimeException)
 286 {
 287     ::dbtools::throwFeatureNotImplementedException( "XParameters::setLong", *this );
 288 }
 289 // -------------------------------------------------------------------------
 290
 291 void SAL_CALL OPreparedStatement::setNull( sal_Int32 parameterIndex, sal_Int32 /*sqlType*/ ) throw(SQLException, RuntimeException)
 292 {
 293     ::osl::MutexGuard aGuard( m_aMutex );
 294     checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 295
 296     checkAndResizeParameters(parameterIndex);
 297
 298     (m_aParameterRow->get())[parameterIndex].setNull();
 299 }
 300 // -------------------------------------------------------------------------
 301
 302 void SAL_CALL OPreparedStatement::setClob( sal_Int32 /*parameterIndex*/, const Reference< XClob >& /*x*/ ) throw(SQLException, RuntimeException)
 303 {
 304     ::dbtools::throwFeatureNotImplementedException( "XParameters::setClob", *this );
 305 }
 306 // -------------------------------------------------------------------------
 307
 308 void SAL_CALL OPreparedStatement::setBlob( sal_Int32 /*parameterIndex*/, const Reference< XBlob >& /*x*/ ) throw(SQLException, RuntimeException)
 309 {
 310     ::dbtools::throwFeatureNotImplementedException( "XParameters::setBlob", *this );
 311 }
 312 // -------------------------------------------------------------------------
 313
 314 void SAL_CALL OPreparedStatement::setArray( sal_Int32 /*parameterIndex*/, const Reference< XArray >& /*x*/ ) throw(SQLException, RuntimeException)
 315 {
 316     ::dbtools::throwFeatureNotImplementedException( "XParameters::setArray", *this );
 317 }
 318 // -------------------------------------------------------------------------
 319
 320 void SAL_CALL OPreparedStatement::setRef( sal_Int32 /*parameterIndex*/, const Reference< XRef >& /*x*/ ) throw(SQLException, RuntimeException)
 321 {
 322     ::dbtools::throwFeatureNotImplementedException( "XParameters::setRef", *this );
 323 }
 324 // -------------------------------------------------------------------------
 325
 326 void SAL_CALL OPreparedStatement::setObjectWithInfo( sal_Int32 /*parameterIndex*/, const Any& /*x*/, sal_Int32 /*sqlType*/, sal_Int32 /*scale*/ ) throw(SQLException, RuntimeException)
 327 {
 328     ::dbtools::throwFeatureNotImplementedException( "XParameters::setObjectWithInfo", *this );
 329 }
 330 // -------------------------------------------------------------------------
 331
 332 void SAL_CALL OPreparedStatement::setObjectNull( sal_Int32 parameterIndex, sal_Int32 sqlType, const ::rtl::OUString& /*typeName*/ ) throw(SQLException, RuntimeException)
 333 {
 334     setNull(parameterIndex,sqlType);
 335 }
 336 // -------------------------------------------------------------------------
 337
 338 void SAL_CALL OPreparedStatement::setObject( sal_Int32 parameterIndex, const Any& x ) throw(SQLException, RuntimeException)
 339 {
 340     ::dbtools::implSetObject(this,parameterIndex,x);
 341 }
 342 // -------------------------------------------------------------------------
 343
 344 void SAL_CALL OPreparedStatement::setShort( sal_Int32 /*parameterIndex*/, sal_Int16 /*x*/ ) throw(SQLException, RuntimeException)
 345 {
 346     ::dbtools::throwFeatureNotImplementedException( "XParameters::setShort", *this );
 347 }
 348 // -------------------------------------------------------------------------
 349
 350 void SAL_CALL OPreparedStatement::setBytes( sal_Int32 /*parameterIndex*/, const Sequence< sal_Int8 >& /*x*/ ) throw(SQLException, RuntimeException)
 351 {
 352     ::dbtools::throwFeatureNotImplementedException( "XParameters::setBytes", *this );
 353 }
 354 // -------------------------------------------------------------------------
 355
 356
 357 void SAL_CALL OPreparedStatement::setCharacterStream( sal_Int32 /*parameterIndex*/, const Reference< ::com::sun::star::io::XInputStream >& /*x*/, sal_Int32 /*length*/ ) throw(SQLException, RuntimeException)
 358 {
 359     ::dbtools::throwFeatureNotImplementedException( "XParameters::setCharacterStream", *this );
 360 }
 361 // -------------------------------------------------------------------------
 362
 363 void SAL_CALL OPreparedStatement::setBinaryStream( sal_Int32 /*parameterIndex*/, const Reference< ::com::sun::star::io::XInputStream >& /*x*/, sal_Int32 /*length*/ ) throw(SQLException, RuntimeException)
 364 {
 365     ::dbtools::throwFeatureNotImplementedException( "XParameters::setBinaryStream", *this );
 366 }
 367 // -------------------------------------------------------------------------
 368
 369 void SAL_CALL OPreparedStatement::clearParameters(  ) throw(SQLException, RuntimeException)
 370 {
 371 }
 372 // -------------------------------------------------------------------------
 373 void OPreparedStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue) throw (Exception)
 374 {
 375     switch(nHandle)
 376     {
 377         case PROPERTY_ID_RESULTSETCONCURRENCY:
 378             break;
 379         case PROPERTY_ID_RESULTSETTYPE:
 380             break;
 381         case PROPERTY_ID_FETCHDIRECTION:
 382             break;
 383         case PROPERTY_ID_USEBOOKMARKS:
 384             break;
 385         default:
 386             OCommonStatement::setFastPropertyValue_NoBroadcast(nHandle,rValue);
 387     }
 388 }
 389 // -----------------------------------------------------------------------------
 390 void OPreparedStatement::checkParameterIndex(sal_Int32 _parameterIndex)
 391 {
 392     if( !_parameterIndex || _parameterIndex > m_nNumParams)
 393         ::dbtools::throwInvalidIndexException(*this);
 394 }
 395 // -----------------------------------------------------------------------------
 396 void OPreparedStatement::checkAndResizeParameters(sal_Int32 parameterIndex)
 397 {
 398     ::connectivity::checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
 399
 400     if ( !m_aParameterRow.isValid() ) {
 401         m_aParameterRow = new OValueVector();
 402         m_aParameterRow->get().push_back(sal_Int32(0));
 403     }
 404
 405     if ((sal_Int32)(m_aParameterRow->get()).size() <= parameterIndex)
 406         (m_aParameterRow->get()).resize(parameterIndex+1);
 407 }
 408 // -----------------------------------------------------------------------------
 409 void OPreparedStatement::setParameter(sal_Int32 parameterIndex, const
 410 ORowSetValue& x)
 411 {
 412     ::osl::MutexGuard aGuard( m_aMutex );
 413     checkAndResizeParameters(parameterIndex);
 414
 415     OSL_TRACE("setParameter( %d, '%s')", parameterIndex, OUtoCStr(x) );
 416     (m_aParameterRow->get())[parameterIndex] = x;
 417 }
 418
 419 //------------------------------------------------------------------
 420 sal_uInt32 OPreparedStatement::AddParameter(OSQLParseNode * pParameter, const Reference<XPropertySet>& _xCol)
 421 {
 422     OSL_UNUSED( pParameter );
 423     // Nr. des neu hinzuzufuegenden Parameters:
 424     sal_uInt32 nParameter = m_xParamColumns->get().size()+1;
 425
 426     OSL_ENSURE(SQL_ISRULE(pParameter,parameter),"OResultSet::AddParameter: Argument ist kein Parameter");
 427     OSL_ENSURE(pParameter->count() > 0,"OResultSet: Fehler im Parse Tree");
 428 #if OSL_DEBUG_LEVEL > 0
 429     OSQLParseNode * pMark = pParameter->getChild(0);
 430     OSL_UNUSED( pMark );
 431 #endif
 432
 433     ::rtl::OUString sParameterName;
 434
 435     // Parameter-Column aufsetzen:
 436     sal_Int32 eType = DataType::VARCHAR;
 437     sal_uInt32 nPrecision = 255;
 438     sal_Int32 nScale = 0;
 439     sal_Int32 nNullable = ColumnValue::NULLABLE;
 440
 441     if (_xCol.is())
 442     {
 443         // Typ, Precision, Scale ... der angegebenen Column verwenden,
 444         // denn dieser Column wird der Wert zugewiesen bzw. mit dieser
 445         // Column wird der Wert verglichen.
 446         eType = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE)));
 447         nPrecision = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION)));
 448         nScale = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE)));
 449         nNullable = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISNULLABLE)));
 450         _xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= sParameterName;
 451     }
 452
 453     Reference<XPropertySet> xParaColumn = new connectivity::sdbcx::OColumn(sParameterName
 454                                                     ,::rtl::OUString()
 455                                                     ,::rtl::OUString()
 456                                                     ,nNullable
 457                                                     ,nPrecision
 458                                                     ,nScale
 459                                                     ,eType
 460                                                     ,sal_False
 461                                                     ,sal_False
 462                                                     ,sal_False
 463                                                     ,m_pSQLIterator->isCaseSensitive());
 464     m_xParamColumns->get().push_back(xParaColumn);
 465     return nParameter;
 466 }
 467 // -----------------------------------------------------------------------------
 468 void OPreparedStatement::describeColumn(OSQLParseNode*
 469 _pParameter,OSQLParseNode* _pNode,const OSQLTable& _xTable)
 470 {
 471     Reference<XPropertySet> xProp;
 472     if(SQL_ISRULE(_pNode,column_ref))
 473     {
 474         ::rtl::OUString sColumnName,sTableRange;
 475         m_pSQLIterator->getColumnRange(_pNode,sColumnName,sTableRange);
 476         if(sColumnName.getLength())
 477         {
 478             Reference<XNameAccess> xNameAccess = _xTable->getColumns();
 479             if(xNameAccess->hasByName(sColumnName))
 480                 xNameAccess->getByName(sColumnName) >>= xProp;
 481             AddParameter(_pParameter,xProp);
 482         }
 483     }
 484     //  else
 485         //  AddParameter(_pParameter,xProp);
 486 }
 487 // -------------------------------------------------------------------------
 488 void OPreparedStatement::describeParameter()
 489 {
 490     ::std::vector< OSQLParseNode*> aParseNodes;
 491     scanParameter(m_pParseTree,aParseNodes);
 492     if(aParseNodes.size())
 493     {
 494         m_xParamColumns = new OSQLColumns();
 495         const OSQLTables& xTabs = m_pSQLIterator->getTables();
 496         if(xTabs.size())
 497         {
 498             OSQLTable xTable = xTabs.begin()->second;
 499             ::std::vector< OSQLParseNode*>::const_iterator aIter =
 500 aParseNodes.begin();
 501             for (;aIter != aParseNodes.end();++aIter )
 502             {
 503                 describeColumn(*aIter,(*aIter)->getParent()->getChild(0),xTable);
 504             }
 505         }
 506     }
 507 }
 508
 509 // -----------------------------------------------------------------------------
 510 void OPreparedStatement::scanParameter(OSQLParseNode* pParseNode,::std::vector< OSQLParseNode*>& _rParaNodes)
 511 {
 512     OSL_ENSURE(pParseNode != NULL,"OResultSet: interner Fehler: ungueltiger ParseNode");
 513
 514     // Parameter Name-Regel gefunden?
 515     if (SQL_ISRULE(pParseNode,parameter))
 516     {
 517         OSL_ENSURE(pParseNode->count() >= 1,"OResultSet: Parse Tree fehlerhaft");
 518         OSL_ENSURE(pParseNode->getChild(0)->getNodeType() == SQL_NODE_PUNCTUATION,"OResultSet: Parse Tree fehlerhaft");
 519
 520         _rParaNodes.push_back(pParseNode);
 521         // Weiterer Abstieg nicht erforderlich
 522         return;
 523     }
 524
 525     // Weiter absteigen im Parse Tree
 526     for (sal_uInt32 i = 0; i < pParseNode->count(); i++)
 527         scanParameter(pParseNode->getChild(i),_rParaNodes);
 528 }
 529 // -----------------------------------------------------------------------------
 530 ::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)
 531 {
 532     return NULL;
 533 }
 534 // -----------------------------------------------------------------------------
 535 sal_Int32 SAL_CALL OPreparedStatement::getUpdateCount(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 536 {
 537     return 0;
 538 }
 539 // -----------------------------------------------------------------------------
 540 sal_Bool SAL_CALL OPreparedStatement::getMoreResults(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 541 {
 542     return sal_False;
 543 }
 544 // -----------------------------------------------------------------------------
 545
 546