xref: /trunk/main/connectivity/source/drivers/ado/AStatement.cxx (revision cdf0e10c4e3984b49a9502b011690b615761d4a3) 
1 /*************************************************************************
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * Copyright 2000, 2010 Oracle and/or its affiliates.
6  *
7  * OpenOffice.org - a multi-platform office productivity suite
8  *
9  * This file is part of OpenOffice.org.
10  *
11  * OpenOffice.org is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License version 3
13  * only, as published by the Free Software Foundation.
14  *
15  * OpenOffice.org is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License version 3 for more details
19  * (a copy is included in the LICENSE file that accompanied this code).
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * version 3 along with OpenOffice.org.  If not, see
23  * <http://www.openoffice.org/license.html>
24  * for a copy of the LGPLv3 License.
25  *
26  ************************************************************************/
27 
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_connectivity.hxx"
30 #include "ado/AStatement.hxx"
31 #include "ado/AConnection.hxx"
32 #include "ado/AResultSet.hxx"
33 #include <comphelper/property.hxx>
34 #include <comphelper/uno3.hxx>
35 #include <osl/thread.h>
36 #include <cppuhelper/typeprovider.hxx>
37 #include <comphelper/sequence.hxx>
38 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
39 #include <com/sun/star/sdbc/ResultSetType.hpp>
40 #include <com/sun/star/sdbc/FetchDirection.hpp>
41 #include "connectivity/dbexception.hxx"
42 #include <comphelper/types.hxx>
43 
44 #undef max
45 
46 #include <algorithm>
47 
48 using namespace ::comphelper;
49 
50 #define CHECK_RETURN(x)                                                 \
51     if(!x)                                                              \
52         ADOS::ThrowException(*m_pConnection->getConnection(),*this);
53 
54 
55 
56 using namespace connectivity::ado;
57 
58 //------------------------------------------------------------------------------
59 using namespace com::sun::star::uno;
60 using namespace com::sun::star::lang;
61 using namespace com::sun::star::beans;
62 using namespace com::sun::star::sdbc;
63 using namespace ::std;
64 //------------------------------------------------------------------------------
65 OStatement_Base::OStatement_Base(OConnection* _pConnection ) :  OStatement_BASE(m_aMutex)
66                                                         ,OPropertySetHelper(OStatement_BASE::rBHelper)
67                                                         ,OSubComponent<OStatement_Base, OStatement_BASE>((::cppu::OWeakObject*)_pConnection, this)
68                                                         ,m_pConnection(_pConnection)
69                                                         ,m_nFetchSize(1)
70                                                         ,m_nMaxRows(0)
71                                                         ,m_eLockType(adLockReadOnly)
72                                                         ,m_eCursorType(adOpenForwardOnly)
73 {
74     osl_incrementInterlockedCount( &m_refCount );
75 
76     m_Command.Create();
77     if(m_Command.IsValid())
78         m_Command.putref_ActiveConnection(m_pConnection->getConnection());
79     else
80         ADOS::ThrowException(*m_pConnection->getConnection(),*this);
81 
82     m_RecordsAffected.setNoArg();
83     m_Parameters.setNoArg();
84 
85     m_pConnection->acquire();
86 
87     osl_decrementInterlockedCount( &m_refCount );
88 }
89 //------------------------------------------------------------------------------
90 void OStatement_Base::disposeResultSet()
91 {
92     // free the cursor if alive
93     Reference< XComponent > xComp(m_xResultSet.get(), UNO_QUERY);
94     if (xComp.is())
95         xComp->dispose();
96     m_xResultSet = Reference< XResultSet>();
97 }
98 
99 //------------------------------------------------------------------------------
100 void OStatement_Base::disposing()
101 {
102     ::osl::MutexGuard aGuard(m_aMutex);
103 
104 
105     disposeResultSet();
106 
107     if ( m_Command.IsValid() )
108         m_Command.putref_ActiveConnection( NULL );
109     m_Command.clear();
110 
111     if ( m_RecordSet.IsValid() )
112         m_RecordSet.PutRefDataSource( NULL );
113     m_RecordSet.clear();
114 
115     if (m_pConnection)
116         m_pConnection->release();
117 
118     dispose_ChildImpl();
119     OStatement_BASE::disposing();
120 }
121 //-----------------------------------------------------------------------------
122 void SAL_CALL OStatement_Base::release() throw()
123 {
124     relase_ChildImpl();
125 }
126 //-----------------------------------------------------------------------------
127 Any SAL_CALL OStatement_Base::queryInterface( const Type & rType ) throw(RuntimeException)
128 {
129     Any aRet = OStatement_BASE::queryInterface(rType);
130     return aRet.hasValue() ? aRet : OPropertySetHelper::queryInterface(rType);
131 }
132 // -------------------------------------------------------------------------
133 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL OStatement_Base::getTypes(  ) throw(::com::sun::star::uno::RuntimeException)
134 {
135     ::cppu::OTypeCollection aTypes( ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XMultiPropertySet > *)0 ),
136                                     ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XFastPropertySet > *)0 ),
137                                     ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > *)0 ));
138 
139     return ::comphelper::concatSequences(aTypes.getTypes(),OStatement_BASE::getTypes());
140 }
141 
142 // -------------------------------------------------------------------------
143 
144 void SAL_CALL OStatement_Base::cancel(  ) throw(RuntimeException)
145 {
146     ::osl::MutexGuard aGuard( m_aMutex );
147     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
148 
149 
150     CHECK_RETURN(m_Command.Cancel())
151 }
152 // -------------------------------------------------------------------------
153 
154 void SAL_CALL OStatement_Base::close(  ) throw(SQLException, RuntimeException)
155 {
156     {
157         ::osl::MutexGuard aGuard( m_aMutex );
158         checkDisposed(OStatement_BASE::rBHelper.bDisposed);
159 
160     }
161     dispose();
162 }
163 // -------------------------------------------------------------------------
164 
165 void SAL_CALL OStatement::clearBatch(  ) throw(SQLException, RuntimeException)
166 {
167 
168 }
169 // -------------------------------------------------------------------------
170 
171 void OStatement_Base::reset() throw (SQLException)
172 {
173     ::osl::MutexGuard aGuard( m_aMutex );
174     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
175 
176 
177     clearWarnings ();
178 
179     if (m_xResultSet.get().is())
180         clearMyResultSet();
181 }
182 //--------------------------------------------------------------------
183 // clearMyResultSet
184 // If a ResultSet was created for this Statement, close it
185 //--------------------------------------------------------------------
186 
187 void OStatement_Base::clearMyResultSet () throw (SQLException)
188 {
189     ::osl::MutexGuard aGuard( m_aMutex );
190     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
191 
192     try
193     {
194         Reference<XCloseable> xCloseable;
195         if ( ::comphelper::query_interface( m_xResultSet.get(), xCloseable ) )
196             xCloseable->close();
197     }
198     catch( const DisposedException& ) { }
199 
200     m_xResultSet = Reference< XResultSet >();
201 }
202 //--------------------------------------------------------------------
203 sal_Int32 OStatement_Base::getRowCount () throw( SQLException)
204 {
205     ::osl::MutexGuard aGuard( m_aMutex );
206     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
207 
208 
209     return m_RecordsAffected;
210 }
211 //--------------------------------------------------------------------
212 // getPrecision
213 // Given a SQL type, return the maximum precision for the column.
214 // Returns -1 if not known
215 //--------------------------------------------------------------------
216 
217 sal_Int32 OStatement_Base::getPrecision ( sal_Int32 sqlType)
218 {
219     ::osl::MutexGuard aGuard( m_aMutex );
220     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
221 
222 
223     sal_Int32 prec = -1;
224     OTypeInfo aInfo;
225     aInfo.nType = (sal_Int16)sqlType;
226     if (!m_aTypeInfo.empty())
227     {
228         ::std::vector<OTypeInfo>::const_iterator aIter = ::std::find(m_aTypeInfo.begin(),m_aTypeInfo.end(),aInfo);
229         for(;aIter != m_aTypeInfo.end();++aIter)
230         {
231             prec = ::std::max(prec,(*aIter).nPrecision);
232         }
233     }
234 
235     return prec;
236 }
237 //--------------------------------------------------------------------
238 // setWarning
239 // Sets the warning
240 //--------------------------------------------------------------------
241 
242 void OStatement_Base::setWarning (const SQLWarning &ex) throw( SQLException)
243 {
244     ::osl::MutexGuard aGuard( m_aMutex );
245     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
246 
247 
248     m_aLastWarning = ex;
249 }
250 // -------------------------------------------------------------------------
251 void OStatement_Base::assignRecordSet( ADORecordset* _pRS )
252 {
253     WpADORecordset aOldRS( m_RecordSet );
254     m_RecordSet = WpADORecordset( _pRS );
255 
256     if ( aOldRS.IsValid() )
257         aOldRS.PutRefDataSource( NULL );
258 
259     if ( m_RecordSet.IsValid() )
260         m_RecordSet.PutRefDataSource( (IDispatch*)m_Command );
261 }
262 // -------------------------------------------------------------------------
263 sal_Bool SAL_CALL OStatement_Base::execute( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException)
264 {
265     ::osl::MutexGuard aGuard( m_aMutex );
266     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
267 
268 
269     // Reset the statement handle and warning
270 
271     reset();
272 
273     try
274     {
275         ADORecordset* pSet = NULL;
276         CHECK_RETURN(m_Command.put_CommandText(sql))
277         CHECK_RETURN(m_Command.Execute(m_RecordsAffected,m_Parameters,adCmdText,&pSet))
278 
279         assignRecordSet( pSet );
280     }
281     catch (SQLWarning& ex)
282     {
283 
284         // Save pointer to warning and save with ResultSet
285         // object once it is created.
286 
287         m_aLastWarning = ex;
288     }
289 
290     return m_RecordSet.IsValid();
291 }
292 // -------------------------------------------------------------------------
293 Reference< XResultSet > SAL_CALL OStatement_Base::executeQuery( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException)
294 {
295     ::osl::MutexGuard aGuard( m_aMutex );
296     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
297 
298 
299     reset();
300 
301     m_xResultSet = WeakReference<XResultSet>(NULL);
302 
303     WpADORecordset aSet;
304     aSet.Create();
305     CHECK_RETURN(m_Command.put_CommandText(sql))
306     OLEVariant aCmd;
307     aCmd.setIDispatch(m_Command);
308     OLEVariant aCon;
309     aCon.setNoArg();
310     CHECK_RETURN(aSet.put_CacheSize(m_nFetchSize))
311     CHECK_RETURN(aSet.put_MaxRecords(m_nMaxRows))
312     CHECK_RETURN(aSet.Open(aCmd,aCon,m_eCursorType,m_eLockType,adOpenUnspecified))
313 
314 
315     CHECK_RETURN(aSet.get_CacheSize(m_nFetchSize))
316     CHECK_RETURN(aSet.get_MaxRecords(m_nMaxRows))
317     CHECK_RETURN(aSet.get_CursorType(m_eCursorType))
318     CHECK_RETURN(aSet.get_LockType(m_eLockType))
319 
320     OResultSet* pSet = new OResultSet(aSet,this);
321     Reference< XResultSet > xRs = pSet;
322     pSet->construct();
323 
324     m_xResultSet = WeakReference<XResultSet>(xRs);
325 
326     return xRs;
327 }
328 // -------------------------------------------------------------------------
329 
330 Reference< XConnection > SAL_CALL OStatement_Base::getConnection(  ) throw(SQLException, RuntimeException)
331 {
332     ::osl::MutexGuard aGuard( m_aMutex );
333     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
334 
335 
336     return (Reference< XConnection >)m_pConnection;
337 }
338 // -------------------------------------------------------------------------
339 
340 Any SAL_CALL OStatement::queryInterface( const Type & rType ) throw(RuntimeException)
341 {
342     Any aRet = ::cppu::queryInterface(rType,static_cast< XBatchExecution*> (this));
343     return aRet.hasValue() ? aRet : OStatement_Base::queryInterface(rType);
344 }
345 // -------------------------------------------------------------------------
346 
347 void SAL_CALL OStatement::addBatch( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException)
348 {
349     ::osl::MutexGuard aGuard( m_aMutex );
350     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
351 
352 
353     m_aBatchList.push_back(sql);
354 }
355 // -------------------------------------------------------------------------
356 Sequence< sal_Int32 > SAL_CALL OStatement::executeBatch(  ) throw(SQLException, RuntimeException)
357 {
358     ::osl::MutexGuard aGuard( m_aMutex );
359     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
360 
361 
362     reset();
363 
364     ::rtl::OUString aBatchSql;
365     sal_Int32 nLen = 0;
366     for(::std::list< ::rtl::OUString>::const_iterator i=m_aBatchList.begin();i != m_aBatchList.end();++i,++nLen)
367         aBatchSql = aBatchSql + *i + ::rtl::OUString::createFromAscii(";");
368 
369 
370     if ( m_RecordSet.IsValid() )
371         m_RecordSet.PutRefDataSource( NULL );
372     m_RecordSet.clear();
373     m_RecordSet.Create();
374 
375     CHECK_RETURN(m_Command.put_CommandText(aBatchSql))
376     if ( m_RecordSet.IsValid() )
377         m_RecordSet.PutRefDataSource((IDispatch*)m_Command);
378 
379     CHECK_RETURN(m_RecordSet.UpdateBatch(adAffectAll))
380 
381     ADORecordset* pSet=NULL;
382     Sequence< sal_Int32 > aRet(nLen);
383     sal_Int32* pArray = aRet.getArray();
384     for(sal_Int32 j=0;j<nLen;++j)
385     {
386         pSet = NULL;
387         OLEVariant aRecordsAffected;
388         if(m_RecordSet.NextRecordset(aRecordsAffected,&pSet) && pSet)
389         {
390             assignRecordSet( pSet );
391 
392             sal_Int32 nValue;
393             if(m_RecordSet.get_RecordCount(nValue))
394                 pArray[j] = nValue;
395         }
396     }
397     return aRet;
398 }
399 // -------------------------------------------------------------------------
400 
401 
402 sal_Int32 SAL_CALL OStatement_Base::executeUpdate( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException)
403 {
404     ::osl::MutexGuard aGuard( m_aMutex );
405     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
406 
407 
408     reset();
409 
410     try {
411         ADORecordset* pSet = NULL;
412         CHECK_RETURN(m_Command.put_CommandText(sql))
413         CHECK_RETURN(m_Command.Execute(m_RecordsAffected,m_Parameters,adCmdText|adExecuteNoRecords,&pSet))
414     }
415     catch (SQLWarning& ex) {
416 
417         // Save pointer to warning and save with ResultSet
418         // object once it is created.
419 
420         m_aLastWarning = ex;
421     }
422     if(!m_RecordsAffected.isEmpty() && !m_RecordsAffected.isNull() && m_RecordsAffected.getType() != VT_ERROR)
423         return m_RecordsAffected;
424 
425     return 0;
426 }
427 // -------------------------------------------------------------------------
428 
429 Reference< XResultSet > SAL_CALL OStatement_Base::getResultSet(  ) throw(SQLException, RuntimeException)
430 {
431     ::osl::MutexGuard aGuard( m_aMutex );
432     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
433 
434 
435     return m_xResultSet;
436 }
437 // -------------------------------------------------------------------------
438 
439 sal_Int32 SAL_CALL OStatement_Base::getUpdateCount(  ) throw(SQLException, RuntimeException)
440 {
441     ::osl::MutexGuard aGuard( m_aMutex );
442     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
443 
444 
445     sal_Int32 nRet;
446     if(m_RecordSet.IsValid() && m_RecordSet.get_RecordCount(nRet))
447         return nRet;
448     return -1;
449 }
450 // -------------------------------------------------------------------------
451 
452 sal_Bool SAL_CALL OStatement_Base::getMoreResults(  ) throw(SQLException, RuntimeException)
453 {
454     ::osl::MutexGuard aGuard( m_aMutex );
455     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
456 
457 
458     SQLWarning  warning;
459 
460     // clear previous warnings
461 
462     clearWarnings ();
463 
464     // Call SQLMoreResults
465 
466     try
467     {
468         ADORecordset* pSet=NULL;
469         OLEVariant aRecordsAffected;
470         if(m_RecordSet.IsValid() && m_RecordSet.NextRecordset(aRecordsAffected,&pSet) && pSet)
471             assignRecordSet( pSet );
472     }
473     catch (SQLWarning &ex)
474     {
475 
476         // Save pointer to warning and save with ResultSet
477         // object once it is created.
478 
479         warning = ex;
480     }
481     return m_RecordSet.IsValid();
482 }
483 // -------------------------------------------------------------------------
484 
485 // -------------------------------------------------------------------------
486 Any SAL_CALL OStatement_Base::getWarnings(  ) throw(SQLException, RuntimeException)
487 {
488     ::osl::MutexGuard aGuard( m_aMutex );
489     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
490 
491 
492     return makeAny(m_aLastWarning);
493 }
494 // -------------------------------------------------------------------------
495 
496 // -------------------------------------------------------------------------
497 void SAL_CALL OStatement_Base::clearWarnings(  ) throw(SQLException, RuntimeException)
498 {
499     ::osl::MutexGuard aGuard( m_aMutex );
500     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
501 
502 
503     m_aLastWarning = SQLWarning();
504 }
505 // -------------------------------------------------------------------------
506 //------------------------------------------------------------------------------
507 sal_Int32 OStatement_Base::getQueryTimeOut() const  throw(SQLException, RuntimeException)
508 {
509     return m_Command.get_CommandTimeout();
510 }
511 //------------------------------------------------------------------------------
512 sal_Int32 OStatement_Base::getMaxRows() const throw(SQLException, RuntimeException)
513 {
514     sal_Int32 nRet=-1;
515     if(!(m_RecordSet.IsValid() && m_RecordSet.get_MaxRecords(nRet)))
516         ::dbtools::throwFunctionSequenceException(NULL);
517     return nRet;
518 }
519 //------------------------------------------------------------------------------
520 sal_Int32 OStatement_Base::getResultSetConcurrency() const throw(SQLException, RuntimeException)
521 {
522     return m_eLockType;
523     sal_Int32 nValue=0;
524     switch(m_eLockType)
525     {
526         case adLockReadOnly:
527             nValue = ResultSetConcurrency::READ_ONLY;
528             break;
529         default:
530             nValue = ResultSetConcurrency::UPDATABLE;
531             break;
532     }
533 
534     return nValue;
535 }
536 //------------------------------------------------------------------------------
537 sal_Int32 OStatement_Base::getResultSetType() const throw(SQLException, RuntimeException)
538 {
539     sal_Int32 nValue=0;
540     switch(m_eCursorType)
541     {
542         case adOpenUnspecified:
543         case adOpenForwardOnly:
544             nValue = ResultSetType::FORWARD_ONLY;
545             break;
546         case adOpenStatic:
547         case adOpenKeyset:
548             nValue = ResultSetType::SCROLL_INSENSITIVE;
549             break;
550         case adOpenDynamic:
551             nValue = ResultSetType::SCROLL_SENSITIVE;
552             break;
553     }
554     return nValue;
555 }
556 //------------------------------------------------------------------------------
557 sal_Int32 OStatement_Base::getFetchDirection() const throw(SQLException, RuntimeException)
558 {
559     return FetchDirection::FORWARD;
560 }
561 //------------------------------------------------------------------------------
562 sal_Int32 OStatement_Base::getFetchSize() const throw(SQLException, RuntimeException)
563 {
564     return m_nFetchSize;
565 }
566 //------------------------------------------------------------------------------
567 sal_Int32 OStatement_Base::getMaxFieldSize() const throw(SQLException, RuntimeException)
568 {
569     return 0;
570 }
571 //------------------------------------------------------------------------------
572 ::rtl::OUString OStatement_Base::getCursorName() const throw(SQLException, RuntimeException)
573 {
574     return m_Command.GetName();
575 }
576 //------------------------------------------------------------------------------
577 void OStatement_Base::setQueryTimeOut(sal_Int32 seconds) throw(SQLException, RuntimeException)
578 {
579     ::osl::MutexGuard aGuard( m_aMutex );
580     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
581 
582 
583     m_Command.put_CommandTimeout(seconds);
584 }
585 //------------------------------------------------------------------------------
586 void OStatement_Base::setMaxRows(sal_Int32 _par0) throw(SQLException, RuntimeException)
587 {
588     ::osl::MutexGuard aGuard( m_aMutex );
589     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
590 
591     m_nMaxRows = _par0;
592 }
593 //------------------------------------------------------------------------------
594 void OStatement_Base::setResultSetConcurrency(sal_Int32 _par0) throw(SQLException, RuntimeException)
595 {
596     ::osl::MutexGuard aGuard( m_aMutex );
597     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
598 
599     switch(_par0)
600     {
601         case ResultSetConcurrency::READ_ONLY:
602             m_eLockType = adLockReadOnly;
603             break;
604         default:
605             m_eLockType = adLockOptimistic;
606             break;
607     }
608 }
609 //------------------------------------------------------------------------------
610 void OStatement_Base::setResultSetType(sal_Int32 _par0) throw(SQLException, RuntimeException)
611 {
612     ::osl::MutexGuard aGuard( m_aMutex );
613     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
614 
615 
616     switch(_par0)
617     {
618         case ResultSetType::FORWARD_ONLY:
619             m_eCursorType = adOpenForwardOnly;
620             break;
621         case ResultSetType::SCROLL_INSENSITIVE:
622             m_eCursorType = adOpenKeyset;
623             break;
624         case ResultSetType::SCROLL_SENSITIVE:
625             m_eCursorType = adOpenDynamic;
626             break;
627     }
628 }
629 //------------------------------------------------------------------------------
630 void OStatement_Base::setFetchDirection(sal_Int32 /*_par0*/) throw(SQLException, RuntimeException)
631 {
632     ::osl::MutexGuard aGuard( m_aMutex );
633     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
634     ::dbtools::throwFeatureNotImplementedException( "Statement::FetchDirection", *this );
635 }
636 //------------------------------------------------------------------------------
637 void OStatement_Base::setFetchSize(sal_Int32 _par0) throw(SQLException, RuntimeException)
638 {
639     ::osl::MutexGuard aGuard( m_aMutex );
640     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
641 
642 
643     m_nFetchSize = _par0;
644     //  m_RecordSet.put_CacheSize(_par0);
645 }
646 //------------------------------------------------------------------------------
647 void OStatement_Base::setMaxFieldSize(sal_Int32 /*_par0*/) throw(SQLException, RuntimeException)
648 {
649     ::osl::MutexGuard aGuard( m_aMutex );
650     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
651     ::dbtools::throwFeatureNotImplementedException( "Statement::MaxFieldSize", *this );
652 }
653 //------------------------------------------------------------------------------
654 void OStatement_Base::setCursorName(const ::rtl::OUString &_par0) throw(SQLException, RuntimeException)
655 {
656     ::osl::MutexGuard aGuard( m_aMutex );
657     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
658 
659     m_Command.put_Name(_par0);
660 }
661 
662 // -------------------------------------------------------------------------
663 ::cppu::IPropertyArrayHelper* OStatement_Base::createArrayHelper( ) const
664 {
665     Sequence< com::sun::star::beans::Property > aProps(10);
666     com::sun::star::beans::Property* pProperties = aProps.getArray();
667     sal_Int32 nPos = 0;
668     DECL_PROP0(CURSORNAME,  ::rtl::OUString);
669     DECL_BOOL_PROP0(ESCAPEPROCESSING);
670     DECL_PROP0(FETCHDIRECTION,sal_Int32);
671     DECL_PROP0(FETCHSIZE,   sal_Int32);
672     DECL_PROP0(MAXFIELDSIZE,sal_Int32);
673     DECL_PROP0(MAXROWS,     sal_Int32);
674     DECL_PROP0(QUERYTIMEOUT,sal_Int32);
675     DECL_PROP0(RESULTSETCONCURRENCY,sal_Int32);
676     DECL_PROP0(RESULTSETTYPE,sal_Int32);
677     DECL_BOOL_PROP0(USEBOOKMARKS);
678 
679 
680     return new ::cppu::OPropertyArrayHelper(aProps);
681 }
682 
683 // -------------------------------------------------------------------------
684 ::cppu::IPropertyArrayHelper & OStatement_Base::getInfoHelper()
685 {
686     return *const_cast<OStatement_Base*>(this)->getArrayHelper();
687 }
688 // -------------------------------------------------------------------------
689 sal_Bool OStatement_Base::convertFastPropertyValue(
690                             Any & rConvertedValue,
691                             Any & rOldValue,
692                             sal_Int32 nHandle,
693                             const Any& rValue )
694                                 throw (::com::sun::star::lang::IllegalArgumentException)
695 {
696     sal_Bool bModified = sal_False;
697 
698     sal_Bool bValidAdoRS = m_RecordSet.IsValid();
699         // some of the properties below, when set, are remembered in a member, and applied in the next execute
700         // For these properties, the record set does not need to be valid to allow setting them.
701         // For all others (where the values are forwarded to the ADO RS directly), the recordset must be valid.
702 
703     try
704     {
705         switch(nHandle)
706         {
707             case PROPERTY_ID_MAXROWS:
708                 bModified = ::comphelper::tryPropertyValue( rConvertedValue, rOldValue, rValue, bValidAdoRS ? getMaxRows() : m_nMaxRows );
709                 break;
710 
711             case PROPERTY_ID_RESULTSETTYPE:
712                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getResultSetType());
713                 break;
714             case PROPERTY_ID_FETCHSIZE:
715                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchSize());
716                 break;
717             case PROPERTY_ID_RESULTSETCONCURRENCY:
718                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getResultSetConcurrency());
719                 break;
720             case PROPERTY_ID_QUERYTIMEOUT:
721                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getQueryTimeOut());
722                 break;
723             case PROPERTY_ID_MAXFIELDSIZE:
724                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getMaxFieldSize());
725                 break;
726             case PROPERTY_ID_CURSORNAME:
727                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getCursorName());
728                 break;
729             case PROPERTY_ID_FETCHDIRECTION:
730                 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchDirection());
731                 break;
732         }
733     }
734     catch( const Exception& e )
735     {
736         bModified = sal_True;   // will ensure that the property is set
737         OSL_ENSURE( sal_False, "OStatement_Base::convertFastPropertyValue: caught something strange!" );
738         (void)e;
739     }
740     return bModified;
741 }
742 // -------------------------------------------------------------------------
743 void OStatement_Base::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue) throw (Exception)
744 {
745     switch(nHandle)
746     {
747         case PROPERTY_ID_QUERYTIMEOUT:
748             setQueryTimeOut(comphelper::getINT32(rValue));
749             break;
750         case PROPERTY_ID_MAXFIELDSIZE:
751             setMaxFieldSize(comphelper::getINT32(rValue));
752             break;
753         case PROPERTY_ID_MAXROWS:
754             setMaxRows(comphelper::getINT32(rValue));
755             break;
756         case PROPERTY_ID_CURSORNAME:
757             setCursorName(comphelper::getString(rValue));
758             break;
759         case PROPERTY_ID_RESULTSETCONCURRENCY:
760             setResultSetConcurrency(comphelper::getINT32(rValue));
761             break;
762         case PROPERTY_ID_RESULTSETTYPE:
763             setResultSetType(comphelper::getINT32(rValue));
764             break;
765         case PROPERTY_ID_FETCHDIRECTION:
766             setFetchDirection(comphelper::getINT32(rValue));
767             break;
768         case PROPERTY_ID_FETCHSIZE:
769             setFetchSize(comphelper::getINT32(rValue));
770             break;
771         case PROPERTY_ID_ESCAPEPROCESSING:
772             //  return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_bAsLink);
773         case PROPERTY_ID_USEBOOKMARKS:
774             //  return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_bAsLink);
775         default:
776             ;
777     }
778 }
779 // -------------------------------------------------------------------------
780 void OStatement_Base::getFastPropertyValue(Any& rValue,sal_Int32 nHandle) const
781 {
782     switch(nHandle)
783     {
784         case PROPERTY_ID_QUERYTIMEOUT:
785             rValue <<= getQueryTimeOut();
786             break;
787         case PROPERTY_ID_MAXFIELDSIZE:
788             rValue <<= getMaxFieldSize();
789             break;
790         case PROPERTY_ID_MAXROWS:
791             rValue <<= getMaxRows();
792             break;
793         case PROPERTY_ID_CURSORNAME:
794             rValue <<= getCursorName();
795             break;
796         case PROPERTY_ID_RESULTSETCONCURRENCY:
797             rValue <<= getResultSetConcurrency();
798             break;
799         case PROPERTY_ID_RESULTSETTYPE:
800             rValue <<= getResultSetType();
801             break;
802         case PROPERTY_ID_FETCHDIRECTION:
803             rValue <<= getFetchDirection();
804             break;
805         case PROPERTY_ID_FETCHSIZE:
806             rValue <<= getFetchSize();
807             break;
808         case PROPERTY_ID_ESCAPEPROCESSING:
809             rValue <<= sal_True;
810             break;
811         case PROPERTY_ID_USEBOOKMARKS:
812         default:
813             ;
814     }
815 }
816 // -------------------------------------------------------------------------
817 OStatement::~OStatement()
818 {
819 }
820 IMPLEMENT_SERVICE_INFO(OStatement,"com.sun.star.sdbcx.AStatement","com.sun.star.sdbc.Statement");
821 // -----------------------------------------------------------------------------
822 void SAL_CALL OStatement_Base::acquire() throw()
823 {
824     OStatement_BASE::acquire();
825 }
826 // -----------------------------------------------------------------------------
827 void SAL_CALL OStatement::acquire() throw()
828 {
829     OStatement_Base::acquire();
830 }
831 // -----------------------------------------------------------------------------
832 void SAL_CALL OStatement::release() throw()
833 {
834     OStatement_Base::release();
835 }
836 // -----------------------------------------------------------------------------
837 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL OStatement_Base::getPropertySetInfo(  ) throw(::com::sun::star::uno::RuntimeException)
838 {
839     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
840 }
841 // -----------------------------------------------------------------------------
842