connectivity/source/drivers/jdbc/PreparedStatement.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <java/sql/PreparedStatement.hxx>
  21 #include <java/sql/ResultSet.hxx>
  22 #include <java/sql/ResultSetMetaData.hxx>
  23 #include <java/sql/Connection.hxx>
  24 #include <java/sql/Timestamp.hxx>
  25 #include <java/math/BigDecimal.hxx>
  26 #include <java/tools.hxx>
  27 #include <cppuhelper/typeprovider.hxx>
  28 #include <cppuhelper/queryinterface.hxx>
  29 #include <comphelper/sequence.hxx>
  30 #include <comphelper/types.hxx>
  31 #include <connectivity/dbtools.hxx>
  32 #include <connectivity/FValue.hxx>
  33 #include <connectivity/dbexception.hxx>
  34 #include <strings.hrc>
  35 #include <resource/sharedresources.hxx>
  36 #include <java/LocalRef.hxx>
  37 #include <strings.hxx>
  38 #include <string.h>
  39 #include <memory>
  40
  41 using namespace connectivity;
  42 using namespace ::com::sun::star::uno;
  43 using namespace ::com::sun::star::sdbc;
  44 using namespace ::com::sun::star::container;
  45 using namespace ::com::sun::star::lang;
  46
  47
  48 //************ Class: java.sql.PreparedStatement
  49
  50 IMPLEMENT_SERVICE_INFO(java_sql_PreparedStatement,u"com.sun.star.sdbcx.JPreparedStatement"_ustr,u"com.sun.star.sdbc.PreparedStatement"_ustr);
  51
  52 java_sql_PreparedStatement::java_sql_PreparedStatement( JNIEnv * pEnv, java_sql_Connection& _rCon, const OUString& sql )
  53     : OStatement_BASE2( pEnv, _rCon )
  54 {
  55     m_sSqlStatement = sql;
  56 }
  57
  58 jclass java_sql_PreparedStatement::theClass = nullptr;
  59
  60 java_sql_PreparedStatement::~java_sql_PreparedStatement()
  61 {
  62 }
  63
  64
  65 jclass java_sql_PreparedStatement::getMyClass() const
  66 {
  67     // the class must be fetched only once, therefore static
  68     if( !theClass )
  69         theClass = findMyClass("java/sql/PreparedStatement");
  70     return theClass;
  71 }
  72
  73
  74 css::uno::Any SAL_CALL java_sql_PreparedStatement::queryInterface( const css::uno::Type & rType )
  75 {
  76     css::uno::Any aRet = OStatement_BASE2::queryInterface(rType);
  77     return aRet.hasValue() ? aRet : ::cppu::queryInterface( rType,
  78                                         static_cast< XPreparedStatement*>(this),
  79                                         static_cast< XParameters*>(this),
  80                                         static_cast< XResultSetMetaDataSupplier*>(this),
  81                                         static_cast< XPreparedBatchExecution*>(this));
  82 }
  83
  84 css::uno::Sequence< css::uno::Type > SAL_CALL java_sql_PreparedStatement::getTypes(  )
  85 {
  86     ::cppu::OTypeCollection aTypes( cppu::UnoType<XPreparedStatement>::get(),
  87                                     cppu::UnoType<XParameters>::get(),
  88                                     cppu::UnoType<XResultSetMetaDataSupplier>::get(),
  89                                     cppu::UnoType<XPreparedBatchExecution>::get());
  90
  91     return ::comphelper::concatSequences(aTypes.getTypes(),OStatement_BASE2::getTypes());
  92 }
  93
  94
  95 sal_Bool SAL_CALL java_sql_PreparedStatement::execute(  )
  96 {
  97     m_aLogger.log( LogLevel::FINE, STR_LOG_EXECUTING_PREPARED );
  98     ::osl::MutexGuard aGuard( m_aMutex );
  99     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 100
 101     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 102     createStatement(t.pEnv);
 103     static jmethodID mID(nullptr);
 104     return callBooleanMethod( "execute", mID );
 105 }
 106
 107
 108 sal_Int32 SAL_CALL java_sql_PreparedStatement::executeUpdate(  )
 109 {
 110     ::osl::MutexGuard aGuard( m_aMutex );
 111     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 112     m_aLogger.log( LogLevel::FINE, STR_LOG_EXECUTING_PREPARED_UPDATE );
 113
 114     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 115     createStatement(t.pEnv);
 116     static jmethodID mID(nullptr);
 117     return callIntMethod_ThrowSQL("executeUpdate", mID);
 118 }
 119
 120
 121 void SAL_CALL java_sql_PreparedStatement::setString( sal_Int32 parameterIndex, const OUString& x )
 122 {
 123     ::osl::MutexGuard aGuard( m_aMutex );
 124     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 125     m_aLogger.log( LogLevel::FINER, STR_LOG_STRING_PARAMETER, parameterIndex, x );
 126
 127     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 128     {       // initialize temporary Variable
 129         createStatement(t.pEnv);
 130         static const char * const cSignature = "(ILjava/lang/String;)V";
 131         static const char * const cMethodName = "setString";
 132         // Java-Call
 133         static jmethodID mID(nullptr);
 134         obtainMethodId_throwSQL(t.pEnv, cMethodName,cSignature, mID);
 135         jdbc::LocalRef< jstring > str( t.env(),convertwchar_tToJavaString(t.pEnv,x));
 136         t.pEnv->CallVoidMethod( object, mID, parameterIndex,str.get());
 137         // and clean up
 138         ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
 139     } //t.pEnv
 140 }
 141
 142
 143 css::uno::Reference< css::sdbc::XConnection > SAL_CALL java_sql_PreparedStatement::getConnection(  )
 144 {
 145     return m_pConnection;
 146 }
 147
 148
 149 css::uno::Reference< css::sdbc::XResultSet > SAL_CALL java_sql_PreparedStatement::executeQuery(  )
 150 {
 151     m_aLogger.log( LogLevel::FINE, STR_LOG_EXECUTING_PREPARED_QUERY );
 152     ::osl::MutexGuard aGuard( m_aMutex );
 153     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 154
 155     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 156     createStatement(t.pEnv);
 157     static jmethodID mID(nullptr);
 158     jobject out = callResultSetMethod(t.env(),"executeQuery",mID);
 159
 160     return out==nullptr ? nullptr : new java_sql_ResultSet( t.pEnv, out, m_aLogger, *m_pConnection,this);
 161 }
 162
 163
 164 void SAL_CALL java_sql_PreparedStatement::setBoolean( sal_Int32 parameterIndex, sal_Bool x )
 165 {
 166     m_aLogger.log( LogLevel::FINER, STR_LOG_BOOLEAN_PARAMETER, parameterIndex, bool(x) );
 167     ::osl::MutexGuard aGuard( m_aMutex );
 168     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 169
 170     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 171     createStatement(t.pEnv);
 172     static jmethodID mID(nullptr);
 173     callVoidMethod_ThrowSQL("setBoolean", "(IZ)V", mID, parameterIndex, x);
 174 }
 175
 176
 177 void SAL_CALL java_sql_PreparedStatement::setByte( sal_Int32 parameterIndex, sal_Int8 x )
 178 {
 179     m_aLogger.log( LogLevel::FINER, STR_LOG_BYTE_PARAMETER, parameterIndex, static_cast<sal_Int32>(x) );
 180     ::osl::MutexGuard aGuard( m_aMutex );
 181     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 182
 183     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 184     createStatement(t.pEnv);
 185     static jmethodID mID(nullptr);
 186     callVoidMethod_ThrowSQL("setByte", "(IB)V", mID, parameterIndex, x);
 187 }
 188
 189
 190 void SAL_CALL java_sql_PreparedStatement::setDate( sal_Int32 parameterIndex, const css::util::Date& x )
 191 {
 192     m_aLogger.log( LogLevel::FINER, STR_LOG_DATE_PARAMETER, parameterIndex, x );
 193     ::osl::MutexGuard aGuard( m_aMutex );
 194     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 195
 196     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 197     createStatement(t.pEnv);
 198     java_sql_Date aT(x);
 199     static jmethodID mID(nullptr);
 200     callVoidMethod_ThrowSQL("setDate", "(ILjava/sql/Date;)V", mID, parameterIndex, aT.getJavaObject());
 201 }
 202
 203
 204 void SAL_CALL java_sql_PreparedStatement::setTime( sal_Int32 parameterIndex, const css::util::Time& x )
 205 {
 206     m_aLogger.log( LogLevel::FINER, STR_LOG_TIME_PARAMETER, parameterIndex, x );
 207     ::osl::MutexGuard aGuard( m_aMutex );
 208     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 209
 210     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 211     createStatement(t.pEnv);
 212     java_sql_Time aT(x);
 213     static jmethodID mID(nullptr);
 214     callVoidMethod_ThrowSQL("setTime", "(ILjava/sql/Time;)V", mID, parameterIndex, aT.getJavaObject());
 215 }
 216
 217
 218 void SAL_CALL java_sql_PreparedStatement::setTimestamp( sal_Int32 parameterIndex, const css::util::DateTime& x )
 219 {
 220     m_aLogger.log( LogLevel::FINER, STR_LOG_TIMESTAMP_PARAMETER, parameterIndex, x );
 221     ::osl::MutexGuard aGuard( m_aMutex );
 222     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 223
 224     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 225     createStatement(t.pEnv);
 226     static jmethodID mID(nullptr);
 227     java_sql_Timestamp aD(x);
 228     callVoidMethod_ThrowSQL("setTimestamp", "(ILjava/sql/Timestamp;)V", mID, parameterIndex, aD.getJavaObject());
 229 }
 230
 231 void SAL_CALL java_sql_PreparedStatement::setDouble( sal_Int32 parameterIndex, double x )
 232 {
 233     m_aLogger.log( LogLevel::FINER, STR_LOG_DOUBLE_PARAMETER, parameterIndex, x );
 234     ::osl::MutexGuard aGuard( m_aMutex );
 235     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 236
 237     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 238     createStatement(t.pEnv);
 239     static jmethodID mID(nullptr);
 240     callVoidMethod_ThrowSQL("setDouble", "(ID)V", mID, parameterIndex, x);
 241 }
 242
 243
 244 void SAL_CALL java_sql_PreparedStatement::setFloat( sal_Int32 parameterIndex, float x )
 245 {
 246     m_aLogger.log( LogLevel::FINER, STR_LOG_FLOAT_PARAMETER, parameterIndex, x );
 247     ::osl::MutexGuard aGuard( m_aMutex );
 248     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 249
 250     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 251     createStatement(t.pEnv);
 252     static jmethodID mID(nullptr);
 253     callVoidMethod_ThrowSQL("setFloat", "(IF)V", mID, parameterIndex, x);
 254 }
 255
 256
 257 void SAL_CALL java_sql_PreparedStatement::setInt( sal_Int32 parameterIndex, sal_Int32 x )
 258 {
 259     m_aLogger.log( LogLevel::FINER, STR_LOG_INT_PARAMETER, parameterIndex, x );
 260     ::osl::MutexGuard aGuard( m_aMutex );
 261     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 262
 263     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 264     createStatement(t.pEnv);
 265     static jmethodID mID(nullptr);
 266     callVoidMethod_ThrowSQL("setInt", "(II)V", mID, parameterIndex, x);
 267 }
 268
 269
 270 void SAL_CALL java_sql_PreparedStatement::setLong( sal_Int32 parameterIndex, sal_Int64 x )
 271 {
 272     m_aLogger.log( LogLevel::FINER, STR_LOG_LONG_PARAMETER, parameterIndex, x );
 273     ::osl::MutexGuard aGuard( m_aMutex );
 274     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 275
 276     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 277     createStatement(t.pEnv);
 278     static jmethodID mID(nullptr);
 279     callVoidMethod_ThrowSQL("setLong", "(IJ)V", mID, parameterIndex, x);
 280 }
 281
 282
 283 void SAL_CALL java_sql_PreparedStatement::setNull( sal_Int32 parameterIndex, sal_Int32 sqlType )
 284 {
 285     m_aLogger.log( LogLevel::FINER, STR_LOG_NULL_PARAMETER, parameterIndex, sqlType );
 286     ::osl::MutexGuard aGuard( m_aMutex );
 287     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 288
 289     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 290     createStatement(t.pEnv);
 291     static jmethodID mID(nullptr);
 292     callVoidMethod_ThrowSQL("setNull", "(II)V", mID, parameterIndex, sqlType);
 293 }
 294
 295
 296 void SAL_CALL java_sql_PreparedStatement::setClob( sal_Int32 /*parameterIndex*/, const css::uno::Reference< css::sdbc::XClob >& /*x*/ )
 297 {
 298     ::dbtools::throwFeatureNotImplementedSQLException( u"XParameters::setClob"_ustr, *this );
 299 }
 300
 301
 302 void SAL_CALL java_sql_PreparedStatement::setBlob( sal_Int32 /*parameterIndex*/, const css::uno::Reference< css::sdbc::XBlob >& /*x*/ )
 303 {
 304     ::dbtools::throwFeatureNotImplementedSQLException( u"XParameters::setBlob"_ustr, *this );
 305 }
 306
 307
 308 void SAL_CALL java_sql_PreparedStatement::setArray( sal_Int32 /*parameterIndex*/, const css::uno::Reference< css::sdbc::XArray >& /*x*/ )
 309 {
 310     ::dbtools::throwFeatureNotImplementedSQLException( u"XParameters::setArray"_ustr, *this );
 311 }
 312
 313
 314 void SAL_CALL java_sql_PreparedStatement::setRef( sal_Int32 /*parameterIndex*/, const css::uno::Reference< css::sdbc::XRef >& /*x*/ )
 315 {
 316     ::dbtools::throwFeatureNotImplementedSQLException( u"XParameters::setRef"_ustr, *this );
 317 }
 318
 319
 320 void SAL_CALL java_sql_PreparedStatement::setObjectWithInfo( sal_Int32 parameterIndex, const css::uno::Any& x, sal_Int32 targetSqlType, sal_Int32 scale )
 321 {
 322     m_aLogger.log( LogLevel::FINER, STR_LOG_OBJECT_NULL_PARAMETER, parameterIndex );
 323     ::osl::MutexGuard aGuard( m_aMutex );
 324     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 325
 326     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 327     {
 328         createStatement(t.pEnv);
 329
 330         // initialize temporary Variable
 331         static const char * const cSignature = "(ILjava/lang/Object;II)V";
 332         static const char * const cMethodName = "setObject";
 333         // Java-Call
 334         static jmethodID mID(nullptr);
 335         obtainMethodId_throwSQL(t.pEnv, cMethodName,cSignature, mID);
 336         {
 337             jobject obj = nullptr;
 338             switch(targetSqlType)
 339             {
 340                 case DataType::DECIMAL:
 341                 case DataType::NUMERIC:
 342                     {
 343                         double nTemp = 0.0;
 344
 345                         std::unique_ptr<java_math_BigDecimal> pBigDecimal;
 346                         if ( x >>= nTemp)
 347                         {
 348                             pBigDecimal.reset(new java_math_BigDecimal(nTemp));
 349                             //setDouble(parameterIndex,nTemp);
 350                             //return;
 351                         }
 352                         else
 353                         {
 354                             ORowSetValue aValue;
 355                             aValue.fill(x);
 356                             const OUString sValue = aValue.getString();
 357                             if ( !sValue.isEmpty() )
 358                                 pBigDecimal.reset(new java_math_BigDecimal(sValue));
 359                             else
 360                                 pBigDecimal.reset(new java_math_BigDecimal(0.0));
 361                         }
 362                             //obj = convertwchar_tToJavaString(t.pEnv,::comphelper::getString(x));
 363                         t.pEnv->CallVoidMethod( object, mID, parameterIndex,pBigDecimal->getJavaObject(),targetSqlType,scale);
 364                         ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
 365                         return;
 366                     }
 367                 default:
 368                     obj = convertwchar_tToJavaString(t.pEnv,::comphelper::getString(x));
 369                     break;
 370             }
 371             t.pEnv->CallVoidMethod( object, mID, parameterIndex,obj,targetSqlType,scale);
 372             t.pEnv->DeleteLocalRef(obj);
 373             ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
 374             // and clean up
 375         } //mID
 376     } //t.pEnv
 377 }
 378
 379
 380 void SAL_CALL java_sql_PreparedStatement::setObjectNull( sal_Int32 parameterIndex, sal_Int32 /*sqlType*/, const OUString& /*typeName*/ )
 381 {
 382     m_aLogger.log( LogLevel::FINER, STR_LOG_OBJECT_NULL_PARAMETER, parameterIndex );
 383     ::osl::MutexGuard aGuard( m_aMutex );
 384     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 385
 386     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 387     createStatement(t.pEnv);
 388     static jmethodID mID(nullptr);
 389     callVoidMethod_ThrowSQL<jobject>("setObject", "(ILjava/lang/Object;)V", mID, parameterIndex, nullptr);
 390 }
 391
 392
 393 void SAL_CALL java_sql_PreparedStatement::setObject( sal_Int32 parameterIndex, const css::uno::Any& x )
 394 {
 395     if(!::dbtools::implSetObject(this,parameterIndex,x))
 396     {
 397         const OUString sError( m_pConnection->getResources().getResourceStringWithSubstitution(
 398                 STR_UNKNOWN_PARA_TYPE,
 399                 "$position$", OUString::number(parameterIndex)
 400              ) );
 401         ::dbtools::throwGenericSQLException(sError,*this);
 402     }
 403 }
 404
 405
 406 void SAL_CALL java_sql_PreparedStatement::setShort( sal_Int32 parameterIndex, sal_Int16 x )
 407 {
 408     m_aLogger.log( LogLevel::FINER, STR_LOG_SHORT_PARAMETER, parameterIndex, x );
 409     ::osl::MutexGuard aGuard( m_aMutex );
 410     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 411
 412     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 413     createStatement(t.pEnv);
 414     static jmethodID mID(nullptr);
 415     callVoidMethod_ThrowSQL("setShort", "(IS)V", mID, parameterIndex, x);
 416 }
 417
 418
 419 void SAL_CALL java_sql_PreparedStatement::setBytes( sal_Int32 parameterIndex, const css::uno::Sequence< sal_Int8 >& x )
 420 {
 421     m_aLogger.log( LogLevel::FINER, STR_LOG_BYTES_PARAMETER, parameterIndex );
 422     ::osl::MutexGuard aGuard( m_aMutex );
 423     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 424
 425     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 426     {
 427         createStatement(t.pEnv);
 428
 429         // initialize temporary Variable
 430         static const char * const cSignature = "(I[B)V";
 431         static const char * const cMethodName = "setBytes";
 432         // Java-Call
 433         static jmethodID mID(nullptr);
 434         obtainMethodId_throwSQL(t.pEnv, cMethodName,cSignature, mID);
 435         jbyteArray pByteArray = t.pEnv->NewByteArray(x.getLength());
 436         jbyte * pData = reinterpret_cast<jbyte *>(
 437             const_cast<sal_Int8 *>(x.getConstArray()));
 438             // 4th param of Set*ArrayRegion changed from pointer to non-const to
 439             // pointer to const between <http://docs.oracle.com/javase/6/docs/
 440             // technotes/guides/jni/spec/functions.html#wp22933> and
 441             // <http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/
 442             // functions.html#wp22933>; work around that difference in a way
 443             // that doesn't trigger loplugin:redundantcast
 444         t.pEnv->SetByteArrayRegion(pByteArray,0,x.getLength(),pData);
 445         t.pEnv->CallVoidMethod( object, mID, parameterIndex,pByteArray);
 446         t.pEnv->DeleteLocalRef(pByteArray);
 447         ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
 448     } //t.pEnv
 449 }
 450
 451
 452 void SAL_CALL java_sql_PreparedStatement::setCharacterStream( sal_Int32 parameterIndex, const css::uno::Reference< css::io::XInputStream >& x, sal_Int32 length )
 453 {
 454     m_aLogger.log( LogLevel::FINER, STR_LOG_CHARSTREAM_PARAMETER, parameterIndex );
 455     ::osl::MutexGuard aGuard( m_aMutex );
 456     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 457
 458     SDBThreadAttach t;
 459     assert(t.pEnv && "Java environment has been deleted!");
 460     {
 461         createStatement(t.pEnv);
 462
 463         // initialize temporary variable
 464         static const char * const cSignature = "(ILjava/io/InputStream;I)V";
 465         static const char * const cMethodName = "setCharacterStream";
 466         // Java-Call
 467         static jmethodID mID(nullptr);
 468         obtainMethodId_throwSQL(t.pEnv, cMethodName,cSignature, mID);
 469         Sequence< sal_Int8 > aSeq;
 470         if ( x.is() )
 471             x->readBytes( aSeq, length );
 472         sal_Int32 actualLength = aSeq.getLength();
 473
 474         jvalue args2[3];
 475         jbyteArray pByteArray = t.pEnv->NewByteArray( actualLength );
 476         jbyte * aSeqData = reinterpret_cast<jbyte *>(
 477             const_cast<sal_Int8 *>(aSeq.getConstArray()));
 478             // 4th param of Set*ArrayRegion changed from pointer to non-const to
 479             // pointer to const between <http://docs.oracle.com/javase/6/docs/
 480             // technotes/guides/jni/spec/functions.html#wp22933> and
 481             // <http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/
 482             // functions.html#wp22933>; work around that difference in a way
 483             // that doesn't trigger loplugin:redundantcast
 484         t.pEnv->SetByteArrayRegion(pByteArray,0,actualLength,aSeqData);
 485         args2[0].l =  pByteArray;
 486         args2[1].i =  0;
 487         args2[2].i =  actualLength;
 488         // Java-Call
 489         jclass aClass = t.pEnv->FindClass("java/io/CharArrayInputStream");
 490         static jmethodID mID2 = nullptr;
 491         if ( !mID2 )
 492         {
 493             // initialize temporary variable
 494             const char * const cSignatureStream = "([BII)V";
 495             mID2  = t.pEnv->GetMethodID( aClass, "<init>", cSignatureStream );
 496         }
 497         jobject tempObj = nullptr;
 498         if(mID2)
 499             tempObj = t.pEnv->NewObjectA( aClass, mID2, args2 );
 500
 501         t.pEnv->CallVoidMethod( object, mID, parameterIndex,tempObj,actualLength);
 502         // and clean up
 503         t.pEnv->DeleteLocalRef(pByteArray);
 504         t.pEnv->DeleteLocalRef(tempObj);
 505         t.pEnv->DeleteLocalRef(aClass);
 506         ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
 507     } //t.pEnv
 508 }
 509
 510
 511 void SAL_CALL java_sql_PreparedStatement::setBinaryStream( sal_Int32 parameterIndex, const css::uno::Reference< css::io::XInputStream >& x, sal_Int32 length )
 512 {
 513     m_aLogger.log( LogLevel::FINER, STR_LOG_BINARYSTREAM_PARAMETER, parameterIndex );
 514     ::osl::MutexGuard aGuard( m_aMutex );
 515     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 516
 517     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 518     {
 519         createStatement(t.pEnv);
 520         // initialize temporary variable
 521         static const char * const cSignature = "(ILjava/io/InputStream;I)V";
 522         static const char * const cMethodName = "setBinaryStream";
 523         // Java-Call
 524         static jmethodID mID(nullptr);
 525         obtainMethodId_throwSQL(t.pEnv, cMethodName,cSignature, mID);
 526         {
 527             Sequence< sal_Int8 > aSeq;
 528             if ( x.is() )
 529                 x->readBytes( aSeq, length );
 530             sal_Int32 actualLength = aSeq.getLength();
 531
 532             jvalue args2[3];
 533             jbyteArray pByteArray = t.pEnv->NewByteArray(actualLength);
 534             jbyte * aSeqData = reinterpret_cast<jbyte *>(
 535                 const_cast<sal_Int8 *>(aSeq.getConstArray()));
 536             // 4th param of Set*ArrayRegion changed from pointer to non-const to
 537             // pointer to const between <http://docs.oracle.com/javase/6/docs/
 538             // technotes/guides/jni/spec/functions.html#wp22933> and
 539             // <http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/
 540             // functions.html#wp22933>; work around that difference in a way
 541             // that doesn't trigger loplugin:redundantcast
 542             t.pEnv->SetByteArrayRegion(pByteArray,0,actualLength,aSeqData);
 543             args2[0].l = pByteArray;
 544             args2[1].i = 0;
 545             args2[2].i = actualLength;
 546
 547             // Java-Call
 548             jclass aClass = t.pEnv->FindClass("java/io/ByteArrayInputStream");
 549             static jmethodID mID2 = nullptr;
 550             if ( !mID2 )
 551             {
 552                 // initialize temporary variable
 553                 const char * const cSignatureStream = "([BII)V";
 554                 mID2  = t.pEnv->GetMethodID( aClass, "<init>", cSignatureStream );
 555             }
 556             jobject tempObj = nullptr;
 557             if(mID2)
 558                 tempObj = t.pEnv->NewObjectA( aClass, mID2, args2 );
 559             t.pEnv->CallVoidMethod( object, mID, parameterIndex,tempObj,actualLength);
 560             // and clean up
 561             t.pEnv->DeleteLocalRef(pByteArray);
 562             t.pEnv->DeleteLocalRef(tempObj);
 563             t.pEnv->DeleteLocalRef(aClass);
 564             ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
 565         }
 566     } //t.pEnv
 567 }
 568
 569
 570 void SAL_CALL java_sql_PreparedStatement::clearParameters(  )
 571 {
 572     m_aLogger.log( LogLevel::FINER, STR_LOG_CLEAR_PARAMETERS );
 573     ::osl::MutexGuard aGuard( m_aMutex );
 574     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 575
 576     SDBThreadAttach t;
 577     {
 578         createStatement(t.pEnv);
 579
 580         static jmethodID mID(nullptr);
 581         callVoidMethod_ThrowSQL("clearParameters",mID);
 582     } //t.pEnv
 583 }
 584
 585 void SAL_CALL java_sql_PreparedStatement::clearBatch(  )
 586 {
 587     ::osl::MutexGuard aGuard( m_aMutex );
 588     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 589     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 590     {
 591         createStatement(t.pEnv);
 592         static jmethodID mID(nullptr);
 593         callVoidMethod_ThrowSQL("clearBatch",mID);
 594     } //t.pEnv
 595 }
 596
 597
 598 void SAL_CALL java_sql_PreparedStatement::addBatch( )
 599 {
 600     ::osl::MutexGuard aGuard( m_aMutex );
 601     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 602     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 603     {
 604         createStatement(t.pEnv);
 605         static jmethodID mID(nullptr);
 606         callVoidMethod_ThrowSQL("addBatch", mID);
 607     } //t.pEnv
 608 }
 609
 610
 611 css::uno::Sequence< sal_Int32 > SAL_CALL java_sql_PreparedStatement::executeBatch(  )
 612 {
 613     ::osl::MutexGuard aGuard( m_aMutex );
 614     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 615     css::uno::Sequence< sal_Int32 > aSeq;
 616     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 617     createStatement(t.pEnv);
 618     static jmethodID mID(nullptr);
 619     jintArray out = static_cast<jintArray>(callObjectMethod(t.pEnv,"executeBatch","()[I", mID));
 620     if(out)
 621     {
 622         jboolean p = false;
 623         aSeq.realloc(t.pEnv->GetArrayLength(out));
 624         memcpy(aSeq.getArray(),t.pEnv->GetIntArrayElements(out,&p),aSeq.getLength());
 625         t.pEnv->DeleteLocalRef(out);
 626     }
 627     return aSeq;
 628 }
 629
 630 css::uno::Reference< css::sdbc::XResultSetMetaData > SAL_CALL java_sql_PreparedStatement::getMetaData(  )
 631 {
 632     ::osl::MutexGuard aGuard( m_aMutex );
 633     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 634     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java environment has been deleted!");
 635     createStatement(t.pEnv);
 636     static jmethodID mID(nullptr);
 637     jobject out = callObjectMethod(t.pEnv,"getMetaData","()Ljava/sql/ResultSetMetaData;", mID);
 638
 639     return out==nullptr ? nullptr : new java_sql_ResultSetMetaData( t.pEnv, out, *m_pConnection );
 640 }
 641
 642 void SAL_CALL java_sql_PreparedStatement::acquire() noexcept
 643 {
 644     OStatement_BASE2::acquire();
 645 }
 646
 647 void SAL_CALL java_sql_PreparedStatement::release() noexcept
 648 {
 649     OStatement_BASE2::release();
 650 }
 651
 652 void java_sql_PreparedStatement::createStatement(JNIEnv* _pEnv)
 653 {
 654     ::osl::MutexGuard aGuard( m_aMutex );
 655     checkDisposed(java_sql_Statement_BASE::rBHelper.bDisposed);
 656
 657     if( object || !_pEnv )
 658         return;
 659
 660     // initialize temporary variable
 661     static const char * const cMethodName = "prepareStatement";
 662
 663     jvalue args[1];
 664     // convert Parameter
 665     args[0].l = convertwchar_tToJavaString(_pEnv,m_sSqlStatement);
 666     // Java-Call
 667     jobject out = nullptr;
 668     static jmethodID mID(nullptr);
 669     if ( !mID )
 670     {
 671         static const char * const cSignature = "(Ljava/lang/String;II)Ljava/sql/PreparedStatement;";
 672         mID  = _pEnv->GetMethodID( m_pConnection->getMyClass(), cMethodName, cSignature );
 673     }
 674     if( mID )
 675     {
 676         out = _pEnv->CallObjectMethod( m_pConnection->getJavaObject(), mID, args[0].l ,m_nResultSetType,m_nResultSetConcurrency);
 677     }
 678     else
 679     {
 680         static jmethodID mID2 = nullptr;
 681         if ( !mID2 )
 682         {
 683             static const char * const cSignature2 = "(Ljava/lang/String;)Ljava/sql/PreparedStatement;";
 684             mID2 = _pEnv->GetMethodID( m_pConnection->getMyClass(), cMethodName, cSignature2 );
 685         }
 686         if ( mID2 )
 687             out = _pEnv->CallObjectMethod( m_pConnection->getJavaObject(), mID2, args[0].l );
 688     }
 689     _pEnv->DeleteLocalRef(static_cast<jstring>(args[0].l));
 690     ThrowLoggedSQLException( m_aLogger, _pEnv, *this );
 691     if ( out )
 692         object = _pEnv->NewGlobalRef( out );
 693 }
 694
 695
 696 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */