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