xref: /AOO41X/main/mysqlc/source/mysqlc_resultset.cxx (revision 3d781bd6f416ae6c4e57144cf77d2e4a529be361) 
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 #include "mysqlc_propertyids.hxx"
23 #include "mysqlc_general.hxx"
24 #include "mysqlc_resultset.hxx"
25 #include "mysqlc_resultsetmetadata.hxx"
26 
27 #include <com/sun/star/sdbc/DataType.hpp>
28 #include <com/sun/star/beans/PropertyAttribute.hpp>
29 #include <com/sun/star/sdbcx/CompareBookmark.hpp>
30 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
31 #include <com/sun/star/sdbc/ResultSetType.hpp>
32 #include <com/sun/star/sdbc/FetchDirection.hpp>
33 #include <cppuhelper/typeprovider.hxx>
34 #include <com/sun/star/lang/DisposedException.hpp>
35 
36 using namespace connectivity::mysqlc;
37 using namespace cppu;
38 using namespace com::sun::star::uno;
39 using namespace com::sun::star::lang;
40 using namespace com::sun::star::beans;
41 using namespace com::sun::star::sdbc;
42 using namespace com::sun::star::sdbcx;
43 using namespace com::sun::star::container;
44 using namespace com::sun::star::io;
45 using namespace com::sun::star::util;
46 using ::osl::MutexGuard;
47 using ::rtl::OUString;
48 
49 #include <cppconn/resultset.h>
50 #include <cppconn/resultset_metadata.h>
51 
52 #include <stdio.h>
53 
54 
55 //	IMPLEMENT_SERVICE_INFO(OResultSet,"com.sun.star.sdbcx.OResultSet","com.sun.star.sdbc.ResultSet");
56 /* {{{ OResultSet::getImplementationName() -I- */
57 OUString SAL_CALL OResultSet::getImplementationName()
58 	throw (RuntimeException)
59 {
60 	OSL_TRACE("OResultSet::getImplementationName");
61     return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sdbcx.mysqlc.ResultSet" ) );
62 }
63 /* }}} */
64 
65 
66 /* {{{ OResultSet::getSupportedServiceNames() -I- */
67 Sequence< OUString > SAL_CALL OResultSet::getSupportedServiceNames()
68 	throw(RuntimeException)
69 {
70 	OSL_TRACE("OResultSet::getSupportedServiceNames");
71 	Sequence< OUString > aSupported(2);
72 	aSupported[0] = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sdbc.ResultSet" ) );
73 	aSupported[1] = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sdbcx.ResultSet" ) );
74 	return (aSupported);
75 }
76 /* }}} */
77 
78 
79 /* {{{ OResultSet::supportsService() -I- */
80 sal_Bool SAL_CALL OResultSet::supportsService(const OUString& _rServiceName)
81 	throw(RuntimeException)
82 {
83 	OSL_TRACE("OResultSet::supportsService");
84 	Sequence< OUString > aSupported(getSupportedServiceNames());
85 	const OUString* pSupported = aSupported.getConstArray();
86 	const OUString* pEnd = pSupported + aSupported.getLength();
87 	for (;pSupported != pEnd && !pSupported->equals(_rServiceName); ++pSupported) {}
88 
89 	return (pSupported != pEnd);
90 }
91 /* }}} */
92 
93 
94 /* {{{ OResultSet::OResultSet() -I- */
95 OResultSet::OResultSet(OCommonStatement * pStmt, sql::ResultSet * result, rtl_TextEncoding _encoding )
96 	: OResultSet_BASE(m_aMutex)
97 	,OPropertySetHelper(OResultSet_BASE::rBHelper)
98 	,m_aStatement((OWeakObject*)pStmt)
99 	,m_xMetaData(NULL)
100 	,m_result(result)
101     ,fieldCount( 0 )
102     ,m_encoding( _encoding )
103 {
104 	OSL_TRACE("OResultSet::OResultSet");
105 	try {
106 		sql::ResultSetMetaData * rs_meta = m_result->getMetaData();
107 		fieldCount = rs_meta->getColumnCount();
108 	} catch (sql::SQLException &e) {
109         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
110 	}
111 }
112 /* }}} */
113 
114 
115 /* {{{ OResultSet::~OResultSet() -I- */
116 OResultSet::~OResultSet()
117 {
118 	OSL_TRACE("OResultSet::~OResultSet");
119 }
120 /* }}} */
121 
122 
123 /* {{{ OResultSet::disposing() -I- */
124 void OResultSet::disposing()
125 {
126 	OSL_TRACE("OResultSet::disposing");
127 	OPropertySetHelper::disposing();
128 
129 	MutexGuard aGuard(m_aMutex);
130 
131 	m_aStatement = NULL;
132 	m_xMetaData  = NULL;
133 }
134 /* }}} */
135 
136 
137 /* {{{ OResultSet::queryInterface() -I- */
138 Any SAL_CALL OResultSet::queryInterface(const Type & rType)
139 	throw(RuntimeException)
140 {
141 	OSL_TRACE("OResultSet::queryInterface");
142 	Any aRet = OPropertySetHelper::queryInterface(rType);
143 	if (!aRet.hasValue()) {
144 		aRet = OResultSet_BASE::queryInterface(rType);
145 	}
146 	return aRet;
147 }
148 /* }}} */
149 
150 
151 /* {{{ OResultSet::getTypes() -I- */
152 Sequence< Type > SAL_CALL OResultSet::getTypes()
153 	throw(RuntimeException)
154 {
155 	OSL_TRACE("OResultSet::getTypes");
156 	OTypeCollection aTypes(	::getCppuType((const  Reference< XMultiPropertySet > *) NULL),
157 												::getCppuType((const Reference< XFastPropertySet > *) NULL),
158 												::getCppuType((const Reference< XPropertySet > *) NULL));
159 
160 	return concatSequences(aTypes.getTypes(), OResultSet_BASE::getTypes());
161 }
162 /* }}} */
163 
164 
165 /* {{{ OResultSet::findColumn() -I- */
166 sal_Int32 SAL_CALL OResultSet::findColumn(const OUString& columnName)
167 	throw(SQLException, RuntimeException)
168 {
169 	OSL_TRACE("OResultSet::findColumn");
170 	MutexGuard aGuard(m_aMutex);
171 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
172 
173 	try {
174 		// find the first column with the name columnName
175 		sql::ResultSetMetaData * meta = m_result->getMetaData();
176 		for (sal_uInt32 i = 1; i <= fieldCount; i++) {
177 			if (columnName.equalsIgnoreAsciiCaseAscii(meta->getColumnName(i).c_str())) {
178 				/* SDBC knows them indexed from 1 */
179 				return i;
180 			}
181 		}
182 	} catch (sql::SQLException &e) {
183         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
184 	}
185 	return 0;
186 }
187 /* }}} */
188 
189 
190 /* {{{ OResultSet::getBinaryStream() -U- */
191 Reference< XInputStream > SAL_CALL OResultSet::getBinaryStream(sal_Int32 column)
192 	throw(SQLException, RuntimeException)
193 {
194 	OSL_TRACE("OResultSet::getBinaryStream");
195 	MutexGuard aGuard(m_aMutex);
196 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
197 	checkColumnIndex(column);
198 
199 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::getBinaryStream", *this);
200 	return NULL;
201 }
202 /* }}} */
203 
204 
205 /* {{{ OResultSet::getCharacterStream() -U- */
206 Reference< XInputStream > SAL_CALL OResultSet::getCharacterStream(sal_Int32 column)
207 	throw(SQLException, RuntimeException)
208 {
209 	OSL_TRACE("OResultSet::getCharacterStream");
210 	MutexGuard aGuard(m_aMutex);
211 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
212 	checkColumnIndex(column);
213 
214 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::getCharacterStream", *this);
215 	return NULL;
216 }
217 /* }}} */
218 
219 
220 /* {{{ OResultSet::getBoolean() -I- */
221 sal_Bool SAL_CALL OResultSet::getBoolean(sal_Int32 column)
222 	throw(SQLException, RuntimeException)
223 {
224 	OSL_TRACE("OResultSet::getBoolean");
225 	MutexGuard aGuard(m_aMutex);
226 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
227 
228 	checkColumnIndex(column);
229 	try {
230 		return m_result->getBoolean(column)? sal_True:sal_False;
231 	} catch (sql::SQLException &e) {
232         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
233 	}
234 	return sal_False;
235 #if 0
236 	OUString str = getString(column);
237 	switch (str[0]) {
238 		case '1':
239 		case 't':
240 		case 'T':
241 		case 'y':
242 		case 'Y':
243 			return sal_True;
244 	}
245 	return sal_False;
246 #endif
247 }
248 /* }}} */
249 
250 
251 /* {{{ OResultSet::getByte() -I- */
252 sal_Int8 SAL_CALL OResultSet::getByte(sal_Int32 column)
253 	throw(SQLException, RuntimeException)
254 {
255 	OSL_TRACE("OResultSet::getByte");
256 	MutexGuard aGuard(m_aMutex);
257 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
258 
259 	checkColumnIndex(column);
260 	try {
261 		return m_result->getInt(column);
262 	} catch (sql::SQLException &e) {
263         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
264 	}
265 	return 0; // fool compiler
266 }
267 /* }}} */
268 
269 
270 /* {{{ OResultSet::getBytes() -I- */
271 Sequence< sal_Int8 > SAL_CALL OResultSet::getBytes(sal_Int32 column)
272 	throw(SQLException, RuntimeException)
273 {
274 	OSL_TRACE("OResultSet::getBytes");
275 
276 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
277 	MutexGuard aGuard(m_aMutex);
278 
279 
280 	sql::SQLString val = m_result->getString(column);
281 	if (!val.length()) {
282 		return Sequence< sal_Int8>();
283 	} else {
284 		return Sequence< sal_Int8 > ((sal_Int8*)val.c_str(), val.length());
285 	}
286 }
287 /* }}} */
288 
289 
290 /* {{{ OResultSet::getDate() -I- */
291 Date SAL_CALL OResultSet::getDate(sal_Int32 column)
292 	throw(SQLException, RuntimeException)
293 {
294 	OSL_TRACE("OResultSet::getDate");
295 	MutexGuard aGuard(m_aMutex);
296 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
297 	checkColumnIndex(column);
298 
299 	Date d;
300 	try {
301 		OUString dateString = getString(column);
302 		OUString token;
303 		sal_Int32 nIndex = 0, i=0;
304 
305 		do {
306 			token = dateString.getToken (0, '-', nIndex);
307 			switch (i) {
308 				case 0:
309 					d.Year =  static_cast<sal_uInt16>(token.toInt32(10));
310 					break;
311 				case 1:
312 					d.Month =  static_cast<sal_uInt16>(token.toInt32(10));
313 					break;
314 				case 2:
315 					d.Day =  static_cast<sal_uInt16>(token.toInt32(10));
316 					break;
317 				default:;
318 			}
319 			i++;
320 		} while (nIndex >= 0);
321 	} catch (sql::SQLException &e) {
322         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
323 	}
324 	return d;
325 }
326 /* }}} */
327 
328 
329 /* {{{ OResultSet::getDouble() -I- */
330 double SAL_CALL OResultSet::getDouble(sal_Int32 column)
331 	throw(SQLException, RuntimeException)
332 {
333 	OSL_TRACE("OResultSet::getDouble");
334 	MutexGuard aGuard(m_aMutex);
335 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
336 
337 	checkColumnIndex(column);
338 	try {
339 		return m_result->getDouble(column);
340 	} catch (sql::SQLException &e) {
341         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
342 	}
343 	return 0.0; // fool compiler
344 }
345 /* }}} */
346 
347 
348 /* {{{ OResultSet::getFloat() -I- */
349 float SAL_CALL OResultSet::getFloat(sal_Int32 column)
350 	throw(SQLException, RuntimeException)
351 {
352 	OSL_TRACE("OResultSet::getFloat");
353 	MutexGuard aGuard(m_aMutex);
354 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
355 
356 	checkColumnIndex(column);
357 	try {
358 		return m_result->getDouble(column);
359 	} catch (sql::SQLException &e) {
360         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
361 	}
362 	return 0.0; // fool compiler
363 }
364 /* }}} */
365 
366 
367 /* {{{ OResultSet::getInt() -I- */
368 sal_Int32 SAL_CALL OResultSet::getInt(sal_Int32 column)
369 	throw(SQLException, RuntimeException)
370 {
371 	OSL_TRACE("OResultSet::getInt");
372 	MutexGuard aGuard(m_aMutex);
373 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
374 
375 	checkColumnIndex(column);
376 	try {
377 		return m_result->getInt(column);
378 	} catch (sql::SQLException &e) {
379         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
380 	}
381 	return 0; // fool compiler
382 }
383 /* }}} */
384 
385 
386 /* {{{ OResultSet::getRow() -I- */
387 sal_Int32 SAL_CALL OResultSet::getRow()
388 	throw(SQLException, RuntimeException)
389 {
390 	OSL_TRACE("OResultSet::getRow");
391 	MutexGuard aGuard(m_aMutex);
392 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
393 
394 	try {
395 		return m_result->getRow();
396 	} catch (sql::SQLException &e) {
397         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
398 	}
399 	return 0; // fool compiler
400 }
401 /* }}} */
402 
403 
404 /* {{{ OResultSet::getLong() -I- */
405 sal_Int64 SAL_CALL OResultSet::getLong(sal_Int32 column)
406 	throw(SQLException, RuntimeException)
407 {
408 	OSL_TRACE("OResultSet::getLong");
409 	MutexGuard aGuard(m_aMutex);
410 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
411 
412 	checkColumnIndex(column);
413 	try {
414 		return m_result->getInt64(column);
415 	} catch (sql::SQLException &e) {
416         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
417 	}
418 	return 0; // fool compiler
419 }
420 /* }}} */
421 
422 
423 /* {{{ OResultSet::getMetaData() -I- */
424 Reference< XResultSetMetaData > SAL_CALL OResultSet::getMetaData()
425 	throw(SQLException, RuntimeException)
426 {
427 	OSL_TRACE("OResultSet::getMetaData");
428 	MutexGuard aGuard(m_aMutex);
429 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
430 	try {
431 		if (!m_xMetaData.is()) {
432 			m_xMetaData = new OResultSetMetaData(m_result->getMetaData(), m_encoding);
433 		}
434 	} catch (sql::MethodNotImplementedException) {
435 		mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::getMetaData", *this);
436 	} catch (sql::SQLException &e) {
437         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
438 	}
439 	return m_xMetaData;
440 }
441 /* }}} */
442 
443 
444 /* {{{ OResultSet::getArray() -U- */
445 Reference< XArray > SAL_CALL OResultSet::getArray(sal_Int32 column)
446 	throw(SQLException, RuntimeException)
447 {
448 	OSL_TRACE("OResultSet::getArray");
449 	MutexGuard aGuard(m_aMutex);
450 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
451 	checkColumnIndex(column);
452 
453 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::getArray", *this);
454 	return NULL;
455 }
456 /* }}} */
457 
458 
459 /* {{{ OResultSet::getClob() -U- */
460 Reference< XClob > SAL_CALL OResultSet::getClob(sal_Int32 column)
461 	throw(SQLException, RuntimeException)
462 {
463 	OSL_TRACE("OResultSet::getClob");
464 	MutexGuard aGuard(m_aMutex);
465 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
466 	checkColumnIndex(column);
467 
468 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::getClob", *this);
469 	return NULL;
470 }
471 /* }}} */
472 
473 
474 /* {{{ OResultSet::getBlob() -U- */
475 Reference< XBlob > SAL_CALL OResultSet::getBlob(sal_Int32 column)
476 	throw(SQLException, RuntimeException)
477 {
478 	OSL_TRACE("OResultSet::getBlob");
479 	MutexGuard aGuard(m_aMutex);
480 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
481 	checkColumnIndex(column);
482 
483 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::getBlob", *this);
484 	return NULL;
485 }
486 /* }}} */
487 
488 
489 /* {{{ OResultSet::getRef() -U- */
490 Reference< XRef > SAL_CALL OResultSet::getRef(sal_Int32 column)
491 	throw(SQLException, RuntimeException)
492 {
493 	OSL_TRACE("OResultSet::getRef");
494 	MutexGuard aGuard(m_aMutex);
495 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
496 	checkColumnIndex(column);
497 
498 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::getRef", *this);
499 	return NULL;
500 }
501 /* }}} */
502 
503 
504 /* {{{ OResultSet::getObject() -U- */
505 Any SAL_CALL OResultSet::getObject(sal_Int32 column, const Reference< XNameAccess >& /* typeMap */)
506 	throw(SQLException, RuntimeException)
507 {
508 	OSL_TRACE("OResultSet::getObject");
509 	MutexGuard aGuard(m_aMutex);
510 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
511 	checkColumnIndex(column);
512 
513 	Any aRet= Any();
514 
515 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::getObject", *this);
516 	return aRet;
517 }
518 /* }}} */
519 
520 
521 /* {{{ OResultSet::getShort() -I- */
522 sal_Int16 SAL_CALL OResultSet::getShort(sal_Int32 column)
523 	throw(SQLException, RuntimeException)
524 {
525 	OSL_TRACE("OResultSet::getShort");
526 	MutexGuard aGuard(m_aMutex);
527 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
528 
529 	try {
530 		return (sal_Int16) m_result->getInt(column);
531 	} catch (sql::SQLException &e) {
532         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
533 	}
534 	return 0; // fool compiler
535 }
536 /* }}} */
537 
538 
539 /* {{{ OResultSet::getString() -I- */
540 OUString SAL_CALL OResultSet::getString(sal_Int32 column)
541 	throw(SQLException, RuntimeException)
542 {
543 	OSL_TRACE("OResultSet::getString");
544 	MutexGuard aGuard(m_aMutex);
545 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
546 
547 	checkColumnIndex(column);
548 
549 	try {
550 		sql::SQLString val = m_result->getString(column);
551 		if (!m_result->wasNull()) {
552 			return OUString( val.c_str(), val.length(), m_encoding );
553 		} else {
554 			return OUString();
555 		}
556 	} catch (sql::SQLException &e) {
557         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
558 	}
559 	return OUString(); // fool compiler
560 }
561 /* }}} */
562 
563 
564 /* {{{ OResultSet::getTime() -I- */
565 Time SAL_CALL OResultSet::getTime(sal_Int32 column)
566 	throw(SQLException, RuntimeException)
567 {
568 	OSL_TRACE("OResultSet::getTime");
569 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
570 	MutexGuard aGuard(m_aMutex);
571 
572 	checkColumnIndex(column);
573 	Time t;
574 	OUString timeString = getString(column);
575 	OUString token;
576 	sal_Int32 nIndex, i=0;
577 
578 	nIndex = timeString.indexOf(' ') + 1;
579 
580 	do {
581 		token = timeString.getToken (0, ':', nIndex);
582 		switch (i) {
583 			case 0:
584 				t.Hours =  static_cast<sal_uInt16>(token.toInt32(10));
585 				break;
586 			case 1:
587 				t.Minutes =  static_cast<sal_uInt16>(token.toInt32(10));
588 				break;
589 			case 2:
590 				t.Seconds =  static_cast<sal_uInt16>(token.toInt32(10));
591 				break;
592 		}
593 		i++;
594 	} while (nIndex >= 0);
595 
596 	return t;
597 }
598 /* }}} */
599 
600 
601 /* {{{ OResultSet::getTimestamp() -I- */
602 DateTime SAL_CALL OResultSet::getTimestamp(sal_Int32 column)
603 	throw(SQLException, RuntimeException)
604 {
605 	OSL_TRACE("OResultSet::getTimestamp");
606 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
607 	MutexGuard aGuard(m_aMutex);
608 
609 	checkColumnIndex(column);
610 	DateTime dt;
611 	Date d = getDate(column);
612 	Time t = getTime(column);
613 
614 	dt.Year = d.Year;
615 	dt.Month = d.Month;
616 	dt.Day = d.Day;
617 	dt.Hours = t.Hours;
618 	dt.Minutes = t.Minutes;
619 	dt.Seconds = t.Seconds;
620 	return dt;
621 }
622 /* }}} */
623 
624 
625 /* {{{ OResultSet::isBeforeFirst() -I- */
626 sal_Bool SAL_CALL OResultSet::isBeforeFirst()
627 	throw(SQLException, RuntimeException)
628 {
629 	OSL_TRACE("OResultSet::isBeforeFirst");
630 	MutexGuard aGuard(m_aMutex);
631 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
632 
633 	try {
634 		return m_result->isBeforeFirst()? sal_True:sal_False;
635 	} catch (sql::SQLException &e) {
636         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
637 	}
638 	return sal_False; //fool
639 }
640 /* }}} */
641 
642 
643 /* {{{ OResultSet::isAfterLast() -I- */
644 sal_Bool SAL_CALL OResultSet::isAfterLast()
645 	throw(SQLException, RuntimeException)
646 {
647 	OSL_TRACE("OResultSet::isAfterLast");
648 	MutexGuard aGuard(m_aMutex);
649 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
650 
651 	try {
652 		return m_result->isAfterLast()? sal_True:sal_False;
653 	} catch (sql::SQLException &e) {
654         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
655 	}
656 	return sal_False; //fool
657 }
658 /* }}} */
659 
660 
661 /* {{{ OResultSet::isFirst() -I- */
662 sal_Bool SAL_CALL OResultSet::isFirst()
663 	throw(SQLException, RuntimeException)
664 {
665 	OSL_TRACE("OResultSet::isFirst");
666 	MutexGuard aGuard(m_aMutex);
667 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
668 
669 	try {
670 		return m_result->isFirst();
671 	} catch (sql::SQLException &e) {
672         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
673 	}
674 	return sal_False; //fool
675 }
676 /* }}} */
677 
678 
679 /* {{{ OResultSet::isLast() -I- */
680 sal_Bool SAL_CALL OResultSet::isLast()
681 	throw(SQLException, RuntimeException)
682 {
683 	OSL_TRACE("OResultSet::isLast");
684 	MutexGuard aGuard(m_aMutex);
685 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
686 
687 	try {
688 		return m_result->isLast()? sal_True:sal_False;
689 	} catch (sql::SQLException &e) {
690         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
691 	}
692 	return sal_False; //fool
693 }
694 /* }}} */
695 
696 
697 /* {{{ OResultSet::beforeFirst() -I- */
698 void SAL_CALL OResultSet::beforeFirst()
699 	throw(SQLException, RuntimeException)
700 {
701 	OSL_TRACE("OResultSet::beforeFirst");
702 	MutexGuard aGuard(m_aMutex);
703 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
704 
705 	try {
706 		m_result->beforeFirst();
707 	} catch (sql::SQLException &e) {
708         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
709 	}
710 }
711 /* }}} */
712 
713 
714 /* {{{ OResultSet::afterLast() -I- */
715 void SAL_CALL OResultSet::afterLast()
716 	throw(SQLException, RuntimeException)
717 {
718 	OSL_TRACE("OResultSet::afterLast");
719 	MutexGuard aGuard(m_aMutex);
720 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
721 
722 	try {
723 		m_result->afterLast();
724 	} catch (sql::SQLException &e) {
725         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
726 	}
727 }
728 /* }}} */
729 
730 
731 /* {{{ OResultSet::close() -I- */
732 void SAL_CALL OResultSet::close() throw(SQLException, RuntimeException)
733 {
734 	OSL_TRACE("OResultSet::close");
735 	MutexGuard aGuard(m_aMutex);
736 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
737 
738 	try {
739 		m_result->close();
740 	} catch (sql::SQLException &e) {
741         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
742 	}
743 
744 	dispose();
745 }
746 /* }}} */
747 
748 
749 /* {{{ OResultSet::first() -I- */
750 sal_Bool SAL_CALL OResultSet::first() throw(SQLException, RuntimeException)
751 {
752 	OSL_TRACE("OResultSet::first");
753 	MutexGuard aGuard(m_aMutex);
754 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
755 
756 	try {
757 		return m_result->first()? sal_True:sal_False;
758 	} catch (sql::SQLException &e) {
759         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
760 	}
761 	return sal_False; //fool
762 }
763 /* }}} */
764 
765 
766 /* {{{ OResultSet::last() -I- */
767 sal_Bool SAL_CALL OResultSet::last()
768 	throw(SQLException, RuntimeException)
769 {
770 	OSL_TRACE("OResultSet::last");
771 	MutexGuard aGuard(m_aMutex);
772 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
773 
774 	try {
775 		return m_result->last()? sal_True:sal_False;
776 	} catch (sql::SQLException &e) {
777         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
778 	}
779 	return sal_False; //fool
780 }
781 /* }}} */
782 
783 
784 /* {{{ OResultSet::absolute() -I- */
785 sal_Bool SAL_CALL OResultSet::absolute(sal_Int32 row)
786 	throw(SQLException, RuntimeException)
787 {
788 	OSL_TRACE("OResultSet::absolute");
789 	MutexGuard aGuard(m_aMutex);
790 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
791 
792 	try {
793 		return m_result->absolute(row)? sal_True:sal_False;
794 	} catch (sql::SQLException &e) {
795         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
796 	}
797 	return sal_False; //fool
798 }
799 /* }}} */
800 
801 
802 /* {{{ OResultSet::relative() -I- */
803 sal_Bool SAL_CALL OResultSet::relative(sal_Int32 row)
804 	throw(SQLException, RuntimeException)
805 {
806 	OSL_TRACE("OResultSet::relative");
807 	MutexGuard aGuard(m_aMutex);
808 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
809 
810 	try {
811 		return m_result->relative(row)? sal_True:sal_False;
812 	} catch (sql::SQLException &e) {
813         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
814 	}
815 	return sal_False; //fool
816 }
817 /* }}} */
818 
819 
820 /* {{{ OResultSet::previous() -I- */
821 sal_Bool SAL_CALL OResultSet::previous()
822 	throw(SQLException, RuntimeException)
823 {
824 	OSL_TRACE("OResultSet::previous");
825 	MutexGuard aGuard(m_aMutex);
826 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
827 
828 	try {
829 		return m_result->previous()? sal_True:sal_False;
830 	} catch (sql::SQLException &e) {
831         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
832 	}
833 	return sal_False; //fool
834 }
835 /* }}} */
836 
837 
838 /* {{{ OResultSet::getStatement() -I- */
839 Reference< XInterface > SAL_CALL OResultSet::getStatement()
840 	throw(SQLException, RuntimeException)
841 {
842 	OSL_TRACE("OResultSet::getStatement");
843 	MutexGuard aGuard(m_aMutex);
844 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
845 
846 	return m_aStatement.get();
847 }
848 /* }}} */
849 
850 
851 /* {{{ OResultSet::rowDeleted() -I- */
852 sal_Bool SAL_CALL OResultSet::rowDeleted()
853 	throw(SQLException, RuntimeException)
854 {
855 	OSL_TRACE("OResultSet::rowDeleted");
856 	MutexGuard aGuard(m_aMutex);
857 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
858 
859 	return sal_False;
860 }
861 /* }}} */
862 
863 
864 /* {{{ OResultSet::rowInserted() -I- */
865 sal_Bool SAL_CALL OResultSet::rowInserted()
866 	throw(SQLException, RuntimeException)
867 {
868 	OSL_TRACE("OResultSet::rowInserted");
869 	MutexGuard aGuard(m_aMutex);
870 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
871 
872 	return sal_False;
873 }
874 /* }}} */
875 
876 
877 /* {{{ OResultSet::rowUpdated() -I- */
878 sal_Bool SAL_CALL OResultSet::rowUpdated()
879 	throw(SQLException, RuntimeException)
880 {
881 	OSL_TRACE("OResultSet::rowUpdated");
882 	MutexGuard aGuard(m_aMutex);
883 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
884 
885 	return sal_False;
886 }
887 /* }}} */
888 
889 
890 /* {{{ OResultSet::next() -I- */
891 sal_Bool SAL_CALL OResultSet::next()
892 	throw(SQLException, RuntimeException)
893 {
894 	OSL_TRACE("OResultSet::next");
895 	MutexGuard aGuard(m_aMutex);
896 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
897 
898 	try {
899 		return m_result->next()? sal_True:sal_False;
900 	} catch (sql::SQLException &e) {
901         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
902 	}
903 	return sal_False; //fool
904 }
905 /* }}} */
906 
907 
908 /* {{{ OResultSet::wasNull() -I- */
909 sal_Bool SAL_CALL OResultSet::wasNull()
910 	throw(SQLException, RuntimeException)
911 {
912 	OSL_TRACE("OResultSet::wasNull");
913 	MutexGuard aGuard(m_aMutex);
914 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
915 
916 	try {
917 		return m_result->wasNull()? sal_True:sal_False;
918 	} catch (sql::SQLException &e) {
919         mysqlc_sdbc_driver::translateAndThrow(e, *this, m_encoding);
920 	}
921 	return sal_False; //fool
922 }
923 /* }}} */
924 
925 
926 /* {{{ OResultSet::cancel() -I- */
927 void SAL_CALL OResultSet::cancel()
928 	throw(RuntimeException)
929 {
930 	OSL_TRACE("OResultSet::cancel");
931 	MutexGuard aGuard(m_aMutex);
932 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
933 }
934 /* }}} */
935 
936 
937 /* {{{ OResultSet::clearWarnings() -I- */
938 void SAL_CALL OResultSet::clearWarnings()
939 	throw(SQLException, RuntimeException)
940 {
941 	OSL_TRACE("OResultSet::clearWarnings");
942 }
943 /* }}} */
944 
945 
946 /* {{{ OResultSet::getWarnings() -I- */
947 Any SAL_CALL OResultSet::getWarnings()
948 	throw(SQLException, RuntimeException)
949 {
950 	OSL_TRACE("OResultSet::getWarnings");
951 	Any aRet= Any();
952 	return aRet;
953 }
954 /* }}} */
955 
956 
957 /* {{{ OResultSet::insertRow() -I- */
958 void SAL_CALL OResultSet::insertRow()
959 	throw(SQLException, RuntimeException)
960 {
961 	OSL_TRACE("OResultSet::insertRow");
962 	MutexGuard aGuard(m_aMutex);
963 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
964 	// you only have to implement this if you want to insert new rows
965     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::insertRow", *this);
966 }
967 /* }}} */
968 
969 
970 /* {{{ OResultSet::updateRow() -I- */
971 void SAL_CALL OResultSet::updateRow()
972 	throw(SQLException, RuntimeException)
973 {
974 	OSL_TRACE("OResultSet::updateRow");
975 	MutexGuard aGuard(m_aMutex);
976 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
977 
978 	// only when you allow updates
979     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateRow", *this);
980 }
981 /* }}} */
982 
983 
984 /* {{{ OResultSet::deleteRow() -I- */
985 void SAL_CALL OResultSet::deleteRow()
986 	throw(SQLException, RuntimeException)
987 {
988 	OSL_TRACE("OResultSet::deleteRow");
989 	MutexGuard aGuard(m_aMutex);
990 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
991     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::deleteRow", *this);
992 }
993 /* }}} */
994 
995 
996 /* {{{ OResultSet::cancelRowUpdates() -I- */
997 void SAL_CALL OResultSet::cancelRowUpdates()
998 	throw(SQLException, RuntimeException)
999 {
1000 	OSL_TRACE("OResultSet::cancelRowUpdates");
1001 	MutexGuard aGuard(m_aMutex);
1002 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1003     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::cancelRowUpdates", *this);
1004 }
1005 /* }}} */
1006 
1007 
1008 /* {{{ OResultSet::moveToInsertRow() -I- */
1009 void SAL_CALL OResultSet::moveToInsertRow()
1010 	throw(SQLException, RuntimeException)
1011 {
1012 	OSL_TRACE("OResultSet::moveToInsertRow");
1013 	MutexGuard aGuard(m_aMutex);
1014 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1015 
1016 	// only when you allow insert's
1017     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::moveToInsertRow", *this);
1018 }
1019 /* }}} */
1020 
1021 
1022 /* {{{ OResultSet::moveToCurrentRow() -I- */
1023 void SAL_CALL OResultSet::moveToCurrentRow()
1024 	throw(SQLException, RuntimeException)
1025 {
1026 	OSL_TRACE("OResultSet::moveToCurrentRow");
1027 	MutexGuard aGuard(m_aMutex);
1028 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1029 }
1030 /* }}} */
1031 
1032 
1033 /* {{{ OResultSet::updateNull() -U- */
1034 void SAL_CALL OResultSet::updateNull(sal_Int32 column)
1035 	throw(SQLException, RuntimeException)
1036 {
1037 	OSL_TRACE("OResultSet::updateNull");
1038 	MutexGuard aGuard(m_aMutex);
1039 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1040 	checkColumnIndex(column);
1041 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateNull", *this);
1042 }
1043 /* }}} */
1044 
1045 
1046 /* {{{ OResultSet::updateBoolean() -U- */
1047 void SAL_CALL OResultSet::updateBoolean(sal_Int32 column, sal_Bool /* x */)
1048 	throw(SQLException, RuntimeException)
1049 {
1050 	OSL_TRACE("OResultSet::updateBoolean");
1051 	MutexGuard aGuard(m_aMutex);
1052 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1053 	checkColumnIndex(column);
1054 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateBoolean", *this);
1055 }
1056 /* }}} */
1057 
1058 
1059 /* {{{ OResultSet::updateByte() -U- */
1060 void SAL_CALL OResultSet::updateByte(sal_Int32 column, sal_Int8 /* x */)
1061 	throw(SQLException, RuntimeException)
1062 {
1063 	OSL_TRACE("OResultSet::updateByte");
1064 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1065 	MutexGuard aGuard(m_aMutex);
1066 	checkColumnIndex(column);
1067 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateByte", *this);
1068 }
1069 /* }}} */
1070 
1071 
1072 /* {{{ OResultSet::updateShort() -U- */
1073 void SAL_CALL OResultSet::updateShort(sal_Int32 column, sal_Int16 /* x */)
1074 	throw(SQLException, RuntimeException)
1075 {
1076 	OSL_TRACE("OResultSet::updateShort");
1077 	MutexGuard aGuard(m_aMutex);
1078 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1079 	checkColumnIndex(column);
1080 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateShort", *this);
1081 }
1082 /* }}} */
1083 
1084 
1085 /* {{{ OResultSet::updateInt() -U- */
1086 void SAL_CALL OResultSet::updateInt(sal_Int32 column, sal_Int32 /* x */)
1087 	throw(SQLException, RuntimeException)
1088 {
1089 	OSL_TRACE("OResultSet::updateInt");
1090 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1091 	MutexGuard aGuard(m_aMutex);
1092 	checkColumnIndex(column);
1093 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateInt", *this);
1094 }
1095 /* }}} */
1096 
1097 
1098 /* {{{ OResultSet::updateLong() -U- */
1099 void SAL_CALL OResultSet::updateLong(sal_Int32 column, sal_Int64 /* x */)
1100 	throw(SQLException, RuntimeException)
1101 {
1102 	OSL_TRACE("OResultSet::updateLong");
1103 	MutexGuard aGuard(m_aMutex);
1104 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1105 	checkColumnIndex(column);
1106 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateLong", *this);
1107 }
1108 /* }}} */
1109 
1110 
1111 /* {{{ OResultSet::updateFloat() -U- */
1112 void SAL_CALL OResultSet::updateFloat(sal_Int32 column, float /* x */)
1113 	throw(SQLException, RuntimeException)
1114 {
1115 	OSL_TRACE("OResultSet::updateFloat");
1116 	MutexGuard aGuard(m_aMutex);
1117 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1118 	checkColumnIndex(column);
1119 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateFloat", *this);
1120 }
1121 /* }}} */
1122 
1123 
1124 /* {{{ OResultSet::updateDouble() -U- */
1125 void SAL_CALL OResultSet::updateDouble(sal_Int32 column, double /* x */)
1126 	throw(SQLException, RuntimeException)
1127 {
1128 	OSL_TRACE("OResultSet::updateDouble");
1129 	MutexGuard aGuard(m_aMutex);
1130 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1131 	checkColumnIndex(column);
1132 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateDouble", *this);
1133 }
1134 /* }}} */
1135 
1136 
1137 /* {{{ OResultSet::updateString() -U- */
1138 void SAL_CALL OResultSet::updateString(sal_Int32 column, const OUString& /* x */)
1139 	throw(SQLException, RuntimeException)
1140 {
1141 	OSL_TRACE("OResultSet::updateString");
1142 	MutexGuard aGuard(m_aMutex);
1143 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1144 	checkColumnIndex(column);
1145 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateString", *this);
1146 }
1147 /* }}} */
1148 
1149 
1150 /* {{{ OResultSet::updateBytes() -U- */
1151 void SAL_CALL OResultSet::updateBytes(sal_Int32 column, const Sequence< sal_Int8 >& /* x */)
1152 	throw(SQLException, RuntimeException)
1153 {
1154 	OSL_TRACE("OResultSet::updateBytes");
1155 	MutexGuard aGuard(m_aMutex);
1156 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1157 	checkColumnIndex(column);
1158 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateBytes", *this);
1159 }
1160 /* }}} */
1161 
1162 
1163 /* {{{ OResultSet::updateDate() -U- */
1164 void SAL_CALL OResultSet::updateDate(sal_Int32 column, const Date& /* x */)
1165 	throw(SQLException, RuntimeException)
1166 {
1167 	OSL_TRACE("OResultSet::updateDate");
1168 	MutexGuard aGuard(m_aMutex);
1169 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1170 	checkColumnIndex(column);
1171 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateDate", *this);
1172 }
1173 /* }}} */
1174 
1175 
1176 /* {{{ OResultSet::updateTime() -U- */
1177 void SAL_CALL OResultSet::updateTime(sal_Int32 column, const Time& /* x */)
1178 	throw(SQLException, RuntimeException)
1179 {
1180 	OSL_TRACE("OResultSet::updateTime");
1181 	MutexGuard aGuard(m_aMutex);
1182 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1183 	checkColumnIndex(column);
1184 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateTime", *this);
1185 }
1186 /* }}} */
1187 
1188 
1189 /* {{{ OResultSet::updateTimestamp() -U- */
1190 void SAL_CALL OResultSet::updateTimestamp(sal_Int32 column, const DateTime& /* x */)
1191 	throw(SQLException, RuntimeException)
1192 {
1193 	OSL_TRACE("OResultSet::updateTimestamp");
1194 	MutexGuard aGuard(m_aMutex);
1195 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1196 	checkColumnIndex(column);
1197 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateTimestamp", *this);
1198 }
1199 /* }}} */
1200 
1201 
1202 /* {{{ OResultSet::updateBinaryStream() -U- */
1203 void SAL_CALL OResultSet::updateBinaryStream(sal_Int32 column, const Reference< XInputStream >& /* x */,
1204 											sal_Int32 /* length */)
1205 	throw(SQLException, RuntimeException)
1206 {
1207 	OSL_TRACE("OResultSet::updateBinaryStream");
1208 	MutexGuard aGuard(m_aMutex);
1209 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1210 	checkColumnIndex(column);
1211 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateBinaryStream", *this);
1212 }
1213 /* }}} */
1214 
1215 
1216 /* {{{ OResultSet::updateCharacterStream() -U- */
1217 void SAL_CALL OResultSet::updateCharacterStream(sal_Int32 column, const Reference< XInputStream >& /* x */,
1218 												sal_Int32 /* length */)
1219 	throw(SQLException, RuntimeException)
1220 {
1221 	OSL_TRACE("OResultSet::updateCharacterStream");
1222 	MutexGuard aGuard(m_aMutex);
1223 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1224 	checkColumnIndex(column);
1225 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateCharacterStream", *this);
1226 }
1227 /* }}} */
1228 
1229 
1230 /* {{{ OResultSet::refreshRow() -U- */
1231 void SAL_CALL OResultSet::refreshRow()
1232 	throw(SQLException, RuntimeException)
1233 {
1234 	OSL_TRACE("OResultSet::refreshRow");
1235 	MutexGuard aGuard(m_aMutex);
1236 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1237 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::refreshRow", *this);
1238 }
1239 /* }}} */
1240 
1241 
1242 /* {{{ OResultSet::updateObject() -U- */
1243 void SAL_CALL OResultSet::updateObject(sal_Int32 column, const Any& /* x */)
1244 	throw(SQLException, RuntimeException)
1245 {
1246 	OSL_TRACE("OResultSet::updateObject");
1247 	MutexGuard aGuard(m_aMutex);
1248 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1249 	checkColumnIndex(column);
1250 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateObject", *this);
1251 }
1252 /* }}} */
1253 
1254 
1255 /* {{{ OResultSet::updateNumericObject() -U- */
1256 void SAL_CALL OResultSet::updateNumericObject(sal_Int32 column, const Any& /* x */, sal_Int32 /* scale */)
1257 	throw(SQLException, RuntimeException)
1258 {
1259 	OSL_TRACE("OResultSet::updateNumericObject");
1260 	MutexGuard aGuard(m_aMutex);
1261 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1262 	checkColumnIndex(column);
1263 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::updateNumericObject", *this);
1264 }
1265 /* }}} */
1266 
1267 
1268 // XRowLocate
1269 /* {{{ OResultSet::getBookmark() -U- */
1270 Any SAL_CALL OResultSet::getBookmark()
1271 	throw(SQLException, RuntimeException)
1272 {
1273 	OSL_TRACE("OResultSet::getBookmark");
1274 	MutexGuard aGuard(m_aMutex);
1275 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1276 	Any aRet = Any();
1277 
1278 	// if you don't want to support bookmark you must remove the XRowLocate interface
1279 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::getBookmark", *this);
1280 
1281 	return aRet;
1282 }
1283 /* }}} */
1284 
1285 
1286 /* {{{ OResultSet::moveToBookmark() -U- */
1287 sal_Bool SAL_CALL OResultSet::moveToBookmark(const Any& /* bookmark */)
1288 	throw(SQLException, RuntimeException)
1289 {
1290 	OSL_TRACE("OResultSet::moveToBookmark");
1291 	MutexGuard aGuard(m_aMutex);
1292 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1293 
1294 	return sal_False;
1295 }
1296 /* }}} */
1297 
1298 
1299 /* {{{ OResultSet::moveRelativeToBookmark() -U- */
1300 sal_Bool SAL_CALL OResultSet::moveRelativeToBookmark(const Any& /* bookmark */, sal_Int32 /* rows */)
1301 	throw(SQLException, RuntimeException)
1302 {
1303 	OSL_TRACE("OResultSet::moveRelativeToBookmark");
1304 	MutexGuard aGuard(m_aMutex);
1305 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1306 
1307 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::moveRelativeToBookmark", *this);
1308 	return sal_False;
1309 }
1310 /* }}} */
1311 
1312 
1313 /* {{{ OResultSet::compareBookmarks() -I- */
1314 sal_Int32 SAL_CALL OResultSet::compareBookmarks(const Any& /* n1 */, const Any& /* n2 */)
1315 	throw(SQLException, RuntimeException)
1316 {
1317 	OSL_TRACE("OResultSet::compareBookmarks");
1318 	MutexGuard aGuard(m_aMutex);
1319 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1320 
1321 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::compareBookmarks", *this);
1322 
1323 	return CompareBookmark::NOT_EQUAL;
1324 }
1325 /* }}} */
1326 
1327 
1328 /* {{{ OResultSet::hasOrderedBookmarks() -I- */
1329 sal_Bool SAL_CALL OResultSet::hasOrderedBookmarks()
1330 	throw(SQLException, RuntimeException)
1331 {
1332 	OSL_TRACE("OResultSet::hasOrderedBookmarks");
1333 	return sal_False;
1334 }
1335 /* }}} */
1336 
1337 
1338 /* {{{ OResultSet::hashBookmark() -U- */
1339 sal_Int32 SAL_CALL OResultSet::hashBookmark(const Any& /* bookmark */)
1340 	throw(SQLException, RuntimeException)
1341 {
1342 	OSL_TRACE("OResultSet::hashBookmark");
1343 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::hashBookmark", *this);
1344 	return 0;
1345 }
1346 /* }}} */
1347 
1348 
1349 // XDeleteRows
1350 /* {{{ OResultSet::deleteRows() -U- */
1351 Sequence< sal_Int32 > SAL_CALL OResultSet::deleteRows(const Sequence< Any >& /* rows */)
1352 	throw(SQLException, RuntimeException)
1353 {
1354 	OSL_TRACE("OResultSet::deleteRows");
1355 	MutexGuard aGuard(m_aMutex);
1356 	checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1357 	Sequence< sal_Int32 > aRet = Sequence< sal_Int32 >();
1358 
1359 	mysqlc_sdbc_driver::throwFeatureNotImplementedException("OResultSet::deleteRows", *this);
1360 	return aRet;
1361 }
1362 /* }}} */
1363 
1364 
1365 /* {{{ OResultSet::createArrayHelper() -I- */
1366 IPropertyArrayHelper * OResultSet::createArrayHelper() const
1367 {
1368 	OSL_TRACE("OResultSet::createArrayHelper");
1369 	Sequence< Property > aProps(5);
1370 	Property* pProperties = aProps.getArray();
1371 	sal_Int32 nPos = 0;
1372 	DECL_PROP0(FETCHDIRECTION,			sal_Int32);
1373 	DECL_PROP0(FETCHSIZE,				sal_Int32);
1374 	DECL_BOOL_PROP1IMPL(ISBOOKMARKABLE) PropertyAttribute::READONLY);
1375 	DECL_PROP1IMPL(RESULTSETCONCURRENCY,sal_Int32) PropertyAttribute::READONLY);
1376 	DECL_PROP1IMPL(RESULTSETTYPE,		sal_Int32) PropertyAttribute::READONLY);
1377 
1378 	return new OPropertyArrayHelper(aProps);
1379 }
1380 /* }}} */
1381 
1382 
1383 /* {{{ OResultSet::getInfoHelper() -I- */
1384 IPropertyArrayHelper & OResultSet::getInfoHelper()
1385 {
1386 	OSL_TRACE("OResultSet::getInfoHelper");
1387 	return (*const_cast<OResultSet*>(this)->getArrayHelper());
1388 }
1389 /* }}} */
1390 
1391 
1392 /* {{{ OResultSet::convertFastPropertyValue() -I- */
1393 sal_Bool OResultSet::convertFastPropertyValue(Any & /* rConvertedValue */,
1394 											Any & /* rOldValue */,
1395 											sal_Int32 nHandle,
1396 											const Any& /* rValue */)
1397 	throw (::com::sun::star::lang::IllegalArgumentException)
1398 {
1399 	OSL_TRACE("OResultSet::convertFastPropertyValue");
1400 	switch (nHandle) {
1401 		case PROPERTY_ID_ISBOOKMARKABLE:
1402 		case PROPERTY_ID_CURSORNAME:
1403 		case PROPERTY_ID_RESULTSETCONCURRENCY:
1404 		case PROPERTY_ID_RESULTSETTYPE:
1405 			throw ::com::sun::star::lang::IllegalArgumentException();
1406 		case PROPERTY_ID_FETCHDIRECTION:
1407 		case PROPERTY_ID_FETCHSIZE:
1408 		default:
1409 			;
1410 	}
1411 	return sal_False;
1412 }
1413 /* }}} */
1414 
1415 
1416 /* {{{ OResultSet::setFastPropertyValue_NoBroadcast() -I- */
1417 void OResultSet::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle, const Any& /* rValue */)
1418 	throw (Exception)
1419 {
1420 	OSL_TRACE("OResultSet::setFastPropertyValue_NoBroadcast");
1421 	switch (nHandle) {
1422 		case PROPERTY_ID_ISBOOKMARKABLE:
1423 		case PROPERTY_ID_CURSORNAME:
1424 		case PROPERTY_ID_RESULTSETCONCURRENCY:
1425 		case PROPERTY_ID_RESULTSETTYPE:
1426 			throw Exception();
1427 		case PROPERTY_ID_FETCHDIRECTION:
1428 			break;
1429 		case PROPERTY_ID_FETCHSIZE:
1430 			break;
1431 		default:
1432 			;
1433 	}
1434 }
1435 /* }}} */
1436 
1437 
1438 /* {{{ OResultSet::getFastPropertyValue() -I- */
1439 void OResultSet::getFastPropertyValue(Any& _rValue, sal_Int32 nHandle) const
1440 {
1441 	OSL_TRACE("OResultSet::getFastPropertyValue");
1442 	switch (nHandle) {
1443 		case PROPERTY_ID_ISBOOKMARKABLE:
1444             _rValue <<= sal_False;
1445             break;
1446 		case PROPERTY_ID_CURSORNAME:
1447             break;
1448 		case PROPERTY_ID_RESULTSETCONCURRENCY:
1449             _rValue <<= ResultSetConcurrency::READ_ONLY;
1450             break;
1451 		case PROPERTY_ID_RESULTSETTYPE:
1452             _rValue <<= ResultSetType::SCROLL_INSENSITIVE;
1453             break;
1454 		case PROPERTY_ID_FETCHDIRECTION:
1455             _rValue <<= FetchDirection::FORWARD;
1456             break;
1457 		case PROPERTY_ID_FETCHSIZE:
1458             _rValue <<= sal_Int32(50);
1459             break;
1460 			;
1461 		default:
1462 			;
1463 	}
1464 }
1465 /* }}} */
1466 
1467 
1468 /* {{{ OResultSet::acquire() -I- */
1469 void SAL_CALL OResultSet::acquire()
1470 	throw()
1471 {
1472 	OSL_TRACE("OResultSet::acquire");
1473 	OResultSet_BASE::acquire();
1474 }
1475 /* }}} */
1476 
1477 
1478 /* {{{ OResultSet::release() -I- */
1479 void SAL_CALL OResultSet::release()
1480 	throw()
1481 {
1482 	OSL_TRACE("OResultSet::release");
1483 	OResultSet_BASE::release();
1484 }
1485 /* }}} */
1486 
1487 
1488 /* {{{ OResultSet::getPropertySetInfo() -I- */
1489 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL OResultSet::getPropertySetInfo() throw(::com::sun::star::uno::RuntimeException)
1490 {
1491 	OSL_TRACE("OResultSet::getPropertySetInfo");
1492 	return (::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper()));
1493 }
1494 /* }}} */
1495 
1496 
1497 /* {{{ OResultSet::checkColumnIndex() -I- */
1498 void OResultSet::checkColumnIndex(sal_Int32 index)
1499 	throw (SQLException, RuntimeException)
1500 {
1501 	OSL_TRACE("OResultSet::checkColumnIndex");
1502 	if ((index < 1 || index > (int) fieldCount)) {
1503 		/* static object for efficiency or thread safety is a problem ? */
1504 		OUString buf( RTL_CONSTASCII_USTRINGPARAM( "index out of range" ) );
1505 		throw SQLException(buf, *this, OUString(), 1, Any());
1506 	}
1507 }
1508 /* }}} */
1509 
1510 
1511 /*
1512  * Local variables:
1513  * tab-width: 4
1514  * c-basic-offset: 4
1515  * End:
1516  * vim600: noet sw=4 ts=4 fdm=marker
1517  * vim<600: noet sw=4 ts=4
1518  */
1519