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  
27  #include "MacabResultSet.hxx"
28  #include "MacabAddressBook.hxx"
29  #include "MacabRecords.hxx"
30  #include "macabutilities.hxx"
31  #include "MacabResultSetMetaData.hxx"
32  #include "MacabConnection.hxx"
33  #include "macabcondition.hxx"
34  #include "macaborder.hxx"
35  #include <com/sun/star/beans/PropertyAttribute.hpp>
36  #include <com/sun/star/sdbcx/CompareBookmark.hpp>
37  #include "TConnection.hxx"
38  #include <connectivity/dbexception.hxx>
39  #include "resource/sharedresources.hxx"
40  #include "resource/macab_res.hrc"
41  
42  using namespace connectivity::macab;
43  using namespace cppu;
44  using namespace com::sun::star::uno;
45  using namespace com::sun::star::lang;
46  using namespace com::sun::star::beans;
47  using namespace com::sun::star::sdbc;
48  using namespace com::sun::star::sdbcx;
49  using namespace com::sun::star::io;
50  using namespace com::sun::star::util;
51  
52  IMPLEMENT_SERVICE_INFO(MacabResultSet, "com.sun.star.sdbc.drivers.MacabResultSet", "com.sun.star.sdbc.ResultSet");
53  // -------------------------------------------------------------------------
MacabResultSet(MacabCommonStatement * pStmt)54  MacabResultSet::MacabResultSet(MacabCommonStatement* pStmt)
55  	: MacabResultSet_BASE(m_aMutex),
56  	  OPropertySetHelper(MacabResultSet_BASE::rBHelper),
57  	  m_xStatement(pStmt),
58  	  m_xMetaData(NULL),
59  	  m_aMacabRecords(),
60  	  m_nRowPos(-1),
61  	  m_bWasNull(sal_True)
62  {
63  	m_sTableName = MacabAddressBook::getDefaultTableName();
64  }
65  // -------------------------------------------------------------------------
~MacabResultSet()66  MacabResultSet::~MacabResultSet()
67  {
68  }
69  // -------------------------------------------------------------------------
allMacabRecords()70  void MacabResultSet::allMacabRecords()
71  {
72  	MacabConnection* pConnection = static_cast< MacabConnection *>(m_xStatement->getConnection().get());
73  
74  	m_aMacabRecords = pConnection->getAddressBook()->getMacabRecords(m_sTableName);
75  }
76  // -------------------------------------------------------------------------
someMacabRecords(const MacabCondition * pCondition)77  void MacabResultSet::someMacabRecords(const MacabCondition *pCondition)
78  {
79  	MacabConnection* pConnection = static_cast< MacabConnection *>(m_xStatement->getConnection().get());
80  	MacabRecords* allRecords;
81  
82  	allRecords = pConnection->getAddressBook()->getMacabRecords(m_sTableName);
83  
84  	// Bad table!! Throw exception?
85  	if(allRecords == NULL)
86  		return;
87  
88  	if(m_aMacabRecords != NULL && m_aMacabRecords != allRecords)
89  		delete m_aMacabRecords;
90  
91  	// The copy constructor copies everything but records (including the
92  	// maximum alloted size, which means that we'll never have to resize)
93  	m_aMacabRecords = new MacabRecords(allRecords);
94  
95  	MacabRecords::iterator iterator;
96  
97  	for (iterator = allRecords->begin();
98  	     iterator != allRecords->end();
99  	     ++iterator)
100  	{
101  		if (pCondition->eval(*iterator))
102  			m_aMacabRecords->insertRecord(*iterator);
103  	}
104  }
105  // -------------------------------------------------------------------------
sortMacabRecords(const MacabOrder * pOrder)106  void MacabResultSet::sortMacabRecords(const MacabOrder *pOrder)
107  {
108  	// I do this with ints rather than an iterator because the ids will
109  	// be changing when we change the order and ints are easier to deal
110  	// with (for me).
111  	sal_Int32 i, j, size, smallest;
112  	size = m_aMacabRecords->size();
113  
114  	for(i = 0; i < size; i++)
115  	{
116  		smallest = i;
117  		for( j = i + 1; j < size; j++)
118  		{
119  			// if smallest > j
120  			if(pOrder->compare(m_aMacabRecords->getRecord(smallest),
121  						m_aMacabRecords->getRecord(j) ) > 0)
122  			{
123  				smallest = j;
124  			}
125  
126  		}
127  
128  		if(smallest != i)
129  		{
130  			m_aMacabRecords->swap(i,smallest);
131  		}
132  	}
133  
134  }
135  // -------------------------------------------------------------------------
setTableName(::rtl::OUString _sTableName)136  void MacabResultSet::setTableName(::rtl::OUString _sTableName)
137  {
138  	m_sTableName = _sTableName;
139  }
140  // -------------------------------------------------------------------------
disposing()141  void MacabResultSet::disposing()
142  {
143  	OPropertySetHelper::disposing();
144  
145  	::osl::MutexGuard aGuard(m_aMutex);
146  
147  m_xStatement.clear();
148  m_xMetaData.clear();
149  }
150  // -------------------------------------------------------------------------
queryInterface(const Type & rType)151  Any SAL_CALL MacabResultSet::queryInterface(const Type & rType) throw(RuntimeException)
152  {
153  	Any aRet = OPropertySetHelper::queryInterface(rType);
154  	if (!aRet.hasValue())
155  		aRet = MacabResultSet_BASE::queryInterface(rType);
156  	return aRet;
157  }
158  // -------------------------------------------------------------------------
acquire()159  void SAL_CALL MacabResultSet::acquire() throw()
160  {
161  	MacabResultSet_BASE::acquire();
162  }
163  // -------------------------------------------------------------------------
release()164  void SAL_CALL MacabResultSet::release() throw()
165  {
166  	MacabResultSet_BASE::release();
167  }
168  // -------------------------------------------------------------------------
getTypes()169  Sequence<  Type > SAL_CALL MacabResultSet::getTypes() throw(RuntimeException)
170  {
171  	OTypeCollection aTypes(
172  		::getCppuType( (const Reference< ::com::sun::star::beans::XMultiPropertySet >*) 0),
173  		::getCppuType( (const Reference< ::com::sun::star::beans::XFastPropertySet >*) 0),
174  		::getCppuType( (const Reference< ::com::sun::star::beans::XPropertySet >*) 0));
175  
176  	return comphelper::concatSequences(aTypes.getTypes(), MacabResultSet_BASE::getTypes());
177  }
178  // -------------------------------------------------------------------------
getPropertySetInfo()179  ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL MacabResultSet::getPropertySetInfo(  ) throw(::com::sun::star::uno::RuntimeException)
180  {
181  	return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
182  }
183  // -------------------------------------------------------------------------
findColumn(const::rtl::OUString & columnName)184  sal_Int32 SAL_CALL MacabResultSet::findColumn(const ::rtl::OUString& columnName) throw(SQLException, RuntimeException)
185  {
186  	::osl::MutexGuard aGuard( m_aMutex );
187  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
188  
189  	// find the first column with the name columnName
190  	Reference< XResultSetMetaData > xMeta = getMetaData();
191  	sal_Int32 nLen = xMeta->getColumnCount();
192  
193  	for (sal_Int32 i = 1; i <= nLen; ++i)
194  		if (xMeta->isCaseSensitive(i) ?
195  			columnName == xMeta->getColumnName(i) :
196  			columnName.equalsIgnoreAsciiCase(xMeta->getColumnName(i)))
197  				return i;
198  
199      ::connectivity::SharedResources aResources;
200      const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution(
201              STR_NO_ELEMENT_NAME,
202              "$name$", columnName
203           ) );
204  	::dbtools::throwGenericSQLException(sError , *this);
205      // Unreachable:
206      OSL_ASSERT(false);
207      return 0;
208  }
209  // -------------------------------------------------------------------------
getString(sal_Int32 columnIndex)210  ::rtl::OUString SAL_CALL MacabResultSet::getString(sal_Int32 columnIndex) throw(SQLException, RuntimeException)
211  {
212  	::osl::MutexGuard aGuard( m_aMutex );
213  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
214  
215  	::rtl::OUString aRet;
216  	sal_Int32 nRecords = m_aMacabRecords->size();
217  	m_bWasNull = true;
218  
219  	if (m_nRowPos != -1 && m_nRowPos != nRecords && m_xMetaData.is())
220  	{
221  		sal_Int32 nFieldNumber = m_xMetaData->fieldAtColumn(columnIndex);
222  		macabfield *aField = m_aMacabRecords->getField(m_nRowPos,nFieldNumber);
223  		if(aField != NULL)
224  		{
225  			if(aField->type == kABStringProperty)
226  			{
227  				aRet = CFStringToOUString( (CFStringRef) aField->value);
228  				m_bWasNull = false;
229  			}
230  		}
231  	}
232  
233  // Trigger an exception if m_bWasNull is true?
234  	return aRet;
235  }
236  // -------------------------------------------------------------------------
getBoolean(sal_Int32)237  sal_Bool SAL_CALL MacabResultSet::getBoolean(sal_Int32) throw(SQLException, RuntimeException)
238  {
239  	::osl::MutexGuard aGuard( m_aMutex );
240  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
241  
242  ::dbtools::throwFunctionNotSupportedException("getBoolean", NULL);
243  
244  	return sal_False;
245  }
246  // -------------------------------------------------------------------------
getByte(sal_Int32)247  sal_Int8 SAL_CALL MacabResultSet::getByte(sal_Int32) throw(SQLException, RuntimeException)
248  {
249  	::osl::MutexGuard aGuard( m_aMutex );
250  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
251  
252  ::dbtools::throwFunctionNotSupportedException("getByte", NULL);
253  
254  	sal_Int8 nRet = 0;
255  	return nRet;
256  }
257  // -------------------------------------------------------------------------
getShort(sal_Int32)258  sal_Int16 SAL_CALL MacabResultSet::getShort(sal_Int32) throw(SQLException, RuntimeException)
259  {
260  	::osl::MutexGuard aGuard( m_aMutex );
261  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
262  
263  ::dbtools::throwFunctionNotSupportedException("getShort", NULL);
264  
265  	sal_Int16 nRet = 0;
266  	return nRet;
267  }
268  // -------------------------------------------------------------------------
getInt(sal_Int32 columnIndex)269  sal_Int32 SAL_CALL MacabResultSet::getInt(sal_Int32 columnIndex) throw(SQLException, RuntimeException)
270  {
271  	::osl::MutexGuard aGuard( m_aMutex );
272  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
273  
274  	sal_Int32 nRet = 0;
275  	sal_Int32 nRecords = m_aMacabRecords->size();
276  	m_bWasNull = true;
277  
278  	if (m_nRowPos != -1 && m_nRowPos != nRecords && m_xMetaData.is())
279  	{
280  		sal_Int32 nFieldNumber = m_xMetaData->fieldAtColumn(columnIndex);
281  		macabfield *aField = m_aMacabRecords->getField(m_nRowPos,nFieldNumber);
282  		if(aField != NULL)
283  		{
284  			if(aField->type == kABIntegerProperty)
285  			{
286  				CFNumberType numberType = CFNumberGetType( (CFNumberRef) aField->value );
287  				// m_bWasNull now becomes whether getting the value was successful
288  				// Should we check for the wrong type here, e.g., a float or a 64 bit int?
289  				m_bWasNull = !CFNumberGetValue((CFNumberRef) aField->value, numberType, &nRet);
290  			}
291  		}
292  	}
293  
294  // Trigger an exception if m_bWasNull is true?
295  	return nRet;
296  }
297  // -------------------------------------------------------------------------
getLong(sal_Int32 columnIndex)298  sal_Int64 SAL_CALL MacabResultSet::getLong(sal_Int32 columnIndex) throw(SQLException, RuntimeException)
299  {
300  	::osl::MutexGuard aGuard( m_aMutex );
301  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
302  
303  	sal_Int64 nRet = 0;
304  	sal_Int32 nRecords = m_aMacabRecords->size();
305  	m_bWasNull = true;
306  
307  	if (m_nRowPos != -1 && m_nRowPos != nRecords && m_xMetaData.is())
308  	{
309  		sal_Int32 nFieldNumber = m_xMetaData->fieldAtColumn(columnIndex);
310  		macabfield *aField = m_aMacabRecords->getField(m_nRowPos,nFieldNumber);
311  		if(aField != NULL)
312  		{
313  			if(aField->type == kABIntegerProperty)
314  			{
315  				CFNumberType numberType = CFNumberGetType( (CFNumberRef) aField->value );
316  				// m_bWasNull now becomes whether getting the value was successful
317  				// Should we check for the wrong type here, e.g., a float or a 32 bit int?
318  				m_bWasNull = !CFNumberGetValue((CFNumberRef) aField->value, numberType, &nRet);
319  			}
320  		}
321  	}
322  
323  // Trigger an exception if m_bWasNull is true?
324  	return nRet;
325  }
326  // -------------------------------------------------------------------------
getFloat(sal_Int32 columnIndex)327  float SAL_CALL MacabResultSet::getFloat(sal_Int32 columnIndex) throw(SQLException, RuntimeException)
328  {
329  	::osl::MutexGuard aGuard( m_aMutex );
330  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
331  
332  	float nVal = 0;
333  	sal_Int32 nRecords = m_aMacabRecords->size();
334  	m_bWasNull = true;
335  
336  	if (m_nRowPos != -1 && m_nRowPos != nRecords && m_xMetaData.is())
337  	{
338  		sal_Int32 nFieldNumber = m_xMetaData->fieldAtColumn(columnIndex);
339  		macabfield *aField = m_aMacabRecords->getField(m_nRowPos,nFieldNumber);
340  		if(aField != NULL)
341  		{
342  			if(aField->type == kABRealProperty)
343  			{
344  				CFNumberType numberType = CFNumberGetType( (CFNumberRef) aField->value );
345  				// m_bWasNull now becomes whether getting the value was successful
346  				// Should we check for the wrong type here, e.g., an int or a double?
347  				m_bWasNull = !CFNumberGetValue((CFNumberRef) aField->value, numberType, &nVal);
348  			}
349  		}
350  	}
351  
352  // Trigger an exception if m_bWasNull is true?
353  	return nVal;
354  }
355  // -------------------------------------------------------------------------
getDouble(sal_Int32 columnIndex)356  double SAL_CALL MacabResultSet::getDouble(sal_Int32 columnIndex) throw(SQLException, RuntimeException)
357  {
358  	::osl::MutexGuard aGuard( m_aMutex );
359  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
360  
361  	double nVal = 0;
362  	sal_Int32 nRecords = m_aMacabRecords->size();
363  	m_bWasNull = true;
364  
365  	if (m_nRowPos != -1 && m_nRowPos != nRecords && m_xMetaData.is())
366  	{
367  		sal_Int32 nFieldNumber = m_xMetaData->fieldAtColumn(columnIndex);
368  		macabfield *aField = m_aMacabRecords->getField(m_nRowPos,nFieldNumber);
369  		if(aField != NULL)
370  		{
371  			if(aField->type == kABRealProperty)
372  			{
373  				CFNumberType numberType = CFNumberGetType( (CFNumberRef) aField->value );
374  				// m_bWasNull now becomes whether getting the value was successful
375  				// Should we check for the wrong type here, e.g., an int or a float?
376  				m_bWasNull = !CFNumberGetValue((CFNumberRef) aField->value, numberType, &nVal);
377  			}
378  		}
379  	}
380  
381  // Trigger an exception if m_bWasNull is true?
382  	return nVal;
383  }
384  // -------------------------------------------------------------------------
getBytes(sal_Int32)385  Sequence< sal_Int8 > SAL_CALL MacabResultSet::getBytes(sal_Int32) throw(SQLException, RuntimeException)
386  {
387  	::osl::MutexGuard aGuard( m_aMutex );
388  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
389  
390  ::dbtools::throwFunctionNotSupportedException("getBytes", NULL);
391  
392  	return Sequence< sal_Int8 >();
393  }
394  // -------------------------------------------------------------------------
getDate(sal_Int32)395  Date SAL_CALL MacabResultSet::getDate(sal_Int32) throw(SQLException, RuntimeException)
396  {
397  	::osl::MutexGuard aGuard( m_aMutex );
398  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
399  
400  ::dbtools::throwFunctionNotSupportedException("getDate", NULL);
401  
402  	Date aRet;
403  	return aRet;
404  }
405  // -------------------------------------------------------------------------
getTime(sal_Int32)406  Time SAL_CALL MacabResultSet::getTime(sal_Int32) throw(SQLException, RuntimeException)
407  {
408  	::osl::MutexGuard aGuard( m_aMutex );
409  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
410  
411  ::dbtools::throwFunctionNotSupportedException("getTime", NULL);
412  
413  	Time nRet;
414  	return nRet;
415  }
416  // -------------------------------------------------------------------------
getTimestamp(sal_Int32 columnIndex)417  DateTime SAL_CALL MacabResultSet::getTimestamp(sal_Int32 columnIndex) throw(SQLException, RuntimeException)
418  {
419  	::osl::MutexGuard aGuard( m_aMutex );
420  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
421  
422  	DateTime nRet;
423  	sal_Int32 nRecords = m_aMacabRecords->size();
424  	m_bWasNull = true;
425  
426  	if (m_nRowPos != -1 && m_nRowPos != nRecords && m_xMetaData.is())
427  	{
428  		sal_Int32 nFieldNumber = m_xMetaData->fieldAtColumn(columnIndex);
429  		macabfield *aField = m_aMacabRecords->getField(m_nRowPos,nFieldNumber);
430  		if(aField != NULL)
431  		{
432  			if(aField->type == kABDateProperty)
433  			{
434  				nRet = CFDateToDateTime((CFDateRef) aField->value);
435  				m_bWasNull = false;
436  			}
437  		}
438  	}
439  
440  // Trigger an exception if m_bWasNull is true?
441  	return nRet;
442  }
443  // -------------------------------------------------------------------------
getBinaryStream(sal_Int32)444  Reference< XInputStream > SAL_CALL MacabResultSet::getBinaryStream(sal_Int32) throw(SQLException, RuntimeException)
445  {
446  	::osl::MutexGuard aGuard( m_aMutex );
447  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
448  
449  ::dbtools::throwFunctionNotSupportedException("getBinaryStream", NULL);
450  
451  	return NULL;
452  }
453  // -------------------------------------------------------------------------
getCharacterStream(sal_Int32)454  Reference< XInputStream > SAL_CALL MacabResultSet::getCharacterStream(sal_Int32) throw(SQLException, RuntimeException)
455  {
456  	::osl::MutexGuard aGuard( m_aMutex );
457  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
458  
459  ::dbtools::throwFunctionNotSupportedException("getCharacterStream", NULL);
460  
461  	return NULL;
462  }
463  // -------------------------------------------------------------------------
getObject(sal_Int32,const Reference<::com::sun::star::container::XNameAccess> &)464  Any SAL_CALL MacabResultSet::getObject(sal_Int32, const Reference< ::com::sun::star::container::XNameAccess >&) throw(SQLException, RuntimeException)
465  {
466  	::osl::MutexGuard aGuard( m_aMutex );
467  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
468  
469  ::dbtools::throwFunctionNotSupportedException("getObject", NULL);
470  
471  	return Any();
472  }
473  // -------------------------------------------------------------------------
getRef(sal_Int32)474  Reference< XRef > SAL_CALL MacabResultSet::getRef(sal_Int32) throw(SQLException, RuntimeException)
475  {
476  	::osl::MutexGuard aGuard( m_aMutex );
477  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
478  
479  ::dbtools::throwFunctionNotSupportedException("getRef", NULL);
480  
481  	return NULL;
482  }
483  // -------------------------------------------------------------------------
getBlob(sal_Int32)484  Reference< XBlob > SAL_CALL MacabResultSet::getBlob(sal_Int32) throw(SQLException, RuntimeException)
485  {
486  	::osl::MutexGuard aGuard( m_aMutex );
487  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
488  
489  ::dbtools::throwFunctionNotSupportedException("getBlob", NULL);
490  
491  	return NULL;
492  }
493  // -------------------------------------------------------------------------
getClob(sal_Int32)494  Reference< XClob > SAL_CALL MacabResultSet::getClob(sal_Int32) throw(SQLException, RuntimeException)
495  {
496  	::osl::MutexGuard aGuard( m_aMutex );
497  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
498  
499  ::dbtools::throwFunctionNotSupportedException("getClob", NULL);
500  
501  	return NULL;
502  }
503  // -------------------------------------------------------------------------
getArray(sal_Int32)504  Reference< XArray > SAL_CALL MacabResultSet::getArray(sal_Int32) throw(SQLException, RuntimeException)
505  {
506  	::osl::MutexGuard aGuard( m_aMutex );
507  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
508  
509  ::dbtools::throwFunctionNotSupportedException("getArray", NULL);
510  
511  	return NULL;
512  }
513  // -------------------------------------------------------------------------
getMetaData()514  Reference< XResultSetMetaData > SAL_CALL MacabResultSet::getMetaData() throw(SQLException, RuntimeException)
515  {
516  	::osl::MutexGuard aGuard( m_aMutex );
517  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
518  
519  	if (!m_xMetaData.is())
520  		m_xMetaData = new MacabResultSetMetaData(m_xStatement->getOwnConnection(), m_sTableName);
521  
522  	Reference< XResultSetMetaData > xMetaData = m_xMetaData.get();
523  	return xMetaData;
524  }
525  // -------------------------------------------------------------------------
isBeforeFirst()526  sal_Bool SAL_CALL MacabResultSet::isBeforeFirst() throw(SQLException, RuntimeException)
527  {
528  	::osl::MutexGuard aGuard( m_aMutex );
529  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
530  
531  	if (m_nRowPos == -1)
532  		return sal_True;
533  
534  	return sal_False;
535  }
536  // -------------------------------------------------------------------------
isAfterLast()537  sal_Bool SAL_CALL MacabResultSet::isAfterLast() throw(SQLException, RuntimeException)
538  {
539  	::osl::MutexGuard aGuard( m_aMutex );
540  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
541  
542  	sal_Int32 nRecords = m_aMacabRecords->size();
543  	if (m_nRowPos == nRecords)
544  		return sal_True;
545  
546  	return sal_False;
547  }
548  // -------------------------------------------------------------------------
isFirst()549  sal_Bool SAL_CALL MacabResultSet::isFirst() throw(SQLException, RuntimeException)
550  {
551  	::osl::MutexGuard aGuard( m_aMutex );
552  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
553  
554  	if (m_nRowPos == 0)
555  		return sal_True;
556  
557  	return sal_False;
558  }
559  // -------------------------------------------------------------------------
isLast()560  sal_Bool SAL_CALL MacabResultSet::isLast() throw(SQLException, RuntimeException)
561  {
562  	::osl::MutexGuard aGuard( m_aMutex );
563  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
564  
565  	sal_Int32 nRecords = m_aMacabRecords->size();
566  	if (m_nRowPos == nRecords - 1)
567  		return sal_True;
568  
569  	return sal_False;
570  }
571  // -------------------------------------------------------------------------
beforeFirst()572  void SAL_CALL MacabResultSet::beforeFirst() throw(SQLException, RuntimeException)
573  {
574  	::osl::MutexGuard aGuard( m_aMutex );
575  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
576  
577  	// move before the first row
578  	m_nRowPos = -1;
579  }
580  // -------------------------------------------------------------------------
afterLast()581  void SAL_CALL MacabResultSet::afterLast() throw(SQLException, RuntimeException)
582  {
583  	::osl::MutexGuard aGuard( m_aMutex );
584  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
585  
586  	// move after the last row
587  	sal_Int32 nRecords = m_aMacabRecords->size();
588  	m_nRowPos = nRecords;
589  }
590  // -------------------------------------------------------------------------
close()591  void SAL_CALL MacabResultSet::close() throw(SQLException, RuntimeException)
592  {
593  	{
594  		::osl::MutexGuard aGuard( m_aMutex );
595  		checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
596  	}
597  	dispose();
598  }
599  // -------------------------------------------------------------------------
first()600  sal_Bool SAL_CALL MacabResultSet::first() throw(SQLException, RuntimeException)
601  {
602  	::osl::MutexGuard aGuard( m_aMutex );
603  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
604  
605  	sal_Int32 nRecords = m_aMacabRecords->size();
606  	if (nRecords == 0)
607  		return sal_False;
608  
609  	m_nRowPos = 0;
610  	return sal_True;
611  }
612  // -------------------------------------------------------------------------
last()613  sal_Bool SAL_CALL MacabResultSet::last() throw(SQLException, RuntimeException)
614  {
615  	::osl::MutexGuard aGuard( m_aMutex );
616  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
617  
618  	sal_Int32 nRecords = m_aMacabRecords->size();
619  	if (nRecords == 0)
620  		return sal_False;
621  
622  	m_nRowPos = nRecords - 1;
623  	return sal_True;
624  }
625  // -------------------------------------------------------------------------
getRow()626  sal_Int32 SAL_CALL MacabResultSet::getRow() throw(SQLException, RuntimeException)
627  {
628  	::osl::MutexGuard aGuard( m_aMutex );
629  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
630  
631  	return m_nRowPos;
632  }
633  // -------------------------------------------------------------------------
absolute(sal_Int32 row)634  sal_Bool SAL_CALL MacabResultSet::absolute(sal_Int32 row) throw(SQLException, RuntimeException)
635  {
636  	::osl::MutexGuard aGuard( m_aMutex );
637  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
638  
639  	sal_Int32 nRecords = m_aMacabRecords->size();
640  	if (row <= -1 ||
641  	    row >= nRecords)
642  		return sal_False;
643  
644  	m_nRowPos = row;
645  	return sal_True;
646  }
647  // -------------------------------------------------------------------------
relative(sal_Int32 row)648  sal_Bool SAL_CALL MacabResultSet::relative(sal_Int32 row) throw(SQLException, RuntimeException)
649  {
650  	::osl::MutexGuard aGuard( m_aMutex );
651  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
652  
653  	return absolute(m_nRowPos + row);
654  }
655  // -------------------------------------------------------------------------
next()656  sal_Bool SAL_CALL MacabResultSet::next() throw(SQLException, RuntimeException)
657  {
658  	::osl::MutexGuard aGuard( m_aMutex );
659  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
660  
661  	return absolute(m_nRowPos + 1);
662  }
663  // -------------------------------------------------------------------------
previous()664  sal_Bool SAL_CALL MacabResultSet::previous() throw(SQLException, RuntimeException)
665  {
666  	::osl::MutexGuard aGuard( m_aMutex );
667  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
668  
669  	return absolute(m_nRowPos - 1);
670  }
671  // -------------------------------------------------------------------------
getStatement()672  Reference< XInterface > SAL_CALL MacabResultSet::getStatement() throw(SQLException, RuntimeException)
673  {
674  	::osl::MutexGuard aGuard( m_aMutex );
675  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
676  
677  	Reference< XStatement > xStatement = m_xStatement.get();
678  	return xStatement;
679  }
680  // -------------------------------------------------------------------------
rowDeleted()681  sal_Bool SAL_CALL MacabResultSet::rowDeleted() throw(SQLException, RuntimeException)
682  {
683  	::osl::MutexGuard aGuard( m_aMutex );
684  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
685  
686  	return sal_False;
687  }
688  // -------------------------------------------------------------------------
rowInserted()689  sal_Bool SAL_CALL MacabResultSet::rowInserted() throw(SQLException, RuntimeException)
690  {
691  	::osl::MutexGuard aGuard( m_aMutex );
692  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
693  
694  	return sal_False;
695  }
696  // -------------------------------------------------------------------------
rowUpdated()697  sal_Bool SAL_CALL MacabResultSet::rowUpdated() throw(SQLException, RuntimeException)
698  {
699  	::osl::MutexGuard aGuard( m_aMutex );
700  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
701  
702  	return sal_False;
703  }
704  // -------------------------------------------------------------------------
wasNull()705  sal_Bool SAL_CALL MacabResultSet::wasNull() throw(SQLException, RuntimeException)
706  {
707  	::osl::MutexGuard aGuard( m_aMutex );
708  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
709  
710  	return m_bWasNull;
711  }
712  // -------------------------------------------------------------------------
cancel()713  void SAL_CALL MacabResultSet::cancel() throw(RuntimeException)
714  {
715  	::osl::MutexGuard aGuard( m_aMutex );
716  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
717  }
718  // -------------------------------------------------------------------------
clearWarnings()719  void SAL_CALL MacabResultSet::clearWarnings() throw(SQLException, RuntimeException)
720  {
721  }
722  // -------------------------------------------------------------------------
getWarnings()723  Any SAL_CALL MacabResultSet::getWarnings() throw(SQLException, RuntimeException)
724  {
725  	return Any();
726  }
727  // -------------------------------------------------------------------------
insertRow()728  void SAL_CALL MacabResultSet::insertRow() throw(SQLException, RuntimeException)
729  {
730  	::osl::MutexGuard aGuard( m_aMutex );
731  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
732  
733  	// you only have to implement this if you want to insert new rows
734  }
735  // -------------------------------------------------------------------------
updateRow()736  void SAL_CALL MacabResultSet::updateRow() throw(SQLException, RuntimeException)
737  {
738  	::osl::MutexGuard aGuard( m_aMutex );
739  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
740  
741  	// only when you allow updates
742  }
743  // -------------------------------------------------------------------------
deleteRow()744  void SAL_CALL MacabResultSet::deleteRow() throw(SQLException, RuntimeException)
745  {
746  	::osl::MutexGuard aGuard( m_aMutex );
747  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
748  }
749  // -------------------------------------------------------------------------
cancelRowUpdates()750  void SAL_CALL MacabResultSet::cancelRowUpdates() throw(SQLException, RuntimeException)
751  {
752  	::osl::MutexGuard aGuard( m_aMutex );
753  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
754  }
755  // -------------------------------------------------------------------------
moveToInsertRow()756  void SAL_CALL MacabResultSet::moveToInsertRow() throw(SQLException, RuntimeException)
757  {
758  	::osl::MutexGuard aGuard( m_aMutex );
759  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
760  
761  	// only when you allow inserts
762  }
763  // -------------------------------------------------------------------------
moveToCurrentRow()764  void SAL_CALL MacabResultSet::moveToCurrentRow() throw(SQLException, RuntimeException)
765  {
766  	::osl::MutexGuard aGuard( m_aMutex );
767  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
768  }
769  // -------------------------------------------------------------------------
updateNull(sal_Int32)770  void SAL_CALL MacabResultSet::updateNull(sal_Int32) throw(SQLException, RuntimeException)
771  {
772  	::osl::MutexGuard aGuard( m_aMutex );
773  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
774  }
775  // -------------------------------------------------------------------------
updateBoolean(sal_Int32,sal_Bool)776  void SAL_CALL MacabResultSet::updateBoolean(sal_Int32, sal_Bool) throw(SQLException, RuntimeException)
777  {
778  	::osl::MutexGuard aGuard( m_aMutex );
779  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
780  }
781  // -------------------------------------------------------------------------
updateByte(sal_Int32,sal_Int8)782  void SAL_CALL MacabResultSet::updateByte(sal_Int32, sal_Int8) throw(SQLException, RuntimeException)
783  {
784  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
785  	::osl::MutexGuard aGuard( m_aMutex );
786  }
787  // -------------------------------------------------------------------------
updateShort(sal_Int32,sal_Int16)788  void SAL_CALL MacabResultSet::updateShort(sal_Int32, sal_Int16) throw(SQLException, RuntimeException)
789  {
790  	::osl::MutexGuard aGuard( m_aMutex );
791  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
792  }
793  // -------------------------------------------------------------------------
updateInt(sal_Int32,sal_Int32)794  void SAL_CALL MacabResultSet::updateInt(sal_Int32, sal_Int32) throw(SQLException, RuntimeException)
795  {
796  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
797  	::osl::MutexGuard aGuard( m_aMutex );
798  }
799  // -------------------------------------------------------------------------
updateLong(sal_Int32,sal_Int64)800  void SAL_CALL MacabResultSet::updateLong(sal_Int32, sal_Int64) throw(SQLException, RuntimeException)
801  {
802  	::osl::MutexGuard aGuard( m_aMutex );
803  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
804  }
805  // -----------------------------------------------------------------------
updateFloat(sal_Int32,float)806  void SAL_CALL MacabResultSet::updateFloat(sal_Int32, float) throw(SQLException, RuntimeException)
807  {
808  	::osl::MutexGuard aGuard( m_aMutex );
809  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
810  }
811  // -------------------------------------------------------------------------
updateDouble(sal_Int32,double)812  void SAL_CALL MacabResultSet::updateDouble(sal_Int32, double) throw(SQLException, RuntimeException)
813  {
814  	::osl::MutexGuard aGuard( m_aMutex );
815  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
816  }
817  // -------------------------------------------------------------------------
updateString(sal_Int32,const::rtl::OUString &)818  void SAL_CALL MacabResultSet::updateString(sal_Int32, const ::rtl::OUString&) throw(SQLException, RuntimeException)
819  {
820  	::osl::MutexGuard aGuard( m_aMutex );
821  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
822  }
823  // -------------------------------------------------------------------------
updateBytes(sal_Int32,const Sequence<sal_Int8> &)824  void SAL_CALL MacabResultSet::updateBytes(sal_Int32, const Sequence< sal_Int8 >&) throw(SQLException, RuntimeException)
825  {
826  	::osl::MutexGuard aGuard( m_aMutex );
827  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
828  }
829  // -------------------------------------------------------------------------
updateDate(sal_Int32,const Date &)830  void SAL_CALL MacabResultSet::updateDate(sal_Int32, const Date&) throw(SQLException, RuntimeException)
831  {
832  	::osl::MutexGuard aGuard( m_aMutex );
833  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
834  }
835  // -------------------------------------------------------------------------
updateTime(sal_Int32,const Time &)836  void SAL_CALL MacabResultSet::updateTime(sal_Int32, const Time&) throw(SQLException, RuntimeException)
837  {
838  	::osl::MutexGuard aGuard( m_aMutex );
839  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
840  }
841  // -------------------------------------------------------------------------
updateTimestamp(sal_Int32,const DateTime &)842  void SAL_CALL MacabResultSet::updateTimestamp(sal_Int32, const DateTime&) throw(SQLException, RuntimeException)
843  {
844  	::osl::MutexGuard aGuard( m_aMutex );
845  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
846  }
847  // -------------------------------------------------------------------------
updateBinaryStream(sal_Int32,const Reference<XInputStream> &,sal_Int32)848  void SAL_CALL MacabResultSet::updateBinaryStream(sal_Int32, const Reference< XInputStream >&, sal_Int32) throw(SQLException, RuntimeException)
849  {
850  	::osl::MutexGuard aGuard( m_aMutex );
851  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
852  }
853  // -------------------------------------------------------------------------
updateCharacterStream(sal_Int32,const Reference<XInputStream> &,sal_Int32)854  void SAL_CALL MacabResultSet::updateCharacterStream(sal_Int32, const Reference< XInputStream >&, sal_Int32) throw(SQLException, RuntimeException)
855  {
856  	::osl::MutexGuard aGuard( m_aMutex );
857  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
858  }
859  // -------------------------------------------------------------------------
refreshRow()860  void SAL_CALL MacabResultSet::refreshRow() throw(SQLException, RuntimeException)
861  {
862  	::osl::MutexGuard aGuard( m_aMutex );
863  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
864  }
865  // -------------------------------------------------------------------------
updateObject(sal_Int32,const Any &)866  void SAL_CALL MacabResultSet::updateObject(sal_Int32, const Any&) throw(SQLException, RuntimeException)
867  {
868  	::osl::MutexGuard aGuard( m_aMutex );
869  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
870  }
871  // -------------------------------------------------------------------------
updateNumericObject(sal_Int32,const Any &,sal_Int32)872  void SAL_CALL MacabResultSet::updateNumericObject(sal_Int32, const Any&, sal_Int32) throw(SQLException, RuntimeException)
873  {
874  	::osl::MutexGuard aGuard( m_aMutex );
875  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
876  }
877  // -------------------------------------------------------------------------
878  // XRowLocate
getBookmark()879  Any SAL_CALL MacabResultSet::getBookmark() throw( SQLException,  RuntimeException)
880  {
881  	::osl::MutexGuard aGuard( m_aMutex );
882  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
883  
884  	sal_Int32 nRecords = m_aMacabRecords->size();
885  
886  	if (m_nRowPos != -1 && m_nRowPos != nRecords)
887  	{
888  		macabfield *uidField = m_aMacabRecords->getField(m_nRowPos,::rtl::OUString::createFromAscii("UID"));
889  		if(uidField != NULL)
890  		{
891  			if(uidField->type == kABStringProperty)
892  			{
893  				return makeAny(CFStringToOUString( (CFStringRef) uidField->value ));
894  			}
895  		}
896  	}
897  	return Any();
898  }
899  // -------------------------------------------------------------------------
moveToBookmark(const Any & bookmark)900  sal_Bool SAL_CALL MacabResultSet::moveToBookmark(const  Any& bookmark) throw( SQLException,  RuntimeException)
901  {
902  	::osl::MutexGuard aGuard( m_aMutex );
903  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
904  
905  	::rtl::OUString sBookmark = comphelper::getString(bookmark);
906          sal_Int32 nRecords = m_aMacabRecords->size();
907  
908  	for (sal_Int32 nRow = 0; nRow < nRecords; nRow++)
909  	{
910  		macabfield *uidField = m_aMacabRecords->getField(m_nRowPos,::rtl::OUString::createFromAscii("UID"));
911  		if(uidField != NULL)
912  		{
913  			if(uidField->type == kABStringProperty)
914  			{
915  				::rtl::OUString sUniqueIdentifier = CFStringToOUString( (CFStringRef) uidField->value );
916  				if (sUniqueIdentifier == sBookmark)
917  				{
918  					m_nRowPos = nRow;
919  					return sal_True;
920  				}
921  			}
922  		}
923  	}
924  	return sal_False;
925  }
926  // -------------------------------------------------------------------------
moveRelativeToBookmark(const Any & bookmark,sal_Int32 rows)927  sal_Bool SAL_CALL MacabResultSet::moveRelativeToBookmark(const  Any& bookmark, sal_Int32 rows) throw( SQLException,  RuntimeException)
928  {
929  	::osl::MutexGuard aGuard( m_aMutex );
930  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
931  
932  	sal_Int32 nRowSave = m_nRowPos;
933  
934  	if (moveToBookmark(bookmark))
935  	{
936  		sal_Int32 nRecords = m_aMacabRecords->size();
937  
938  		m_nRowPos += rows;
939  
940  		if (-1 < m_nRowPos && m_nRowPos < nRecords)
941  			return sal_True;
942  	}
943  
944  	m_nRowPos = nRowSave;
945  	return sal_False;
946  }
947  // -------------------------------------------------------------------------
compareBookmarks(const Any & firstItem,const Any & secondItem)948  sal_Int32 SAL_CALL MacabResultSet::compareBookmarks(const  Any& firstItem, const  Any& secondItem) throw( SQLException,  RuntimeException)
949  {
950  	::osl::MutexGuard aGuard( m_aMutex );
951  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
952  
953  	::rtl::OUString sFirst = comphelper::getString(firstItem);
954  	::rtl::OUString sSecond = comphelper::getString(secondItem);
955  
956  	if (sFirst < sSecond)
957  		return CompareBookmark::LESS;
958  	if (sFirst > sSecond)
959  		return CompareBookmark::GREATER;
960  	return CompareBookmark::EQUAL;
961  }
962  // -------------------------------------------------------------------------
hasOrderedBookmarks()963  sal_Bool SAL_CALL MacabResultSet::hasOrderedBookmarks() throw( SQLException,  RuntimeException)
964  {
965  	return sal_False;
966  }
967  // -------------------------------------------------------------------------
hashBookmark(const Any & bookmark)968  sal_Int32 SAL_CALL MacabResultSet::hashBookmark(const  Any& bookmark) throw( SQLException,  RuntimeException)
969  {
970  	::osl::MutexGuard aGuard( m_aMutex );
971  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
972  
973  	::rtl::OUString sBookmark = comphelper::getString(bookmark);
974  
975  	return sBookmark.hashCode();
976  }
977  // -------------------------------------------------------------------------
978  // XDeleteRows
deleteRows(const Sequence<Any> &)979  Sequence< sal_Int32 > SAL_CALL MacabResultSet::deleteRows(const  Sequence<  Any >&) throw( SQLException,  RuntimeException)
980  {
981  	::osl::MutexGuard aGuard( m_aMutex );
982  	checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
983  
984  	return Sequence< sal_Int32 >();
985  }
986  // -------------------------------------------------------------------------
createArrayHelper() const987  IPropertyArrayHelper* MacabResultSet::createArrayHelper() const
988  {
989  	Sequence< Property > aProps(6);
990  	Property* pProperties = aProps.getArray();
991  	sal_Int32 nPos = 0;
992  	DECL_PROP1IMPL(CURSORNAME,			::rtl::OUString) PropertyAttribute::READONLY);
993  	DECL_PROP0(FETCHDIRECTION,			sal_Int32);
994  	DECL_PROP0(FETCHSIZE,				sal_Int32);
995  	DECL_BOOL_PROP1IMPL(ISBOOKMARKABLE) PropertyAttribute::READONLY);
996  	DECL_PROP1IMPL(RESULTSETCONCURRENCY,sal_Int32) PropertyAttribute::READONLY);
997  	DECL_PROP1IMPL(RESULTSETTYPE,		sal_Int32) PropertyAttribute::READONLY);
998  
999  	return new OPropertyArrayHelper(aProps);
1000  }
1001  // -------------------------------------------------------------------------
getInfoHelper()1002  IPropertyArrayHelper & MacabResultSet::getInfoHelper()
1003  {
1004  	return *static_cast<MacabResultSet*>(this)->getArrayHelper();
1005  }
1006  // -------------------------------------------------------------------------
convertFastPropertyValue(Any &,Any &,sal_Int32 nHandle,const Any &)1007  sal_Bool MacabResultSet::convertFastPropertyValue(
1008  			Any &,
1009  			Any &,
1010  			sal_Int32 nHandle,
1011  			const Any& )
1012  				throw (::com::sun::star::lang::IllegalArgumentException)
1013  {
1014  	switch (nHandle)
1015  	{
1016  		case PROPERTY_ID_ISBOOKMARKABLE:
1017  		case PROPERTY_ID_CURSORNAME:
1018  		case PROPERTY_ID_RESULTSETCONCURRENCY:
1019  		case PROPERTY_ID_RESULTSETTYPE:
1020  			throw ::com::sun::star::lang::IllegalArgumentException();
1021  			break;
1022  		case PROPERTY_ID_FETCHDIRECTION:
1023  		case PROPERTY_ID_FETCHSIZE:
1024  		default:
1025  			;
1026  	}
1027  	return sal_False;
1028  }
1029  // -------------------------------------------------------------------------
setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any &)1030  void MacabResultSet::setFastPropertyValue_NoBroadcast(
1031  			sal_Int32 nHandle,
1032  			const Any& )
1033  				 throw (Exception)
1034  {
1035  	switch (nHandle)
1036  	{
1037  		case PROPERTY_ID_ISBOOKMARKABLE:
1038  		case PROPERTY_ID_CURSORNAME:
1039  		case PROPERTY_ID_RESULTSETCONCURRENCY:
1040  		case PROPERTY_ID_RESULTSETTYPE:
1041  			throw Exception();
1042  			break;
1043  		case PROPERTY_ID_FETCHDIRECTION:
1044  			break;
1045  		case PROPERTY_ID_FETCHSIZE:
1046  			break;
1047  		default:
1048  			;
1049  	}
1050  }
1051  // -------------------------------------------------------------------------
getFastPropertyValue(Any & _rValue,sal_Int32 nHandle) const1052  void MacabResultSet::getFastPropertyValue(
1053  			Any& _rValue,
1054  			sal_Int32 nHandle) const
1055  {
1056  	switch (nHandle)
1057  	{
1058  		case PROPERTY_ID_ISBOOKMARKABLE:
1059              _rValue <<= (sal_Bool)sal_False;
1060              break;
1061  		case PROPERTY_ID_CURSORNAME:
1062  		case PROPERTY_ID_RESULTSETCONCURRENCY:
1063  		case PROPERTY_ID_RESULTSETTYPE:
1064  		case PROPERTY_ID_FETCHDIRECTION:
1065  		case PROPERTY_ID_FETCHSIZE:
1066  			;
1067  	}
1068  }
1069  // -----------------------------------------------------------------------------
1070