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_general.hxx"
23 #include "mysqlc_preparedstatement.hxx"
24 #include "mysqlc_propertyids.hxx"
25 #include "mysqlc_resultsetmetadata.hxx"
26
27 #include <com/sun/star/lang/DisposedException.hpp>
28 #include <com/sun/star/sdbc/DataType.hpp>
29
30 #include <cppconn/connection.h>
31 #include <cppconn/exception.h>
32 #include <cppconn/parameter_metadata.h>
33 #include <cppconn/prepared_statement.h>
34 #include <cppconn/statement.h>
35 #include <cppuhelper/typeprovider.hxx>
36 #include <osl/diagnose.h>
37
38 #include <stdio.h>
39
40 using namespace connectivity::mysqlc;
41 using namespace com::sun::star::uno;
42 using namespace com::sun::star::lang;
43 using namespace com::sun::star::beans;
44 using namespace com::sun::star::sdbc;
45 using namespace com::sun::star::container;
46 using namespace com::sun::star::io;
47 using namespace com::sun::star::util;
48 using ::osl::MutexGuard;
49 using mysqlc_sdbc_driver::getStringFromAny;
50
51
52 /* {{{ my_i_to_a() -I- */
my_i_to_a(char * buf,size_t buf_size,int a)53 static inline char * my_i_to_a(char * buf, size_t buf_size, int a)
54 {
55 snprintf(buf, buf_size, "%d", a);
56 return buf;
57 }
58 /* }}} */
59
60
61 IMPLEMENT_SERVICE_INFO(OPreparedStatement,"com.sun.star.sdbcx.mysqlc.PreparedStatement","com.sun.star.sdbc.PreparedStatement");
62
63
64 /* {{{ OPreparedStatement::OPreparedStatement() -I- */
OPreparedStatement(OConnection * _pConnection,sql::PreparedStatement * _cppPrepStmt)65 OPreparedStatement::OPreparedStatement(OConnection* _pConnection, sql::PreparedStatement * _cppPrepStmt)
66 :OCommonStatement(_pConnection, _cppPrepStmt)
67 {
68 OSL_TRACE("OPreparedStatement::OPreparedStatement");
69 m_pConnection = _pConnection;
70 m_pConnection->acquire();
71
72 try {
73 m_paramCount = ((sql::PreparedStatement *)cppStatement)->getParameterMetaData()->getParameterCount();
74 } catch (sql::SQLException &e) {
75 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
76 }
77 }
78 /* }}} */
79
80
81 /* {{{ OPreparedStatement::~OPreparedStatement() -I- */
~OPreparedStatement()82 OPreparedStatement::~OPreparedStatement()
83 {
84 OSL_TRACE("OPreparedStatement::~OPreparedStatement");
85 }
86 /* }}} */
87
88
89 /* {{{ OPreparedStatement::acquire() -I- */
acquire()90 void SAL_CALL OPreparedStatement::acquire()
91 throw()
92 {
93 OSL_TRACE("OPreparedStatement::acquire");
94 OCommonStatement::acquire();
95 }
96 /* }}} */
97
98
99 /* {{{ OPreparedStatement::release() -I- */
release()100 void SAL_CALL OPreparedStatement::release()
101 throw()
102 {
103 OSL_TRACE("OPreparedStatement::release");
104 OCommonStatement::release();
105 }
106 /* }}} */
107
108
109 /* {{{ OPreparedStatement::queryInterface() -I- */
queryInterface(const Type & rType)110 Any SAL_CALL OPreparedStatement::queryInterface(const Type & rType)
111 {
112 OSL_TRACE("OPreparedStatement::queryInterface");
113 Any aRet = OCommonStatement::queryInterface(rType);
114 if (!aRet.hasValue()) {
115 aRet = OPreparedStatement_BASE::queryInterface(rType);
116 }
117 return (aRet);
118 }
119 /* }}} */
120
121
122 /* {{{ OPreparedStatement::getPropertySetInfo() -I- */
getTypes()123 Sequence< Type > SAL_CALL OPreparedStatement::getTypes()
124 {
125 OSL_TRACE("OPreparedStatement::getTypes");
126 return concatSequences(OPreparedStatement_BASE::getTypes(), OCommonStatement::getTypes());
127 }
128 /* }}} */
129
130
131 /* {{{ OPreparedStatement::getMetaData() -I- */
getMetaData()132 Reference< XResultSetMetaData > SAL_CALL OPreparedStatement::getMetaData()
133 {
134 OSL_TRACE("OPreparedStatement::getMetaData");
135 MutexGuard aGuard(m_aMutex);
136 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
137
138 try {
139 if (!m_xMetaData.is()) {
140 m_xMetaData = new OResultSetMetaData(
141 ((sql::PreparedStatement *)cppStatement)->getMetaData(),
142 getOwnConnection()->getConnectionEncoding()
143 );
144 }
145 } catch (sql::MethodNotImplementedException) {
146 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::getMetaData", *this);
147 } catch (sql::SQLException &e) {
148 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
149 }
150 return m_xMetaData;
151 }
152 /* }}} */
153
154
155 /* {{{ OPreparedStatement::close() -I- */
close()156 void SAL_CALL OPreparedStatement::close()
157 {
158 OSL_TRACE("OPreparedStatement::close");
159
160 MutexGuard aGuard(m_aMutex);
161 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
162
163 try {
164 clearWarnings();
165 clearParameters();
166 OCommonStatement::close();
167 } catch (SQLException) {
168 // If we get an error, ignore
169 }
170
171 // Remove this Statement object from the Connection object's
172 // list
173 }
174 /* }}} */
175
176
177 /* {{{ OPreparedStatement::execute() -I- */
execute()178 sal_Bool SAL_CALL OPreparedStatement::execute()
179 {
180 OSL_TRACE("OPreparedStatement::execute");
181 MutexGuard aGuard(m_aMutex);
182 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
183
184 sal_Bool success = sal_False;
185 try {
186 success = ((sql::PreparedStatement *)cppStatement)->execute()? sal_True:sal_False;
187 } catch (sql::SQLException &e) {
188 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
189 }
190 return success;
191 }
192 /* }}} */
193
194
195 /* {{{ OPreparedStatement::executeUpdate() -I- */
executeUpdate()196 sal_Int32 SAL_CALL OPreparedStatement::executeUpdate()
197 {
198 OSL_TRACE("OPreparedStatement::executeUpdate");
199 MutexGuard aGuard(m_aMutex);
200 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
201
202 sal_Int32 affectedRows = sal_False;
203 try {
204 affectedRows = ((sql::PreparedStatement *)cppStatement)->executeUpdate();
205 } catch (sql::SQLException &e) {
206 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
207 }
208 return affectedRows;
209 }
210 /* }}} */
211
212
213 /* {{{ OPreparedStatement::getPropertySetInfo() -I- */
setString(sal_Int32 parameter,const OUString & x)214 void SAL_CALL OPreparedStatement::setString(sal_Int32 parameter, const OUString& x)
215 {
216 OSL_TRACE("OPreparedStatement::setString");
217 MutexGuard aGuard(m_aMutex);
218 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
219 checkParameterIndex(parameter);
220
221 try {
222 ext_std::string stringie(::rtl::OUStringToOString(x, m_pConnection->getConnectionEncoding()).getStr());
223 ((sql::PreparedStatement *)cppStatement)->setString(parameter, stringie);
224 } catch (sql::MethodNotImplementedException) {
225 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::clearParameters", *this);
226 } catch (sql::SQLException &e) {
227 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
228 }
229 }
230 /* }}} */
231
232
233 /* {{{ OPreparedStatement::getConnection() -I- */
getConnection()234 Reference< XConnection > SAL_CALL OPreparedStatement::getConnection()
235 {
236 OSL_TRACE("OPreparedStatement::getConnection");
237 MutexGuard aGuard(m_aMutex);
238 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
239
240 return (Reference< XConnection >)m_pConnection;
241 }
242 /* }}} */
243
executeQuery(const OUString & sql)244 Reference< XResultSet > SAL_CALL OPreparedStatement::executeQuery(const OUString& sql)
245 {
246 return OCommonStatement::executeQuery( sql );
247 }
248
executeUpdate(const OUString & sql)249 sal_Int32 SAL_CALL OPreparedStatement::executeUpdate(const OUString& sql)
250 {
251 return OCommonStatement::executeUpdate( sql );
252 }
253
execute(const OUString & sql)254 sal_Bool SAL_CALL OPreparedStatement::execute( const OUString& sql )
255 {
256 return OCommonStatement::execute( sql );
257 }
258
259 /* {{{ OPreparedStatement::executeQuery() -I- */
executeQuery()260 Reference< XResultSet > SAL_CALL OPreparedStatement::executeQuery()
261 {
262 OSL_TRACE("OPreparedStatement::executeQuery");
263 MutexGuard aGuard(m_aMutex);
264 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
265
266 Reference< XResultSet > xResultSet;
267 try {
268 sql::ResultSet * res = ((sql::PreparedStatement *)cppStatement)->executeQuery();
269 xResultSet = new OResultSet(this, res, getOwnConnection()->getConnectionEncoding());
270 } catch (sql::SQLException &e) {
271 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
272 }
273 return xResultSet;
274 }
275 /* }}} */
276
277
278 /* {{{ OPreparedStatement::setBoolean() -I- */
setBoolean(sal_Int32 parameter,sal_Bool x)279 void SAL_CALL OPreparedStatement::setBoolean(sal_Int32 parameter, sal_Bool x)
280 {
281 OSL_TRACE("OPreparedStatement::setBoolean");
282 MutexGuard aGuard(m_aMutex);
283 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
284 checkParameterIndex(parameter);
285
286 try {
287 ((sql::PreparedStatement *)cppStatement)->setBoolean(parameter, x);
288 } catch (sql::MethodNotImplementedException) {
289 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setBoolean", *this);
290 } catch (sql::SQLException &e) {
291 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
292 }
293 }
294 /* }}} */
295
296
297 /* {{{ OPreparedStatement::setByte() -I- */
setByte(sal_Int32 parameter,sal_Int8 x)298 void SAL_CALL OPreparedStatement::setByte(sal_Int32 parameter, sal_Int8 x)
299 {
300 OSL_TRACE("OPreparedStatement::setByte");
301 MutexGuard aGuard(m_aMutex);
302 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
303 checkParameterIndex(parameter);
304
305 try {
306 ((sql::PreparedStatement *)cppStatement)->setInt(parameter, x);
307 } catch (sql::MethodNotImplementedException) {
308 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setByte", *this);
309 } catch (sql::SQLException &e) {
310 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
311 }
312 }
313 /* }}} */
314
315
316 /* {{{ OPreparedStatement::setDate() -I- */
setDate(sal_Int32 parameter,const Date & aData)317 void SAL_CALL OPreparedStatement::setDate(sal_Int32 parameter, const Date& aData)
318 {
319 OSL_TRACE("OPreparedStatement::setDate");
320 MutexGuard aGuard(m_aMutex);
321 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
322 checkParameterIndex(parameter);
323
324 ext_std::string dateStr;
325 char buf[20];
326 dateStr.append(my_i_to_a(buf, sizeof(buf)-1, aData.Year));
327 dateStr.append("-", 1);
328 dateStr.append(my_i_to_a(buf, sizeof(buf)-1, aData.Month));
329 dateStr.append("-", 1);
330 dateStr.append(my_i_to_a(buf, sizeof(buf)-1, aData.Day));
331
332 try {
333 ((sql::PreparedStatement *)cppStatement)->setDateTime(parameter, dateStr);
334 } catch (sql::MethodNotImplementedException) {
335 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setDate", *this);
336 } catch (sql::SQLException &e) {
337 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
338 }
339 }
340 /* }}} */
341
342
343 /* {{{ OPreparedStatement::setTime() -I- */
setTime(sal_Int32 parameter,const Time & aVal)344 void SAL_CALL OPreparedStatement::setTime(sal_Int32 parameter, const Time& aVal)
345 {
346 OSL_TRACE("OPreparedStatement::setTime");
347 MutexGuard aGuard(m_aMutex);
348 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
349 checkParameterIndex(parameter);
350
351 ext_std::string timeStr;
352 char buf[20];
353 timeStr.append(my_i_to_a(buf, sizeof(buf)-1, aVal.Hours));
354 timeStr.append(":", 1);
355 timeStr.append(my_i_to_a(buf, sizeof(buf)-1, aVal.Minutes));
356 timeStr.append(":", 1);
357 timeStr.append(my_i_to_a(buf, sizeof(buf)-1, aVal.Seconds));
358
359 try {
360 ((sql::PreparedStatement *)cppStatement)->setDateTime(parameter, timeStr);
361 } catch (sql::MethodNotImplementedException) {
362 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setTime", *this);
363 } catch (sql::SQLException &e) {
364 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
365 }
366 }
367 /* }}} */
368
369
370 /* {{{ OPreparedStatement::setTimestamp() -I- */
setTimestamp(sal_Int32 parameter,const DateTime & aVal)371 void SAL_CALL OPreparedStatement::setTimestamp(sal_Int32 parameter, const DateTime& aVal)
372 {
373 OSL_TRACE("OPreparedStatement::setTimestamp");
374 MutexGuard aGuard(m_aMutex);
375 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
376 checkParameterIndex(parameter);
377
378 ext_std::string timeStr;
379 char buf[20];
380 timeStr.append(my_i_to_a(buf, sizeof(buf)-1, aVal.Year));
381 timeStr.append("-", 1);
382 timeStr.append(my_i_to_a(buf, sizeof(buf)-1, aVal.Month));
383 timeStr.append("-", 1);
384 timeStr.append(my_i_to_a(buf, sizeof(buf)-1, aVal.Day));
385
386 timeStr.append(" ", 1);
387
388 timeStr.append(my_i_to_a(buf, sizeof(buf)-1, aVal.Hours));
389 timeStr.append(":", 1);
390 timeStr.append(my_i_to_a(buf, sizeof(buf)-1, aVal.Minutes));
391 timeStr.append(":", 1);
392 timeStr.append(my_i_to_a(buf, sizeof(buf)-1, aVal.Seconds));
393
394 try {
395 ((sql::PreparedStatement *)cppStatement)->setDateTime(parameter, timeStr);
396 } catch (sql::MethodNotImplementedException) {
397 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setTimestamp", *this);
398 } catch (sql::SQLException &e) {
399 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
400 }
401 }
402 /* }}} */
403
404
405 /* {{{ OPreparedStatement::setDouble() -I- */
setDouble(sal_Int32 parameter,double x)406 void SAL_CALL OPreparedStatement::setDouble(sal_Int32 parameter, double x)
407 {
408 OSL_TRACE("OPreparedStatement::setDouble");
409 MutexGuard aGuard(m_aMutex);
410 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
411 checkParameterIndex(parameter);
412
413 try {
414 ((sql::PreparedStatement *)cppStatement)->setDouble(parameter, x);
415 } catch (sql::MethodNotImplementedException) {
416 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setDouble", *this);
417 } catch (sql::SQLException &e) {
418 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
419 }
420 }
421 /* }}} */
422
423
424 /* {{{ OPreparedStatement::setFloat() -I- */
setFloat(sal_Int32 parameter,float x)425 void SAL_CALL OPreparedStatement::setFloat(sal_Int32 parameter, float x)
426 {
427 OSL_TRACE("OPreparedStatement::setFloat");
428 MutexGuard aGuard(m_aMutex);
429 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
430 checkParameterIndex(parameter);
431
432 try {
433 ((sql::PreparedStatement *)cppStatement)->setDouble(parameter, x);
434 } catch (sql::MethodNotImplementedException) {
435 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setFloat", *this);
436 } catch (sql::SQLException &e) {
437 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
438 }
439 }
440 /* }}} */
441
442
443 /* {{{ OPreparedStatement::setInt() -I- */
setInt(sal_Int32 parameter,sal_Int32 x)444 void SAL_CALL OPreparedStatement::setInt(sal_Int32 parameter, sal_Int32 x)
445 {
446 OSL_TRACE("OPreparedStatement::setInt");
447 MutexGuard aGuard(m_aMutex);
448 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
449 checkParameterIndex(parameter);
450
451 try {
452 ((sql::PreparedStatement *)cppStatement)->setInt(parameter, x);
453 } catch (sql::MethodNotImplementedException) {
454 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setInt", *this);
455 } catch (sql::SQLException &e) {
456 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
457 }
458 }
459 /* }}} */
460
461
462 /* {{{ OPreparedStatement::setLong() -I- */
setLong(sal_Int32 parameter,sal_Int64 aVal)463 void SAL_CALL OPreparedStatement::setLong(sal_Int32 parameter, sal_Int64 aVal)
464 {
465 OSL_TRACE("OPreparedStatement::setLong");
466 MutexGuard aGuard(m_aMutex);
467 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
468 checkParameterIndex(parameter);
469
470 try {
471 ((sql::PreparedStatement *)cppStatement)->setInt64(parameter, aVal);
472 } catch (sql::MethodNotImplementedException) {
473 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setLong", *this);
474 } catch (sql::SQLException &e) {
475 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
476 }
477 }
478 /* }}} */
479
480
481 /* {{{ OPreparedStatement::setNull() -I- */
setNull(sal_Int32 parameter,sal_Int32 sqlType)482 void SAL_CALL OPreparedStatement::setNull(sal_Int32 parameter, sal_Int32 sqlType)
483 {
484 OSL_TRACE("OPreparedStatement::setNull");
485 MutexGuard aGuard(m_aMutex);
486 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
487 checkParameterIndex(parameter);
488
489 try {
490 ((sql::PreparedStatement *)cppStatement)->setNull(parameter, sqlType);
491 } catch (sql::MethodNotImplementedException) {
492 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setNull", *this);
493 } catch (sql::SQLException &e) {
494 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
495 }
496 }
497 /* }}} */
498
499
500 /* {{{ OPreparedStatement::setClob() -U- */
setClob(sal_Int32 parameter,const Reference<XClob> &)501 void SAL_CALL OPreparedStatement::setClob(sal_Int32 parameter, const Reference< XClob >& /* x */)
502 {
503 OSL_TRACE("OPreparedStatement::setClob");
504 MutexGuard aGuard(m_aMutex);
505 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
506 checkParameterIndex(parameter);
507
508 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setClob", *this);
509 }
510 /* }}} */
511
512
513 /* {{{ OPreparedStatement::setBlob() -U- */
setBlob(sal_Int32 parameter,const Reference<XBlob> &)514 void SAL_CALL OPreparedStatement::setBlob(sal_Int32 parameter, const Reference< XBlob >& /* x */)
515 {
516 OSL_TRACE("OPreparedStatement::setBlob");
517 MutexGuard aGuard(m_aMutex);
518 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
519 checkParameterIndex(parameter);
520
521 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setBlob", *this);
522 }
523 /* }}} */
524
525
526 /* {{{ OPreparedStatement::setArray() -U- */
setArray(sal_Int32 parameter,const Reference<XArray> &)527 void SAL_CALL OPreparedStatement::setArray(sal_Int32 parameter, const Reference< XArray >& /* x */)
528 {
529 OSL_TRACE("OPreparedStatement::setArray");
530 MutexGuard aGuard(m_aMutex);
531 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
532 checkParameterIndex(parameter);
533
534 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setArray", *this);
535 }
536 /* }}} */
537
538
539 /* {{{ OPreparedStatement::setRef() -U- */
setRef(sal_Int32 parameter,const Reference<XRef> &)540 void SAL_CALL OPreparedStatement::setRef(sal_Int32 parameter, const Reference< XRef >& /* x */)
541 {
542 OSL_TRACE("OPreparedStatement::setRef");
543 MutexGuard aGuard(m_aMutex);
544 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
545 checkParameterIndex(parameter);
546
547 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setRef", *this);
548 }
549 /* }}} */
550
551 namespace
552 {
553 template < class COMPLEXTYPE >
impl_setObject(const Reference<XParameters> & _rxParam,sal_Int32 _parameterIndex,const Any & _value,void (SAL_CALL XParameters::* _Setter)(sal_Int32,const COMPLEXTYPE &),bool _throwIfNotExtractable)554 bool impl_setObject( const Reference< XParameters >& _rxParam, sal_Int32 _parameterIndex, const Any& _value,
555 void ( SAL_CALL XParameters::*_Setter )( sal_Int32, const COMPLEXTYPE& ), bool _throwIfNotExtractable )
556 {
557 COMPLEXTYPE aValue;
558 if ( _value >>= aValue )
559 {
560 (_rxParam.get()->*_Setter)( _parameterIndex, aValue );
561 return true;
562 }
563
564 if ( _throwIfNotExtractable )
565 mysqlc_sdbc_driver::throwInvalidArgumentException( "OPreparedStatement::setObjectWithInfo", _rxParam );
566 return false;
567 }
568
569 template < class INTTYPE >
impl_setObject(const Reference<XParameters> & _rxParam,sal_Int32 _parameterIndex,const Any & _value,void (SAL_CALL XParameters::* _Setter)(sal_Int32,INTTYPE))570 void impl_setObject( const Reference< XParameters >& _rxParam, sal_Int32 _parameterIndex, const Any& _value,
571 void ( SAL_CALL XParameters::*_Setter )( sal_Int32, INTTYPE ) )
572 {
573 sal_Int32 nValue(0);
574 if ( !( _value >>= nValue ) )
575 mysqlc_sdbc_driver::throwInvalidArgumentException( "OPreparedStatement::setObjectWithInfo", _rxParam );
576 (_rxParam.get()->*_Setter)( _parameterIndex, (INTTYPE)nValue );
577 }
578 }
579
580 /* {{{ OPreparedStatement::setObjectWithInfo() -U- */
setObjectWithInfo(sal_Int32 _parameterIndex,const Any & _value,sal_Int32 _targetSqlType,sal_Int32)581 void SAL_CALL OPreparedStatement::setObjectWithInfo(sal_Int32 _parameterIndex, const Any& _value, sal_Int32 _targetSqlType, sal_Int32 /* scale */)
582 {
583 OSL_TRACE("OPreparedStatement::setObjectWithInfo");
584 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
585 MutexGuard aGuard(m_aMutex);
586 checkParameterIndex( _parameterIndex );
587
588 if ( !_value.hasValue() )
589 {
590 setNull( _parameterIndex, _targetSqlType );
591 return;
592 }
593
594 switch ( _targetSqlType )
595 {
596 case DataType::DECIMAL:
597 case DataType::NUMERIC:
598 {
599 double nValue(0);
600 if ( _value >>= nValue )
601 {
602 setDouble( _parameterIndex, nValue );
603 break;
604 }
605 }
606 // run through
607
608 case DataType::CHAR:
609 case DataType::VARCHAR:
610 case DataType::LONGVARCHAR:
611 impl_setObject( this, _parameterIndex, _value, &XParameters::setString, true );
612 break;
613
614 case DataType::BIGINT:
615 {
616 sal_Int64 nValue = 0;
617 if ( !( _value >>= nValue ) )
618 mysqlc_sdbc_driver::throwInvalidArgumentException( "OPreparedStatement::setObjectWithInfo", *this );
619 setLong( _parameterIndex, nValue );
620 }
621 break;
622
623 case DataType::FLOAT:
624 case DataType::REAL:
625 {
626 float nValue = 0;
627 if ( _value >>= nValue )
628 {
629 setFloat(_parameterIndex,nValue);
630 break;
631 }
632 }
633 // run through if we couldn't set a float value
634
635 case DataType::DOUBLE:
636 {
637 double nValue(0);
638 if ( !( _value >>= nValue ) )
639 mysqlc_sdbc_driver::throwInvalidArgumentException( "OPreparedStatement::setObjectWithInfo", *this );
640 setDouble( _parameterIndex, nValue );
641 }
642 break;
643
644 case DataType::DATE:
645 impl_setObject( this, _parameterIndex, _value, &XParameters::setDate, true );
646 break;
647
648 case DataType::TIME:
649 impl_setObject( this, _parameterIndex, _value, &XParameters::setTime, true );
650 break;
651
652 case DataType::TIMESTAMP:
653 impl_setObject( this, _parameterIndex, _value, &XParameters::setTimestamp, true );
654 break;
655
656 case DataType::BINARY:
657 case DataType::VARBINARY:
658 case DataType::LONGVARBINARY:
659 {
660 if ( impl_setObject( this, _parameterIndex, _value, &XParameters::setBytes, false )
661 || impl_setObject( this, _parameterIndex, _value, &XParameters::setBlob, false )
662 || impl_setObject( this, _parameterIndex, _value, &XParameters::setClob, false )
663 )
664 break;
665
666 Reference< ::com::sun::star::io::XInputStream > xBinStream;
667 if ( _value >>= xBinStream )
668 {
669 setBinaryStream( _parameterIndex, xBinStream, xBinStream->available() );
670 break;
671 }
672
673 mysqlc_sdbc_driver::throwInvalidArgumentException( "OPreparedStatement::setObjectWithInfo", *this );
674 }
675 break;
676
677 case DataType::BIT:
678 case DataType::BOOLEAN:
679 {
680 bool bValue( false );
681 if ( _value >>= bValue )
682 {
683 setBoolean( _parameterIndex, bValue );
684 break;
685 }
686 sal_Int32 nValue( 0 );
687 if ( _value >>= nValue )
688 {
689 setBoolean( _parameterIndex, ( nValue != 0 ) );
690 break;
691 }
692 mysqlc_sdbc_driver::throwInvalidArgumentException( "OPreparedStatement::setObjectWithInfo", *this );
693 }
694 break;
695
696 case DataType::TINYINT:
697 impl_setObject( this, _parameterIndex, _value, &XParameters::setByte );
698 break;
699
700 case DataType::SMALLINT:
701 impl_setObject( this, _parameterIndex, _value, &XParameters::setShort );
702 break;
703
704 case DataType::INTEGER:
705 impl_setObject( this, _parameterIndex, _value, &XParameters::setInt );
706 break;
707
708 default:
709 mysqlc_sdbc_driver::throwInvalidArgumentException( "OPreparedStatement::setObjectWithInfo", *this );
710 break;
711 }
712 }
713 /* }}} */
714
715
716 /* {{{ OPreparedStatement::setObjectNull() -U- */
setObjectNull(sal_Int32 parameter,sal_Int32,const OUString &)717 void SAL_CALL OPreparedStatement::setObjectNull(sal_Int32 parameter, sal_Int32 /* sqlType */, const OUString& /* typeName */)
718 {
719 OSL_TRACE("OPreparedStatement::setObjectNull");
720 MutexGuard aGuard(m_aMutex);
721 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
722 checkParameterIndex(parameter);
723
724 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setObjectNull", *this);
725 }
726 /* }}} */
727
728
729 /* {{{ OPreparedStatement::setObject() -U- */
setObject(sal_Int32 parameter,const Any &)730 void SAL_CALL OPreparedStatement::setObject(sal_Int32 parameter, const Any& /* x */)
731 {
732 OSL_TRACE("OPreparedStatement::setObject");
733 MutexGuard aGuard(m_aMutex);
734 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
735 checkParameterIndex(parameter);
736
737 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setObject", *this);
738 }
739 /* }}} */
740
741
742 /* {{{ OPreparedStatement::setShort() -I- */
setShort(sal_Int32 parameter,sal_Int16 x)743 void SAL_CALL OPreparedStatement::setShort(sal_Int32 parameter, sal_Int16 x)
744 {
745 OSL_TRACE("OPreparedStatement::setShort");
746 MutexGuard aGuard(m_aMutex);
747 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
748 checkParameterIndex(parameter);
749
750 try {
751 ((sql::PreparedStatement *)cppStatement)->setInt(parameter, x);
752 } catch (sql::MethodNotImplementedException) {
753 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setShort", *this);
754 } catch (sql::SQLException &e) {
755 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
756 }
757 }
758 /* }}} */
759
760
761 /* {{{ OPreparedStatement::setBytes() -I- */
setBytes(sal_Int32 parameter,const Sequence<sal_Int8> & x)762 void SAL_CALL OPreparedStatement::setBytes(sal_Int32 parameter, const Sequence< sal_Int8 >& x)
763 {
764 OSL_TRACE("OPreparedStatement::setBytes");
765 MutexGuard aGuard(m_aMutex);
766 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
767 checkParameterIndex(parameter);
768
769 ext_std::string blobby((char *)x.getConstArray(), x.getLength());
770 try {
771 ((sql::PreparedStatement *)cppStatement)->setString(parameter, blobby);
772 } catch (sql::MethodNotImplementedException) {
773 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setBytes", *this);
774 } catch (sql::SQLException &e) {
775 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
776 }
777 }
778 /* }}} */
779
780
781 /* {{{ OPreparedStatement::setCharacterStream() -U- */
setCharacterStream(sal_Int32 parameter,const Reference<XInputStream> &,sal_Int32)782 void SAL_CALL OPreparedStatement::setCharacterStream(sal_Int32 parameter,
783 const Reference< XInputStream >& /* x */,
784 sal_Int32 /* length */)
785 {
786 OSL_TRACE("OPreparedStatement::setCharacterStream");
787 MutexGuard aGuard(m_aMutex);
788 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
789 checkParameterIndex(parameter);
790
791 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setCharacterStream", *this);
792 }
793 /* }}} */
794
795
796 /* {{{ OPreparedStatement::setBinaryStream() -U- */
setBinaryStream(sal_Int32 parameter,const Reference<XInputStream> &,sal_Int32)797 void SAL_CALL OPreparedStatement::setBinaryStream(sal_Int32 parameter,
798 const Reference< XInputStream >& /* x */,
799 sal_Int32 /* length */)
800 {
801 OSL_TRACE("OPreparedStatement::setBinaryStream");
802 MutexGuard aGuard(m_aMutex);
803 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
804 checkParameterIndex(parameter);
805
806 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::setBinaryStream", *this);
807 }
808 /* }}} */
809
810
811 /* {{{ OPreparedStatement::clearParameters() -I- */
clearParameters()812 void SAL_CALL OPreparedStatement::clearParameters()
813 {
814 OSL_TRACE("OPreparedStatement::clearParameters");
815 MutexGuard aGuard(m_aMutex);
816 checkDisposed(OPreparedStatement::rBHelper.bDisposed);
817
818 try {
819 ((sql::PreparedStatement *)cppStatement)->clearParameters();
820 } catch (sql::MethodNotImplementedException) {
821 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::clearParameters", *this);
822 } catch (sql::SQLException &e) {
823 mysqlc_sdbc_driver::translateAndThrow(e, *this, m_pConnection->getConnectionEncoding());
824 }
825 }
826 /* }}} */
827
828
829 /* {{{ OPreparedStatement::clearBatch() -U- */
clearBatch()830 void SAL_CALL OPreparedStatement::clearBatch()
831 {
832 OSL_TRACE("OPreparedStatement::clearBatch");
833 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::clearBatch", *this);
834 }
835 /* }}} */
836
837
838 /* {{{ OPreparedStatement::addBatch() -U- */
addBatch()839 void SAL_CALL OPreparedStatement::addBatch()
840 {
841 OSL_TRACE("OPreparedStatement::addBatch");
842 mysqlc_sdbc_driver::throwFeatureNotImplementedException("OPreparedStatement::addBatch", *this);
843 }
844 /* }}} */
845
846
847 /* {{{ OPreparedStatement::executeBatch() -I- */
executeBatch()848 Sequence< sal_Int32 > SAL_CALL OPreparedStatement::executeBatch()
849 {
850 OSL_TRACE("OPreparedStatement::executeBatch");
851 Sequence< sal_Int32 > aRet= Sequence< sal_Int32 > ();
852 return aRet;
853 }
854 /* }}} */
855
856
857 /* {{{ OPreparedStatement::setFastPropertyValue_NoBroadcast() -I- */
setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any & rValue)858 void OPreparedStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue)
859 {
860 OSL_TRACE("OPreparedStatement::setFastPropertyValue_NoBroadcast");
861 switch(nHandle)
862 {
863 case PROPERTY_ID_RESULTSETCONCURRENCY:
864 break;
865 case PROPERTY_ID_RESULTSETTYPE:
866 break;
867 case PROPERTY_ID_FETCHDIRECTION:
868 break;
869 case PROPERTY_ID_USEBOOKMARKS:
870 break;
871 default:
872 /* XXX: Recursion ?? */
873 OPreparedStatement::setFastPropertyValue_NoBroadcast(nHandle,rValue);
874 }
875 }
876 /* }}} */
877
878
879 /* {{{ OPreparedStatement::checkParameterIndex() -I- */
checkParameterIndex(sal_Int32 column)880 void OPreparedStatement::checkParameterIndex(sal_Int32 column)
881 {
882 OSL_TRACE("OPreparedStatement::checkColumnIndex");
883 if (column < 1 || column > (sal_Int32) m_paramCount) {
884 OUString buf( RTL_CONSTASCII_USTRINGPARAM( "Parameter index out of range" ) );
885 throw SQLException(buf, *this, OUString(), 1, Any ());
886 }
887 }
888 /* }}} */
889
890
891 /*
892 * Local variables:
893 * tab-width: 4
894 * c-basic-offset: 4
895 * End:
896 * vim600: noet sw=4 ts=4 fdm=marker
897 * vim<600: noet sw=4 ts=4
898 */
899