1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_connectivity.hxx"
26 #include "ado/AResultSet.hxx"
27 #include "ado/AResultSetMetaData.hxx"
28 #include <com/sun/star/sdbc/DataType.hpp>
29 #include <com/sun/star/sdbc/KeyRule.hpp>
30 #include <com/sun/star/sdbc/IndexType.hpp>
31 #include <comphelper/property.hxx>
32 #include <com/sun/star/lang/DisposedException.hpp>
33 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
34 #include <com/sun/star/sdbc/ResultSetType.hpp>
35 #include <com/sun/star/sdbc/FetchDirection.hpp>
36 #include <cppuhelper/typeprovider.hxx>
37 #include <comphelper/sequence.hxx>
38 #include <com/sun/star/beans/PropertyAttribute.hpp>
39 #include <comphelper/seqstream.hxx>
40 #include "connectivity/dbexception.hxx"
41 #include "connectivity/dbtools.hxx"
42 #include <comphelper/types.hxx>
43 
44 using namespace ::comphelper;
45 
46 
47 #include <oledb.h>
48 
49 #define CHECK_RETURN(x)													\
50 	if(!SUCCEEDED(x))																\
51 		ADOS::ThrowException(*m_pStmt->m_pConnection->getConnection(),*this);
52 
53 using namespace connectivity::ado;
54 using namespace com::sun::star::uno;
55 using namespace com::sun::star::lang;
56 using namespace com::sun::star::beans;
57 using namespace com::sun::star::sdbc;
58 
59 //------------------------------------------------------------------------------
60 //	IMPLEMENT_SERVICE_INFO(OResultSet,"com.sun.star.sdbcx.AResultSet","com.sun.star.sdbc.ResultSet");
getImplementationName()61 ::rtl::OUString SAL_CALL OResultSet::getImplementationName(  ) throw (::com::sun::star::uno::RuntimeException)	\
62 {
63 	return ::rtl::OUString::createFromAscii("com.sun.star.sdbcx.ado.ResultSet");
64 }
65 // -------------------------------------------------------------------------
getSupportedServiceNames()66 ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL OResultSet::getSupportedServiceNames(  ) throw(::com::sun::star::uno::RuntimeException)
67 {
68 	::com::sun::star::uno::Sequence< ::rtl::OUString > aSupported(2);
69 	aSupported[0] = ::rtl::OUString::createFromAscii("com.sun.star.sdbc.ResultSet");
70 	aSupported[1] = ::rtl::OUString::createFromAscii("com.sun.star.sdbcx.ResultSet");
71 	return aSupported;
72 }
73 // -------------------------------------------------------------------------
supportsService(const::rtl::OUString & _rServiceName)74 sal_Bool SAL_CALL OResultSet::supportsService( const ::rtl::OUString& _rServiceName ) throw(::com::sun::star::uno::RuntimeException)
75 {
76 	Sequence< ::rtl::OUString > aSupported(getSupportedServiceNames());
77 	const ::rtl::OUString* pSupported = aSupported.getConstArray();
78 	const ::rtl::OUString* pEnd = pSupported + aSupported.getLength();
79 	for (;pSupported != pEnd && !pSupported->equals(_rServiceName); ++pSupported)
80 		;
81 
82 	return pSupported != pEnd;
83 }
84 // -------------------------------------------------------------------------
OResultSet(ADORecordset * _pRecordSet,OStatement_Base * pStmt)85 OResultSet::OResultSet(ADORecordset* _pRecordSet,OStatement_Base* pStmt) :	OResultSet_BASE(m_aMutex)
86 						,OPropertySetHelper(OResultSet_BASE::rBHelper)
87 						,m_xStatement(*pStmt)
88 						,m_pStmt(pStmt)
89 						,m_nRowPos(0)
90 						,m_xMetaData(NULL)
91 						,m_pRecordSet(_pRecordSet)
92 						,m_bEOF(sal_False)
93 {
94 }
95 // -------------------------------------------------------------------------
OResultSet(ADORecordset * _pRecordSet)96 OResultSet::OResultSet(ADORecordset* _pRecordSet) :	OResultSet_BASE(m_aMutex)
97 						,OPropertySetHelper(OResultSet_BASE::rBHelper)
98 						,m_xStatement(NULL)
99 						,m_xMetaData(NULL)
100 						,m_pRecordSet(_pRecordSet)
101 						,m_bEOF(sal_False)
102 {
103 }
104 // -----------------------------------------------------------------------------
construct()105 void OResultSet::construct()
106 {
107 	osl_incrementInterlockedCount( &m_refCount );
108 	if (!m_pRecordSet)
109 	{
110 		OSL_ENSURE( sal_False, "OResultSet::construct: no RecordSet!" );
111 		Reference< XInterface > xInt( *this );
112 		osl_decrementInterlockedCount( &m_refCount );
113 		::dbtools::throwFunctionSequenceException( xInt );
114 	}
115 	m_pRecordSet->AddRef();
116 	VARIANT_BOOL bIsAtBOF;
117 	CHECK_RETURN(m_pRecordSet->get_BOF(&bIsAtBOF))
118 	m_bOnFirstAfterOpen = bIsAtBOF != VARIANT_TRUE;
119 	osl_decrementInterlockedCount( &m_refCount );
120 }
121 // -------------------------------------------------------------------------
~OResultSet()122 OResultSet::~OResultSet()
123 {
124 	if(m_pRecordSet)
125 		m_pRecordSet->Release();
126 }
127 // -------------------------------------------------------------------------
disposing(void)128 void OResultSet::disposing(void)
129 {
130 	OPropertySetHelper::disposing();
131 
132 	::osl::MutexGuard aGuard(m_aMutex);
133 	if(m_pRecordSet)
134 		m_pRecordSet->Close();
135 m_xStatement.clear();
136 m_xMetaData.clear();
137 }
138 // -------------------------------------------------------------------------
queryInterface(const Type & rType)139 Any SAL_CALL OResultSet::queryInterface( const Type & rType ) throw(RuntimeException)
140 {
141 	Any aRet = OPropertySetHelper::queryInterface(rType);
142 	return aRet.hasValue() ? aRet : OResultSet_BASE::queryInterface(rType);
143 }
144 // -------------------------------------------------------------------------
getTypes()145 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL OResultSet::getTypes(  ) throw(::com::sun::star::uno::RuntimeException)
146 {
147 	::cppu::OTypeCollection aTypes(	::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XMultiPropertySet > *)0 ),
148 									::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XFastPropertySet > *)0 ),
149 									::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > *)0 ));
150 
151 	return ::comphelper::concatSequences(aTypes.getTypes(),OResultSet_BASE::getTypes());
152 }
153 
154 // -------------------------------------------------------------------------
155 
findColumn(const::rtl::OUString & columnName)156 sal_Int32 SAL_CALL OResultSet::findColumn( const ::rtl::OUString& columnName ) throw(SQLException, RuntimeException)
157 {
158 	::osl::MutexGuard aGuard( m_aMutex );
159 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
160 
161 
162 	Reference< XResultSetMetaData > xMeta = getMetaData();
163 	sal_Int32 nLen = xMeta->getColumnCount();
164 	sal_Int32 i = 1;
165 	for(;i<=nLen;++i)
166 		if(xMeta->isCaseSensitive(i) ? columnName == xMeta->getColumnName(i) :
167 			columnName.equalsIgnoreAsciiCase(xMeta->getColumnName(i)))
168 			break;
169 	return i;
170 }
171 #define BLOCK_SIZE 256
172 // -------------------------------------------------------------------------
getBinaryStream(sal_Int32 columnIndex)173 Reference< ::com::sun::star::io::XInputStream > SAL_CALL OResultSet::getBinaryStream( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
174 {
175 	::osl::MutexGuard aGuard( m_aMutex );
176 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
177 
178 	WpADOField aField = ADOS::getField(m_pRecordSet,columnIndex);
179 
180 	if((aField.GetAttributes() & adFldLong) == adFldLong)
181 	{
182 		//Copy the data only upto the Actual Size of Field.
183 		sal_Int32 nSize = aField.GetActualSize();
184 		Sequence<sal_Int8> aData(nSize);
185 		long index = 0;
186 		while(index < nSize)
187 		{
188 			m_aValue = aField.GetChunk(BLOCK_SIZE);
189 			if(m_aValue.isNull())
190 				break;
191 			UCHAR chData;
192 			for(long index2 = 0;index2 < BLOCK_SIZE;++index2)
193 			{
194 				HRESULT hr = ::SafeArrayGetElement(m_aValue.parray,&index2,&chData);
195 				if(SUCCEEDED(hr))
196 				{
197 					//Take BYTE by BYTE and advance Memory Location
198 					aData.getArray()[index++] = chData;
199 				}
200 				else
201 					break;
202 			}
203 		}
204 
205 		return new ::comphelper::SequenceInputStream(aData);
206 	}
207 	// else we ask for a bytesequence
208 	aField.get_Value(m_aValue);
209 
210 	return m_aValue.isNull() ? NULL : new ::comphelper::SequenceInputStream(m_aValue);
211 }
212 // -------------------------------------------------------------------------
getCharacterStream(sal_Int32)213 Reference< ::com::sun::star::io::XInputStream > SAL_CALL OResultSet::getCharacterStream( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
214 {
215     ::dbtools::throwFeatureNotImplementedException( "XRow::getCharacterStream", *this );
216 	return NULL;
217 }
218 // -----------------------------------------------------------------------------
getValue(sal_Int32 columnIndex)219 OLEVariant OResultSet::getValue(sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
220 {
221 	::osl::MutexGuard aGuard( m_aMutex );
222 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
223 
224 	WpADOField aField = ADOS::getField(m_pRecordSet,columnIndex);
225 	aField.get_Value(m_aValue);
226 	return m_aValue;
227 }
228 // -------------------------------------------------------------------------
getBoolean(sal_Int32 columnIndex)229 sal_Bool SAL_CALL OResultSet::getBoolean( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
230 {
231 	return getValue(columnIndex);
232 }
233 // -------------------------------------------------------------------------
234 
getByte(sal_Int32 columnIndex)235 sal_Int8 SAL_CALL OResultSet::getByte( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
236 {
237 	return getValue(columnIndex);
238 }
239 // -------------------------------------------------------------------------
240 
getBytes(sal_Int32 columnIndex)241 Sequence< sal_Int8 > SAL_CALL OResultSet::getBytes( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
242 {
243 	return getValue(columnIndex);
244 }
245 // -------------------------------------------------------------------------
246 
getDate(sal_Int32 columnIndex)247 ::com::sun::star::util::Date SAL_CALL OResultSet::getDate( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
248 {
249 	return getValue(columnIndex);
250 }
251 // -------------------------------------------------------------------------
252 
getDouble(sal_Int32 columnIndex)253 double SAL_CALL OResultSet::getDouble( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
254 {
255 	return getValue(columnIndex);
256 }
257 // -------------------------------------------------------------------------
258 
getFloat(sal_Int32 columnIndex)259 float SAL_CALL OResultSet::getFloat( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
260 {
261 	return getValue(columnIndex);
262 }
263 // -------------------------------------------------------------------------
264 
getInt(sal_Int32 columnIndex)265 sal_Int32 SAL_CALL OResultSet::getInt( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
266 {
267 	return getValue(columnIndex);
268 }
269 // -------------------------------------------------------------------------
270 
getRow()271 sal_Int32 SAL_CALL OResultSet::getRow(  ) throw(SQLException, RuntimeException)
272 {
273 	::osl::MutexGuard aGuard( m_aMutex );
274 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
275 
276 
277 	PositionEnum aPos;
278 	m_pRecordSet->get_AbsolutePosition(&aPos);
279 	return  (aPos > 0) ? aPos : m_nRowPos;
280 	// return the rowcount from driver if the driver doesn't support this return our count
281 }
282 // -------------------------------------------------------------------------
283 
getLong(sal_Int32)284 sal_Int64 SAL_CALL OResultSet::getLong( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
285 {
286     ::dbtools::throwFeatureNotImplementedException( "XRow::getLong", *this );
287 	return sal_Int64(0);
288 }
289 // -------------------------------------------------------------------------
290 
getMetaData()291 Reference< XResultSetMetaData > SAL_CALL OResultSet::getMetaData(  ) throw(SQLException, RuntimeException)
292 {
293 	::osl::MutexGuard aGuard( m_aMutex );
294 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
295 
296 
297 	if(!m_xMetaData.is())
298 		m_xMetaData = new OResultSetMetaData(m_pRecordSet);
299 	return m_xMetaData;
300 }
301 // -------------------------------------------------------------------------
getArray(sal_Int32)302 Reference< XArray > SAL_CALL OResultSet::getArray( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
303 {
304     ::dbtools::throwFeatureNotImplementedException( "XRow::getArray", *this );
305 	return NULL;
306 }
307 
308 // -------------------------------------------------------------------------
309 
getClob(sal_Int32)310 Reference< XClob > SAL_CALL OResultSet::getClob( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
311 {
312     ::dbtools::throwFeatureNotImplementedException( "XRow::getClob", *this );
313 	return NULL;
314 }
315 // -------------------------------------------------------------------------
getBlob(sal_Int32)316 Reference< XBlob > SAL_CALL OResultSet::getBlob( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
317 {
318     ::dbtools::throwFeatureNotImplementedException( "XRow::getBlob", *this );
319 	return NULL;
320 }
321 // -------------------------------------------------------------------------
322 
getRef(sal_Int32)323 Reference< XRef > SAL_CALL OResultSet::getRef( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
324 {
325     ::dbtools::throwFeatureNotImplementedException( "XRow::getRef", *this );
326 	return NULL;
327 }
328 // -------------------------------------------------------------------------
329 
getObject(sal_Int32 columnIndex,const Reference<::com::sun::star::container::XNameAccess> &)330 Any SAL_CALL OResultSet::getObject( sal_Int32 columnIndex, const Reference< ::com::sun::star::container::XNameAccess >& /*typeMap*/ ) throw(SQLException, RuntimeException)
331 {
332     return getValue(columnIndex).makeAny();
333 }
334 // -------------------------------------------------------------------------
335 
getShort(sal_Int32 columnIndex)336 sal_Int16 SAL_CALL OResultSet::getShort( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
337 {
338 	return getValue(columnIndex);
339 }
340 // -------------------------------------------------------------------------
341 
getString(sal_Int32 columnIndex)342 ::rtl::OUString SAL_CALL OResultSet::getString( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
343 {
344 	return getValue(columnIndex);
345 }
346 
347 // -------------------------------------------------------------------------
348 
349 
getTime(sal_Int32 columnIndex)350 ::com::sun::star::util::Time SAL_CALL OResultSet::getTime( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
351 {
352 	return getValue(columnIndex);
353 }
354 // -------------------------------------------------------------------------
355 
356 
getTimestamp(sal_Int32 columnIndex)357 ::com::sun::star::util::DateTime SAL_CALL OResultSet::getTimestamp( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
358 {
359 	return getValue(columnIndex);
360 }
361 // -------------------------------------------------------------------------
362 
isAfterLast()363 sal_Bool SAL_CALL OResultSet::isAfterLast(  ) throw(SQLException, RuntimeException)
364 {
365 	::osl::MutexGuard aGuard( m_aMutex );
366 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
367 
368 
369 	VARIANT_BOOL bIsAtEOF;
370 	CHECK_RETURN(m_pRecordSet->get_EOF(&bIsAtEOF))
371 	return bIsAtEOF == VARIANT_TRUE;
372 }
373 // -------------------------------------------------------------------------
isFirst()374 sal_Bool SAL_CALL OResultSet::isFirst(  ) throw(SQLException, RuntimeException)
375 {
376 	::osl::MutexGuard aGuard( m_aMutex );
377 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
378 
379 
380 	return m_nRowPos == 1;
381 }
382 // -------------------------------------------------------------------------
isLast()383 sal_Bool SAL_CALL OResultSet::isLast(  ) throw(SQLException, RuntimeException)
384 {
385 	::osl::MutexGuard aGuard( m_aMutex );
386 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
387 
388 
389 	return sal_True;
390 }
391 // -------------------------------------------------------------------------
beforeFirst()392 void SAL_CALL OResultSet::beforeFirst(  ) throw(SQLException, RuntimeException)
393 {
394 	::osl::MutexGuard aGuard( m_aMutex );
395 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
396 
397 
398 	if(first())
399 		m_bOnFirstAfterOpen = !previous();
400 }
401 // -------------------------------------------------------------------------
afterLast()402 void SAL_CALL OResultSet::afterLast(  ) throw(SQLException, RuntimeException)
403 {
404 	::osl::MutexGuard aGuard( m_aMutex );
405 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
406 
407 
408 	if(last())
409 		next();
410 	m_bEOF = sal_True;
411 }
412 // -------------------------------------------------------------------------
413 
close()414 void SAL_CALL OResultSet::close(  ) throw(SQLException, RuntimeException)
415 {
416 	{
417 		::osl::MutexGuard aGuard( m_aMutex );
418 		checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
419 
420 	}
421 	dispose();
422 }
423 // -------------------------------------------------------------------------
424 
first()425 sal_Bool SAL_CALL OResultSet::first(  ) throw(SQLException, RuntimeException)
426 {
427 	::osl::MutexGuard aGuard( m_aMutex );
428 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
429 
430 
431 	if(SUCCEEDED(m_pRecordSet->MoveFirst()))
432 	{
433 		m_nRowPos = 1;
434 		m_bOnFirstAfterOpen = sal_False;
435 		return sal_True;
436 	}
437 	return sal_False;
438 }
439 // -------------------------------------------------------------------------
440 
last()441 sal_Bool SAL_CALL OResultSet::last(  ) throw(SQLException, RuntimeException)
442 {
443 	::osl::MutexGuard aGuard( m_aMutex );
444 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
445 
446 
447 	sal_Bool bRet = SUCCEEDED(m_pRecordSet->MoveLast());
448 	if(bRet)
449 	{
450 		m_pRecordSet->get_RecordCount(&m_nRowPos);
451 		m_bOnFirstAfterOpen = sal_False;
452 	}
453 	return bRet;
454 }
455 // -------------------------------------------------------------------------
absolute(sal_Int32 row)456 sal_Bool SAL_CALL OResultSet::absolute( sal_Int32 row ) throw(SQLException, RuntimeException)
457 {
458 	::osl::MutexGuard aGuard( m_aMutex );
459 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
460 
461 
462 	if(!row)				 // absolute with zero not allowed
463 		::dbtools::throwFunctionSequenceException(*this);
464 
465 	sal_Bool bCheck = sal_True;
466 	if(row < 0)
467 	{
468         bCheck = SUCCEEDED(m_pRecordSet->MoveLast());
469 		if ( bCheck )
470 		{
471 			while(++row < 0 && bCheck)
472 				bCheck = SUCCEEDED(m_pRecordSet->MovePrevious());
473 		}
474 	}
475 	else
476 	{
477 		first();
478 		OLEVariant aEmpty;
479 		aEmpty.setNoArg();
480 		bCheck = SUCCEEDED(m_pRecordSet->Move(row-1,aEmpty)); // move to row -1 because we stand already on the first
481 		if(bCheck)
482 			m_nRowPos = row;
483 	}
484 	if(bCheck)
485 		m_bOnFirstAfterOpen = sal_False;
486 	return bCheck;
487 }
488 // -------------------------------------------------------------------------
relative(sal_Int32 row)489 sal_Bool SAL_CALL OResultSet::relative( sal_Int32 row ) throw(SQLException, RuntimeException)
490 {
491 	::osl::MutexGuard aGuard( m_aMutex );
492 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
493 
494 
495 	OLEVariant aEmpty;
496 	aEmpty.setNoArg();
497 	sal_Int32 nNewPos = row;
498 	if ( m_bOnFirstAfterOpen && nNewPos > 0 )
499 		--nNewPos;
500 	sal_Bool bRet = SUCCEEDED(m_pRecordSet->Move(row,aEmpty));
501 	if(bRet)
502 	{
503 		m_nRowPos += row;
504 		m_bOnFirstAfterOpen = sal_False;
505 	}
506 	return bRet;
507 }
508 // -------------------------------------------------------------------------
previous()509 sal_Bool SAL_CALL OResultSet::previous(  ) throw(SQLException, RuntimeException)
510 {
511 	::osl::MutexGuard aGuard( m_aMutex );
512 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
513 
514 	sal_Bool bRet = SUCCEEDED(m_pRecordSet->MovePrevious());
515 	if(bRet)
516 	{
517 		--m_nRowPos;
518 		m_bOnFirstAfterOpen = sal_False;
519 	}
520 	return bRet;
521 }
522 // -------------------------------------------------------------------------
getStatement()523 Reference< XInterface > SAL_CALL OResultSet::getStatement(  ) throw(SQLException, RuntimeException)
524 {
525 	::osl::MutexGuard aGuard( m_aMutex );
526 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
527 	return m_xStatement;
528 }
529 // -------------------------------------------------------------------------
530 
rowDeleted()531 sal_Bool SAL_CALL OResultSet::rowDeleted(  ) throw(SQLException, RuntimeException)
532 {
533 	::osl::MutexGuard aGuard( m_aMutex );
534 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
535 
536 
537 	RecordStatusEnum eRec;
538 	m_pRecordSet->get_Status((sal_Int32*)&eRec);
539 	sal_Bool  bRet = (eRec & adRecDeleted) == adRecDeleted;
540 	if(bRet)
541 		--m_nRowPos;
542 	return bRet;
543 }
544 // -------------------------------------------------------------------------
rowInserted()545 sal_Bool SAL_CALL OResultSet::rowInserted(  ) throw(SQLException, RuntimeException)
546 {	::osl::MutexGuard aGuard( m_aMutex );
547 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
548 
549 
550 	RecordStatusEnum eRec;
551 	m_pRecordSet->get_Status((sal_Int32*)&eRec);
552 	sal_Bool  bRet = (eRec & adRecNew) == adRecNew;
553 	if(bRet)
554 		++m_nRowPos;
555 	return bRet;
556 }
557 // -------------------------------------------------------------------------
rowUpdated()558 sal_Bool SAL_CALL OResultSet::rowUpdated(  ) throw(SQLException, RuntimeException)
559 {
560 	::osl::MutexGuard aGuard( m_aMutex );
561 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
562 
563 
564 	RecordStatusEnum eRec;
565 	m_pRecordSet->get_Status((sal_Int32*)&eRec);
566 	return (eRec & adRecModified) == adRecModified;
567 }
568 // -------------------------------------------------------------------------
569 
isBeforeFirst()570 sal_Bool SAL_CALL OResultSet::isBeforeFirst(  ) throw(SQLException, RuntimeException)
571 {
572 	::osl::MutexGuard aGuard( m_aMutex );
573 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
574 
575 
576 	OSL_ENSURE(!m_nRowPos,"OResultSet::isBeforeFirst: Error in setting m_nRowPos!");
577 	VARIANT_BOOL bIsAtBOF = VARIANT_TRUE;
578 	if(!m_bOnFirstAfterOpen)
579 	{
580 		OSL_ENSURE(!m_nRowPos,"OResultSet::isBeforeFirst: Error in setting m_nRowPos!");
581 		m_pRecordSet->get_BOF(&bIsAtBOF);
582 	}
583 	return bIsAtBOF == VARIANT_TRUE;
584 }
585 // -------------------------------------------------------------------------
586 
next()587 sal_Bool SAL_CALL OResultSet::next(  ) throw(SQLException, RuntimeException)
588 {
589 	::osl::MutexGuard aGuard( m_aMutex );
590 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
591 
592 
593 	sal_Bool bRet = sal_True;
594 	if(m_bOnFirstAfterOpen)
595 	{
596 		m_bOnFirstAfterOpen = sal_False;
597 		++m_nRowPos;
598 	}
599 	else
600 	{
601 		bRet = SUCCEEDED(m_pRecordSet->MoveNext());
602 
603 		if(bRet)
604 		{
605 			VARIANT_BOOL bIsAtEOF;
606 			CHECK_RETURN(m_pRecordSet->get_EOF(&bIsAtEOF))
607 			bRet = bIsAtEOF != VARIANT_TRUE;
608 			++m_nRowPos;
609 		}
610 		else
611 			ADOS::ThrowException(*m_pStmt->m_pConnection->getConnection(),*this);
612 	}
613 
614 	return bRet;
615 }
616 // -------------------------------------------------------------------------
617 
wasNull()618 sal_Bool SAL_CALL OResultSet::wasNull(  ) throw(SQLException, RuntimeException)
619 {
620 	::osl::MutexGuard aGuard( m_aMutex );
621 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
622 
623 
624 	return m_aValue.isNull();
625 }
626 // -------------------------------------------------------------------------
627 
cancel()628 void SAL_CALL OResultSet::cancel(  ) throw(RuntimeException)
629 {
630 	::osl::MutexGuard aGuard( m_aMutex );
631 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
632 
633 
634 	m_pRecordSet->Cancel();
635 }
636 // -------------------------------------------------------------------------
clearWarnings()637 void SAL_CALL OResultSet::clearWarnings(  ) throw(SQLException, RuntimeException)
638 {
639 }
640 // -------------------------------------------------------------------------
getWarnings()641 Any SAL_CALL OResultSet::getWarnings(  ) throw(SQLException, RuntimeException)
642 {
643 	return Any();
644 }
645 // -------------------------------------------------------------------------
insertRow()646 void SAL_CALL OResultSet::insertRow(  ) throw(SQLException, RuntimeException)
647 {
648 	::osl::MutexGuard aGuard( m_aMutex );
649 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
650 
651 
652 	OLEVariant aEmpty;
653 	aEmpty.setNoArg();
654 	m_pRecordSet->AddNew(aEmpty,aEmpty);
655 }
656 // -------------------------------------------------------------------------
updateRow()657 void SAL_CALL OResultSet::updateRow(  ) throw(SQLException, RuntimeException)
658 {
659 	::osl::MutexGuard aGuard( m_aMutex );
660 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
661 
662 
663 	OLEVariant aEmpty;
664 	aEmpty.setNoArg();
665 	m_pRecordSet->Update(aEmpty,aEmpty);
666 }
667 // -------------------------------------------------------------------------
deleteRow()668 void SAL_CALL OResultSet::deleteRow(  ) throw(SQLException, RuntimeException)
669 {
670 	::osl::MutexGuard aGuard( m_aMutex );
671 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
672 
673 
674 	m_pRecordSet->Delete(adAffectCurrent);
675 	m_pRecordSet->UpdateBatch(adAffectCurrent);
676 }
677 // -------------------------------------------------------------------------
678 
cancelRowUpdates()679 void SAL_CALL OResultSet::cancelRowUpdates(  ) throw(SQLException, RuntimeException)
680 {
681 	::osl::MutexGuard aGuard( m_aMutex );
682 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
683 
684 
685 	m_pRecordSet->CancelUpdate();
686 }
687 // -------------------------------------------------------------------------
688 
moveToInsertRow()689 void SAL_CALL OResultSet::moveToInsertRow(  ) throw(SQLException, RuntimeException)
690 {
691  //   ::osl::MutexGuard aGuard( m_aMutex );
692 	//checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
693  //   if ( getResultSetConcurrency() == ResultSetConcurrency::READ_ONLY )
694  //       throw SQLException();
695 }
696 // -------------------------------------------------------------------------
697 
moveToCurrentRow()698 void SAL_CALL OResultSet::moveToCurrentRow(  ) throw(SQLException, RuntimeException)
699 {
700 }
701 // -----------------------------------------------------------------------------
updateValue(sal_Int32 columnIndex,const OLEVariant & x)702 void OResultSet::updateValue(sal_Int32 columnIndex,const OLEVariant& x)
703 {
704 	::osl::MutexGuard aGuard( m_aMutex );
705 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
706 
707 	WpADOField aField = ADOS::getField(m_pRecordSet,columnIndex);
708 	aField.PutValue(x);
709 }
710 // -------------------------------------------------------------------------
updateNull(sal_Int32 columnIndex)711 void SAL_CALL OResultSet::updateNull( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
712 {
713 	OLEVariant x;
714 	x.setNull();
715 	updateValue(columnIndex,x);
716 }
717 // -------------------------------------------------------------------------
718 
updateBoolean(sal_Int32 columnIndex,sal_Bool x)719 void SAL_CALL OResultSet::updateBoolean( sal_Int32 columnIndex, sal_Bool x ) throw(SQLException, RuntimeException)
720 {
721 	updateValue(columnIndex,x);
722 }
723 // -------------------------------------------------------------------------
updateByte(sal_Int32 columnIndex,sal_Int8 x)724 void SAL_CALL OResultSet::updateByte( sal_Int32 columnIndex, sal_Int8 x ) throw(SQLException, RuntimeException)
725 {
726 	updateValue(columnIndex,x);
727 }
728 // -------------------------------------------------------------------------
729 
updateShort(sal_Int32 columnIndex,sal_Int16 x)730 void SAL_CALL OResultSet::updateShort( sal_Int32 columnIndex, sal_Int16 x ) throw(SQLException, RuntimeException)
731 {
732 	updateValue(columnIndex,x);
733 }
734 // -------------------------------------------------------------------------
updateInt(sal_Int32 columnIndex,sal_Int32 x)735 void SAL_CALL OResultSet::updateInt( sal_Int32 columnIndex, sal_Int32 x ) throw(SQLException, RuntimeException)
736 {
737 	updateValue(columnIndex,x);
738 }
739 // -------------------------------------------------------------------------
updateLong(sal_Int32 columnIndex,sal_Int64 x)740 void SAL_CALL OResultSet::updateLong( sal_Int32 columnIndex, sal_Int64 x ) throw(SQLException, RuntimeException)
741 {
742 	updateValue(columnIndex,x);
743 }
744 // -----------------------------------------------------------------------
updateFloat(sal_Int32 columnIndex,float x)745 void SAL_CALL OResultSet::updateFloat( sal_Int32 columnIndex, float x ) throw(SQLException, RuntimeException)
746 {
747 	updateValue(columnIndex,x);
748 }
749 // -------------------------------------------------------------------------
750 
updateDouble(sal_Int32 columnIndex,double x)751 void SAL_CALL OResultSet::updateDouble( sal_Int32 columnIndex, double x ) throw(SQLException, RuntimeException)
752 {
753 	updateValue(columnIndex,x);
754 }
755 // -------------------------------------------------------------------------
updateString(sal_Int32 columnIndex,const::rtl::OUString & x)756 void SAL_CALL OResultSet::updateString( sal_Int32 columnIndex, const ::rtl::OUString& x ) throw(SQLException, RuntimeException)
757 {
758 	updateValue(columnIndex,x);
759 }
760 // -------------------------------------------------------------------------
updateBytes(sal_Int32 columnIndex,const Sequence<sal_Int8> & x)761 void SAL_CALL OResultSet::updateBytes( sal_Int32 columnIndex, const Sequence< sal_Int8 >& x ) throw(SQLException, RuntimeException)
762 {
763 	updateValue(columnIndex,x);
764 }
765 // -------------------------------------------------------------------------
updateDate(sal_Int32 columnIndex,const::com::sun::star::util::Date & x)766 void SAL_CALL OResultSet::updateDate( sal_Int32 columnIndex, const ::com::sun::star::util::Date& x ) throw(SQLException, RuntimeException)
767 {
768 	updateValue(columnIndex,x);
769 }
770 // -------------------------------------------------------------------------
771 
updateTime(sal_Int32 columnIndex,const::com::sun::star::util::Time & x)772 void SAL_CALL OResultSet::updateTime( sal_Int32 columnIndex, const ::com::sun::star::util::Time& x ) throw(SQLException, RuntimeException)
773 {
774 	updateValue(columnIndex,x);
775 }
776 // -------------------------------------------------------------------------
777 
updateTimestamp(sal_Int32 columnIndex,const::com::sun::star::util::DateTime & x)778 void SAL_CALL OResultSet::updateTimestamp( sal_Int32 columnIndex, const ::com::sun::star::util::DateTime& x ) throw(SQLException, RuntimeException)
779 {
780 	updateValue(columnIndex,x);
781 }
782 // -------------------------------------------------------------------------
783 
updateBinaryStream(sal_Int32 columnIndex,const Reference<::com::sun::star::io::XInputStream> & x,sal_Int32 length)784 void SAL_CALL OResultSet::updateBinaryStream( sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
785 {
786     if(!x.is())
787 		::dbtools::throwFunctionSequenceException(*this);
788 
789 	Sequence<sal_Int8> aSeq;
790 	x->readBytes(aSeq,length);
791 	updateBytes(columnIndex,aSeq);
792 }
793 // -------------------------------------------------------------------------
updateCharacterStream(sal_Int32 columnIndex,const Reference<::com::sun::star::io::XInputStream> & x,sal_Int32 length)794 void SAL_CALL OResultSet::updateCharacterStream( sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
795 {
796     if(!x.is())
797 		::dbtools::throwFunctionSequenceException(*this);
798 
799 	Sequence<sal_Int8> aSeq;
800 	x->readBytes(aSeq,length);
801 	updateBytes(columnIndex,aSeq);
802 }
803 // -------------------------------------------------------------------------
refreshRow()804 void SAL_CALL OResultSet::refreshRow(  ) throw(SQLException, RuntimeException)
805 {
806 	::osl::MutexGuard aGuard( m_aMutex );
807 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
808 
809 
810 	m_pRecordSet->Resync(adAffectCurrent,adResyncAllValues);
811 }
812 // -------------------------------------------------------------------------
updateObject(sal_Int32 columnIndex,const Any & x)813 void SAL_CALL OResultSet::updateObject( sal_Int32 columnIndex, const Any& x ) throw(SQLException, RuntimeException)
814 {
815 	if (!::dbtools::implUpdateObject(this, columnIndex, x))
816 		throw SQLException();
817 }
818 // -------------------------------------------------------------------------
819 
updateNumericObject(sal_Int32 columnIndex,const Any & x,sal_Int32)820 void SAL_CALL OResultSet::updateNumericObject( sal_Int32 columnIndex, const Any& x, sal_Int32 /*scale*/ ) throw(SQLException, RuntimeException)
821 {
822 	if (!::dbtools::implUpdateObject(this, columnIndex, x))
823 		throw SQLException();
824 }
825 //------------------------------------------------------------------------------
826 // XRowLocate
getBookmark()827 Any SAL_CALL OResultSet::getBookmark(  ) throw(SQLException, RuntimeException)
828 {
829 	::osl::MutexGuard aGuard( m_aMutex );
830 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
831 
832 	if(m_nRowPos < (sal_Int32)m_aBookmarks.size()) // this bookmark was already fetched
833 		return makeAny(sal_Int32(m_nRowPos-1));
834 
835 	OLEVariant aVar;
836 	m_pRecordSet->get_Bookmark(&aVar);
837 	m_aBookmarks.push_back(aVar);
838 	return makeAny((sal_Int32)(m_aBookmarks.size()-1));
839 
840 }
841 //------------------------------------------------------------------------------
moveToBookmark(const Any & bookmark)842 sal_Bool SAL_CALL OResultSet::moveToBookmark( const Any& bookmark ) throw(SQLException, RuntimeException)
843 {
844 	::osl::MutexGuard aGuard( m_aMutex );
845 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
846 
847 
848 	sal_Int32 nPos;
849 	bookmark >>= nPos;
850 	OSL_ENSURE(nPos >= 0 && nPos < (sal_Int32)m_aBookmarks.size(),"Invalid Index for vector");
851 	if(nPos < 0 || nPos >= (sal_Int32)m_aBookmarks.size())
852 		::dbtools::throwFunctionSequenceException(*this);
853 
854 	return SUCCEEDED(m_pRecordSet->Move(0,m_aBookmarks[nPos]));
855 }
856 //------------------------------------------------------------------------------
moveRelativeToBookmark(const Any & bookmark,sal_Int32 rows)857 sal_Bool SAL_CALL OResultSet::moveRelativeToBookmark( const Any& bookmark, sal_Int32 rows ) throw(SQLException, RuntimeException)
858 {
859 	::osl::MutexGuard aGuard( m_aMutex );
860 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
861 
862 
863 	sal_Int32 nPos;
864 	bookmark >>= nPos;
865 	nPos += rows;
866 	OSL_ENSURE(nPos >= 0 && nPos < (sal_Int32)m_aBookmarks.size(),"Invalid Index for vector");
867 	if(nPos < 0 || nPos >= (sal_Int32)m_aBookmarks.size())
868 		::dbtools::throwFunctionSequenceException(*this);
869 	return SUCCEEDED(m_pRecordSet->Move(rows,m_aBookmarks[nPos]));
870 }
871 //------------------------------------------------------------------------------
compareBookmarks(const Any & first,const Any & second)872 sal_Int32 SAL_CALL OResultSet::compareBookmarks( const Any& first, const Any& second ) throw(SQLException, RuntimeException)
873 {
874 	::osl::MutexGuard aGuard( m_aMutex );
875 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
876 
877 	sal_Int32 nPos1;
878 	first >>= nPos1;
879 	sal_Int32 nPos2;
880 	second >>= nPos2;
881 	if(nPos1 == nPos2)	// they should be equal
882 		return sal_True;
883 
884 	OSL_ENSURE((nPos1 >= 0 && nPos1 < (sal_Int32)m_aBookmarks.size()) || (nPos1 >= 0 && nPos2 < (sal_Int32)m_aBookmarks.size()),"Invalid Index for vector");
885 
886 	CompareEnum eNum;
887 	m_pRecordSet->CompareBookmarks(m_aBookmarks[nPos1],m_aBookmarks[nPos2],&eNum);
888 	return ((sal_Int32)eNum) +1;
889 }
890 //------------------------------------------------------------------------------
hasOrderedBookmarks()891 sal_Bool SAL_CALL OResultSet::hasOrderedBookmarks(  ) throw(SQLException, RuntimeException)
892 {
893 	::osl::MutexGuard aGuard( m_aMutex );
894 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
895 
896 
897 	ADOProperties* pProps = NULL;
898 	m_pRecordSet->get_Properties(&pProps);
899 	WpADOProperties aProps;
900 	aProps.setWithOutAddRef(pProps);
901 	ADOS::ThrowException(*((OConnection*)m_pStmt->getConnection().get())->getConnection(),*this);
902 	OSL_ENSURE(aProps.IsValid(),"There are no properties at the connection");
903 
904 	WpADOProperty aProp(aProps.GetItem(::rtl::OUString::createFromAscii("Bookmarks Ordered")));
905 	OLEVariant aVar;
906 	if(aProp.IsValid())
907 		aVar = aProp.GetValue();
908 	else
909 		ADOS::ThrowException(*((OConnection*)m_pStmt->getConnection().get())->getConnection(),*this);
910 
911 	sal_Bool bValue(sal_False);
912 	if(!aVar.isNull() && !aVar.isEmpty())
913 		bValue = aVar;
914 	return bValue;
915 }
916 //------------------------------------------------------------------------------
hashBookmark(const Any & bookmark)917 sal_Int32 SAL_CALL OResultSet::hashBookmark( const Any& bookmark ) throw(SQLException, RuntimeException)
918 {
919 	::osl::MutexGuard aGuard( m_aMutex );
920 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
921 
922 
923 	sal_Int32 nPos;
924 	bookmark >>= nPos;
925 	return nPos;
926 }
927 //------------------------------------------------------------------------------
928 // XDeleteRows
deleteRows(const Sequence<Any> & rows)929 Sequence< sal_Int32 > SAL_CALL OResultSet::deleteRows( const Sequence< Any >& rows ) throw(SQLException, RuntimeException)
930 {
931 	::osl::MutexGuard aGuard( m_aMutex );
932 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
933 
934 
935 	OLEVariant aVar;
936 	sal_Int32 nPos;
937 
938 	// Create SafeArray Bounds and initialize the array
939 	SAFEARRAYBOUND rgsabound[1];
940 	rgsabound[0].lLbound   = 0;
941 	rgsabound[0].cElements = rows.getLength();
942 	SAFEARRAY *psa         = SafeArrayCreate( VT_VARIANT, 1, rgsabound );
943 
944 	const Any* pBegin = rows.getConstArray();
945 	const Any* pEnd = pBegin + rows.getLength();
946 	for(sal_Int32 i=0;pBegin != pEnd ;++pBegin,++i)
947 	{
948 		*pBegin >>= nPos;
949 		SafeArrayPutElement(psa,&i,&m_aBookmarks[nPos]);
950 	}
951 
952 	// Initialize and fill the SafeArray
953 	OLEVariant vsa;
954 	vsa.setArray(psa,VT_VARIANT);
955 
956 	m_pRecordSet->put_Filter(vsa);
957 	m_pRecordSet->Delete(adAffectGroup);
958 	m_pRecordSet->UpdateBatch(adAffectGroup);
959 
960 	Sequence< sal_Int32 > aSeq(rows.getLength());
961 	if(first())
962 	{
963 		sal_Int32* pSeq = aSeq.getArray();
964 		sal_Int32 i=0;
965 		do
966 		{
967 			OSL_ENSURE(i<aSeq.getLength(),"Index greater than length of sequence");
968 			m_pRecordSet->get_Status(&pSeq[i]);
969 			if(pSeq[i++] == adRecDeleted)
970 				--m_nRowPos;
971 		}
972 		while(next());
973 	}
974 	return aSeq;
975 }
976 //------------------------------------------------------------------------------
getResultSetConcurrency() const977 sal_Int32 OResultSet::getResultSetConcurrency() const
978 	throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
979 {
980 	sal_Int32 nValue=ResultSetConcurrency::READ_ONLY;
981 	LockTypeEnum eRet;
982 	if(!SUCCEEDED(m_pRecordSet->get_LockType(&eRet)))
983 	{
984 		switch(eRet)
985 		{
986 			case adLockReadOnly:
987 				nValue = ResultSetConcurrency::READ_ONLY;
988 				break;
989 			default:
990 				nValue = ResultSetConcurrency::UPDATABLE;
991 				break;
992 		}
993 	}
994 	return nValue;
995 }
996 //------------------------------------------------------------------------------
getResultSetType() const997 sal_Int32 OResultSet::getResultSetType() const
998 	throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
999 {
1000 	sal_Int32 nValue=0;
1001 	CursorTypeEnum eRet;
1002 	if(!SUCCEEDED(m_pRecordSet->get_CursorType(&eRet)))
1003 	{
1004 		switch(eRet)
1005 		{
1006 			case adOpenUnspecified:
1007 			case adOpenForwardOnly:
1008 				nValue = ResultSetType::FORWARD_ONLY;
1009 				break;
1010 			case adOpenStatic:
1011 			case adOpenKeyset:
1012 				nValue = ResultSetType::SCROLL_INSENSITIVE;
1013 				break;
1014 			case adOpenDynamic:
1015 				nValue = ResultSetType::SCROLL_SENSITIVE;
1016 				break;
1017 		}
1018 	}
1019 	return nValue;
1020 }
1021 //------------------------------------------------------------------------------
getFetchDirection() const1022 sal_Int32 OResultSet::getFetchDirection() const
1023 	throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1024 {
1025 	return FetchDirection::FORWARD;
1026 }
1027 //------------------------------------------------------------------------------
getFetchSize() const1028 sal_Int32 OResultSet::getFetchSize() const
1029 	throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1030 {
1031 	sal_Int32 nValue=-1;
1032 	m_pRecordSet->get_CacheSize(&nValue);
1033 	return nValue;
1034 }
1035 //------------------------------------------------------------------------------
getCursorName() const1036 ::rtl::OUString OResultSet::getCursorName() const
1037 	throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1038 {
1039 	return ::rtl::OUString();
1040 }
1041 
1042 //------------------------------------------------------------------------------
setFetchDirection(sal_Int32)1043 void OResultSet::setFetchDirection(sal_Int32 /*_par0*/)
1044 	throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1045 {
1046     ::dbtools::throwFeatureNotImplementedException( "ResultSet::FetchDirection", *this );
1047 }
1048 //------------------------------------------------------------------------------
setFetchSize(sal_Int32 _par0)1049 void OResultSet::setFetchSize(sal_Int32 _par0)
1050 	throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1051 {
1052 	m_pRecordSet->put_CacheSize(_par0);
1053 }
1054 // -------------------------------------------------------------------------
createArrayHelper() const1055 ::cppu::IPropertyArrayHelper* OResultSet::createArrayHelper( ) const
1056 {
1057 	Sequence< com::sun::star::beans::Property > aProps(5);
1058 	com::sun::star::beans::Property* pProperties = aProps.getArray();
1059 	sal_Int32 nPos = 0;
1060 
1061 	//	DECL_PROP1IMPL(CURSORNAME,			::rtl::OUString) PropertyAttribute::READONLY);
1062 	DECL_PROP0(FETCHDIRECTION,			sal_Int32);
1063 	DECL_PROP0(FETCHSIZE,				sal_Int32);
1064 	DECL_BOOL_PROP1IMPL(ISBOOKMARKABLE) PropertyAttribute::READONLY);
1065 	DECL_PROP1IMPL(RESULTSETCONCURRENCY,sal_Int32) PropertyAttribute::READONLY);
1066 	DECL_PROP1IMPL(RESULTSETTYPE,		sal_Int32) PropertyAttribute::READONLY);
1067 
1068 	return new ::cppu::OPropertyArrayHelper(aProps);
1069 }
1070 // -------------------------------------------------------------------------
getInfoHelper()1071 ::cppu::IPropertyArrayHelper & OResultSet::getInfoHelper()
1072 {
1073 	return *const_cast<OResultSet*>(this)->getArrayHelper();
1074 }
1075 // -------------------------------------------------------------------------
convertFastPropertyValue(Any & rConvertedValue,Any & rOldValue,sal_Int32 nHandle,const Any & rValue)1076 sal_Bool OResultSet::convertFastPropertyValue(
1077 							Any & rConvertedValue,
1078 							Any & rOldValue,
1079 							sal_Int32 nHandle,
1080 							const Any& rValue )
1081 								throw (::com::sun::star::lang::IllegalArgumentException)
1082 {
1083 	switch(nHandle)
1084 	{
1085 		case PROPERTY_ID_ISBOOKMARKABLE:
1086 		case PROPERTY_ID_CURSORNAME:
1087 		case PROPERTY_ID_RESULTSETCONCURRENCY:
1088 		case PROPERTY_ID_RESULTSETTYPE:
1089 			throw ::com::sun::star::lang::IllegalArgumentException();
1090 			break;
1091 		case PROPERTY_ID_FETCHDIRECTION:
1092 			return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchDirection());
1093 		case PROPERTY_ID_FETCHSIZE:
1094 			return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchSize());
1095 		default:
1096 			;
1097 	}
1098 	return sal_False;
1099 }
1100 // -------------------------------------------------------------------------
setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any & rValue)1101 void OResultSet::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue)throw (Exception)
1102 {
1103 	switch(nHandle)
1104 	{
1105 		case PROPERTY_ID_ISBOOKMARKABLE:
1106 		case PROPERTY_ID_CURSORNAME:
1107 		case PROPERTY_ID_RESULTSETCONCURRENCY:
1108 		case PROPERTY_ID_RESULTSETTYPE:
1109 			throw Exception();
1110 			break;
1111 		case PROPERTY_ID_FETCHDIRECTION:
1112 			setFetchDirection(getINT32(rValue));
1113 			break;
1114 		case PROPERTY_ID_FETCHSIZE:
1115 			setFetchSize(getINT32(rValue));
1116 			break;
1117 		default:
1118 			;
1119 	}
1120 }
1121 // -------------------------------------------------------------------------
getFastPropertyValue(Any & rValue,sal_Int32 nHandle) const1122 void OResultSet::getFastPropertyValue(Any& rValue,sal_Int32 nHandle) const
1123 {
1124 	switch(nHandle)
1125 	{
1126 		case PROPERTY_ID_ISBOOKMARKABLE:
1127 			{
1128 				VARIANT_BOOL bBool;
1129 				m_pRecordSet->Supports(adBookmark,&bBool);
1130 				sal_Bool bRet = bBool == VARIANT_TRUE;
1131 				rValue.setValue(&bRet, ::getCppuBooleanType() );
1132 			}
1133 			break;
1134 		case PROPERTY_ID_CURSORNAME:
1135 			rValue <<= getCursorName();
1136 			break;
1137 		case PROPERTY_ID_RESULTSETCONCURRENCY:
1138 			rValue <<= getResultSetConcurrency();
1139 			break;
1140 		case PROPERTY_ID_RESULTSETTYPE:
1141 			rValue <<= getResultSetType();
1142 			break;
1143 		case PROPERTY_ID_FETCHDIRECTION:
1144 			rValue <<= getFetchDirection();
1145 			break;
1146 		case PROPERTY_ID_FETCHSIZE:
1147 			rValue <<= getFetchSize();
1148 			break;
1149 	}
1150 }
1151 // -----------------------------------------------------------------------------
acquire()1152 void SAL_CALL OResultSet::acquire() throw()
1153 {
1154 	OResultSet_BASE::acquire();
1155 }
1156 // -----------------------------------------------------------------------------
release()1157 void SAL_CALL OResultSet::release() throw()
1158 {
1159 	OResultSet_BASE::release();
1160 }
1161 // -----------------------------------------------------------------------------
getPropertySetInfo()1162 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL OResultSet::getPropertySetInfo(  ) throw(::com::sun::star::uno::RuntimeException)
1163 {
1164 	return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
1165 }
1166 // -----------------------------------------------------------------------------
1167 
1168 
1169 
1170