~ubuntu-branches/ubuntu/trusty/mysql-connector-java/trusty

Viewing changes to .pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/jdbc2/optional/StatementWrapper.java

Committer: Package Import Robot
Author(s): Emmanuel Bourg, Miguel Landaeta
Date: 2013-07-02 17:07:51 UTC
mfrom: (1.1.8) (3.1.6 sid)
Revision ID: package-import@ubuntu.com-20130702170751-f4rszjabxg0391fr

Tags: 5.1.25-1

http://bugs.debian.org/706668

http://bugs.debian.org/654122

* New upstream release
* Refreshed the patches
* Added a patch to build with one JDK and removed the build
dependency on java-gcj-compat-dev
* Updated Standards-Version to 3.9.4 (no changes)
* Use canonical URLs for the Vcs-* fields
* debian/rules: Improved the clean target to allow rebuilds
* Updated the watch file
* Renamed debian/README.Debian-source to README.source

[ Miguel Landaeta ]
* Fix FTBFS with OpenJDK 7 (Closes: #706668)
* Remove Michael Koch from Uploaders list.
Thanks for your work on this package. (Closes: #654122).

files added:
.pc/.quilt_patches

.pc/.quilt_series

.pc/0002-java6-compilation-compat.patch

.pc/0002-java6-compilation-compat.patch/src

.pc/0002-java6-compilation-compat.patch/src/com

.pc/0002-java6-compilation-compat.patch/src/com/mysql

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/CallableStatement.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/ConnectionImpl.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/DatabaseMetaData.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/LoadBalancedMySQLConnection.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/MysqlParameterMetadata.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/NonRegisteringDriver.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/PreparedStatement.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/ReplicationConnection.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/ResultSetImpl.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/ResultSetMetaData.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/StatementImpl.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/jdbc2

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/jdbc2/optional

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/jdbc2/optional/CallableStatementWrapper.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/jdbc2/optional/ConnectionWrapper.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/jdbc2/optional/MysqlDataSource.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/jdbc2/optional/MysqlPooledConnection.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/jdbc2/optional/PreparedStatementWrapper.java

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/jdbc2/optional/StatementWrapper.java

.pc/0002-java6-compilation-compat.patch/src/testsuite

.pc/0002-java6-compilation-compat.patch/src/testsuite/regression

.pc/0002-java6-compilation-compat.patch/src/testsuite/regression/StatementRegressionTest.java

debian/README.source

debian/patches/0002-java6-compilation-compat.patch

src/com/mysql/jdbc/AbandonedConnectionCleanupThread.java

src/com/mysql/jdbc/AuthenticationPlugin.java

src/com/mysql/jdbc/CacheAdapter.java

src/com/mysql/jdbc/CacheAdapterFactory.java

src/com/mysql/jdbc/NetworkResources.java

src/com/mysql/jdbc/PerConnectionLRUFactory.java

src/com/mysql/jdbc/PerVmServerConfigCacheFactory.java

src/com/mysql/jdbc/authentication

src/com/mysql/jdbc/authentication/MysqlClearPasswordPlugin.java

src/com/mysql/jdbc/authentication/MysqlNativePasswordPlugin.java

src/com/mysql/jdbc/authentication/MysqlOldPasswordPlugin.java

src/com/mysql/jdbc/authentication/Sha256PasswordPlugin.java

src/com/mysql/jdbc/exceptions/MySQLQueryInterruptedException.java

src/testsuite/regression/SyntaxRegressionTest.java

src/testsuite/simple/TestBug57662Logger.java

files removed:
debian/README.Debian

debian/README.Debian-source

src/testsuite/regression/AppletRegressionTest.java

src/testsuite/regression/jdbc4

src/testsuite/regression/jdbc4/ConnectionRegressionTest.java

files modified:
.pc/0001-disable-testsuite.patch/build.xml

.pc/applied-patches

CHANGES

README

README.txt

build.xml

debian/changelog

debian/control

debian/patches/0001-disable-testsuite.patch

debian/patches/series

debian/rules

debian/watch

src/com/mysql/jdbc/AssertionFailedException.java

src/com/mysql/jdbc/BestResponseTimeBalanceStrategy.java

src/com/mysql/jdbc/BlobFromLocator.java

src/com/mysql/jdbc/Buffer.java

src/com/mysql/jdbc/BufferRow.java

src/com/mysql/jdbc/CachedResultSetMetaData.java

src/com/mysql/jdbc/CallableStatement.java

src/com/mysql/jdbc/CharsetMapping.java

src/com/mysql/jdbc/Clob.java

src/com/mysql/jdbc/CommunicationsException.java

src/com/mysql/jdbc/Connection.java

src/com/mysql/jdbc/ConnectionFeatureNotAvailableException.java

src/com/mysql/jdbc/ConnectionGroup.java

src/com/mysql/jdbc/ConnectionGroupManager.java

src/com/mysql/jdbc/ConnectionImpl.java

src/com/mysql/jdbc/ConnectionProperties.java

src/com/mysql/jdbc/ConnectionPropertiesImpl.java

src/com/mysql/jdbc/DatabaseMetaData.java

src/com/mysql/jdbc/DatabaseMetaDataUsingInfoSchema.java

src/com/mysql/jdbc/DocsConnectionPropsHelper.java

src/com/mysql/jdbc/EscapeProcessor.java

src/com/mysql/jdbc/FailoverConnectionProxy.java

src/com/mysql/jdbc/Field.java

src/com/mysql/jdbc/IterateBlock.java

src/com/mysql/jdbc/JDBC4Connection.java

src/com/mysql/jdbc/JDBC4LoadBalancedMySQLConnection.java

src/com/mysql/jdbc/JDBC4ResultSet.java

src/com/mysql/jdbc/LicenseConfiguration.java

src/com/mysql/jdbc/LoadBalancedAutoCommitInterceptor.java

src/com/mysql/jdbc/LoadBalancedMySQLConnection.java

src/com/mysql/jdbc/LoadBalancingConnectionProxy.java

src/com/mysql/jdbc/LocalizedErrorMessages.properties

src/com/mysql/jdbc/MySQLConnection.java

src/com/mysql/jdbc/MysqlDataTruncation.java

src/com/mysql/jdbc/MysqlDefs.java

src/com/mysql/jdbc/MysqlErrorNumbers.java

src/com/mysql/jdbc/MysqlIO.java

src/com/mysql/jdbc/MysqlParameterMetadata.java

src/com/mysql/jdbc/MysqlSavepoint.java

src/com/mysql/jdbc/NonRegisteringDriver.java

src/com/mysql/jdbc/NonRegisteringReplicationDriver.java

src/com/mysql/jdbc/NotImplemented.java

src/com/mysql/jdbc/OperationNotSupportedException.java

src/com/mysql/jdbc/PacketTooBigException.java

src/com/mysql/jdbc/PreparedStatement.java

src/com/mysql/jdbc/ProfilerEventHandlerFactory.java

src/com/mysql/jdbc/RandomBalanceStrategy.java

src/com/mysql/jdbc/ReflectiveStatementInterceptorAdapter.java

src/com/mysql/jdbc/ReplicationConnection.java

src/com/mysql/jdbc/ResultSetImpl.java

src/com/mysql/jdbc/ResultSetInternalMethods.java

src/com/mysql/jdbc/ResultSetMetaData.java

src/com/mysql/jdbc/ResultSetRow.java

src/com/mysql/jdbc/RowDataCursor.java

src/com/mysql/jdbc/RowDataDynamic.java

src/com/mysql/jdbc/RowDataStatic.java

src/com/mysql/jdbc/SQLError.java

src/com/mysql/jdbc/Security.java

src/com/mysql/jdbc/SequentialBalanceStrategy.java

src/com/mysql/jdbc/ServerPreparedStatement.java

src/com/mysql/jdbc/SingleByteCharsetConverter.java

src/com/mysql/jdbc/StandardLoadBalanceExceptionChecker.java

src/com/mysql/jdbc/StandardSocketFactory.java

src/com/mysql/jdbc/StatementImpl.java

src/com/mysql/jdbc/StringUtils.java

src/com/mysql/jdbc/TimeUtil.java

src/com/mysql/jdbc/UpdatableResultSet.java

src/com/mysql/jdbc/Util.java

src/com/mysql/jdbc/configs/maxPerformance.properties

src/com/mysql/jdbc/exceptions/MySQLDataException.java

src/com/mysql/jdbc/exceptions/MySQLIntegrityConstraintViolationException.java

src/com/mysql/jdbc/exceptions/MySQLInvalidAuthorizationSpecException.java

src/com/mysql/jdbc/exceptions/MySQLNonTransientConnectionException.java

src/com/mysql/jdbc/exceptions/MySQLNonTransientException.java

src/com/mysql/jdbc/exceptions/MySQLStatementCancelledException.java

src/com/mysql/jdbc/exceptions/MySQLSyntaxErrorException.java

src/com/mysql/jdbc/exceptions/MySQLTimeoutException.java

src/com/mysql/jdbc/exceptions/MySQLTransactionRollbackException.java

src/com/mysql/jdbc/exceptions/MySQLTransientConnectionException.java

src/com/mysql/jdbc/exceptions/MySQLTransientException.java

src/com/mysql/jdbc/integration/jboss/ExtendedMysqlExceptionSorter.java

src/com/mysql/jdbc/interceptors/ResultSetScannerInterceptor.java

src/com/mysql/jdbc/interceptors/ServerStatusDiffInterceptor.java

src/com/mysql/jdbc/interceptors/SessionAssociationInterceptor.java

src/com/mysql/jdbc/jdbc2/optional/CallableStatementWrapper.java

src/com/mysql/jdbc/jdbc2/optional/ConnectionWrapper.java

src/com/mysql/jdbc/jdbc2/optional/MysqlConnectionPoolDataSource.java

src/com/mysql/jdbc/jdbc2/optional/MysqlDataSource.java

src/com/mysql/jdbc/jdbc2/optional/MysqlDataSourceFactory.java

src/com/mysql/jdbc/jdbc2/optional/MysqlPooledConnection.java

src/com/mysql/jdbc/jdbc2/optional/MysqlXAConnection.java

src/com/mysql/jdbc/jdbc2/optional/MysqlXADataSource.java

src/com/mysql/jdbc/jdbc2/optional/MysqlXAException.java

src/com/mysql/jdbc/jdbc2/optional/MysqlXid.java

src/com/mysql/jdbc/jdbc2/optional/PreparedStatementWrapper.java

src/com/mysql/jdbc/jdbc2/optional/StatementWrapper.java

src/com/mysql/jdbc/jdbc2/optional/SuspendableXAConnection.java

src/com/mysql/jdbc/jdbc2/optional/WrapperBase.java

src/com/mysql/jdbc/log/Jdk14Logger.java

src/com/mysql/jdbc/log/LogFactory.java

src/com/mysql/jdbc/log/LogUtils.java

src/com/mysql/jdbc/log/Slf4JLogger.java

src/com/mysql/jdbc/log/StandardLogger.java

src/com/mysql/jdbc/profiler/ProfilerEvent.java

src/com/mysql/jdbc/util/LRUCache.java

src/com/mysql/jdbc/util/PropertiesDocGenerator.java

src/com/mysql/jdbc/util/ServerController.java

src/doc/sources/connPropsToDocbook.xsl

src/testsuite/BaseTestCase.java

src/testsuite/UnreliableSocketFactory.java

src/testsuite/perf/BasePerfTest.java

src/testsuite/regression/BlobRegressionTest.java

src/testsuite/regression/CachedRowsetTest.java

src/testsuite/regression/CallableStatementRegressionTest.java

src/testsuite/regression/ConnectionRegressionTest.java

src/testsuite/regression/DataSourceRegressionTest.java

src/testsuite/regression/EscapeProcessorRegressionTest.java

src/testsuite/regression/MetaDataRegressionTest.java

src/testsuite/regression/MicroPerformanceRegressionTest.java

src/testsuite/regression/NumbersRegressionTest.java

src/testsuite/regression/PooledConnectionRegressionTest.java

src/testsuite/regression/ResultSetRegressionTest.java

src/testsuite/regression/StatementRegressionTest.java

src/testsuite/regression/StressRegressionTest.java

src/testsuite/regression/StringRegressionTest.java

src/testsuite/regression/SubqueriesRegressionTest.java

src/testsuite/simple/BlobTest.java

src/testsuite/simple/CallableStatementTest.java

src/testsuite/simple/CharsetTests.java

src/testsuite/simple/ConnectionTest.java

src/testsuite/simple/DataSourceTest.java

src/testsuite/simple/EscapeProcessingTest.java

src/testsuite/simple/MetadataTest.java

src/testsuite/simple/ReadOnlyCallableStatementTest.java

src/testsuite/simple/ResultSetTest.java

src/testsuite/simple/SplitDBdotNameTest.java

src/testsuite/simple/StatementsTest.java

src/testsuite/simple/TestLifecycleInterceptor.java

src/testsuite/simple/TraversalTest.java

src/testsuite/simple/UpdatabilityTest.java

Show diffs side-by-side

added added

removed removed

.pc/0002-java6-compilation-compat.patch/src/com/mysql/jdbc/jdbc2/optional/StatementWrapper.java

The MySQL Connector/J is licensed under the terms of the GPLv2

<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most MySQL Connectors.

There are special exceptions to the terms and conditions of the GPLv2 as it is applied to

this software, see the FLOSS License Exception

<http://www.mysql.com/about/legal/licensing/foss-exception.html>.

This program is free software; you can redistribute it and/or modify it under the terms

of the GNU General Public License as published by the Free Software Foundation; version 2

of the License.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;

without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this

program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth

Floor, Boston, MA 02110-1301 USA

package com.mysql.jdbc.jdbc2.optional;

import java.lang.reflect.Constructor;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.SQLWarning;

import java.sql.Statement;

import com.mysql.jdbc.SQLError;

import com.mysql.jdbc.Util;

/**

* Wraps statements so that errors can be reported correctly to

* ConnectionEventListeners.

* @author Mark Matthews

* @version $Id: StatementWrapper.java,v 1.1.2.1 2005/05/13 18:58:38 mmatthews

* Exp $

public class StatementWrapper extends WrapperBase implements Statement {

private static final Constructor<?> JDBC_4_STATEMENT_WRAPPER_CTOR;

static {

if (Util.isJdbc4()) {

try {

JDBC_4_STATEMENT_WRAPPER_CTOR = Class.forName(

"com.mysql.jdbc.jdbc2.optional.JDBC4StatementWrapper").getConstructor(

new Class[] { ConnectionWrapper.class,

MysqlPooledConnection.class,

Statement.class });

} catch (SecurityException e) {

throw new RuntimeException(e);

} catch (NoSuchMethodException e) {

throw new RuntimeException(e);

} catch (ClassNotFoundException e) {

throw new RuntimeException(e);

}

} else {

JDBC_4_STATEMENT_WRAPPER_CTOR = null;

}

protected static StatementWrapper getInstance(ConnectionWrapper c,

MysqlPooledConnection conn,

Statement toWrap) throws SQLException {

if (!Util.isJdbc4()) {

return new StatementWrapper(c,

conn, toWrap);

}

return (StatementWrapper) Util.handleNewInstance(

JDBC_4_STATEMENT_WRAPPER_CTOR,

new Object[] {c,

conn, toWrap }, conn.getExceptionInterceptor());

}

protected Statement wrappedStmt;

protected ConnectionWrapper wrappedConn;

public StatementWrapper(ConnectionWrapper c, MysqlPooledConnection conn,

Statement toWrap) {

super(conn);

this.wrappedStmt = toWrap;

this.wrappedConn = c;

}

* (non-Javadoc)

* @see java.sql.Statement#getConnection()

100

public Connection getConnection() throws SQLException {

101

try {

102

if (this.wrappedStmt != null) {

103

return this.wrappedConn;

104

}

105

106

throw SQLError.createSQLException("Statement already closed",

107

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

108

} catch (SQLException sqlEx) {

109

checkAndFireConnectionError(sqlEx);

110

}

111

112

return null; // we actually never get here, but the compiler can't

113

// figure

114

115

// that out

116

}

117

118

119

* (non-Javadoc)

120

121

* @see java.sql.Statement#setCursorName(java.lang.String)

122

123

public void setCursorName(String name) throws SQLException {

124

try {

125

if (this.wrappedStmt != null) {

126

this.wrappedStmt.setCursorName(name);

127

} else {

128

throw SQLError.createSQLException("Statement already closed",

129

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

130

}

131

} catch (SQLException sqlEx) {

132

checkAndFireConnectionError(sqlEx);

133

}

134

}

135

136

137

* (non-Javadoc)

138

139

* @see java.sql.Statement#setEscapeProcessing(boolean)

140

141

public void setEscapeProcessing(boolean enable) throws SQLException {

142

try {

143

if (this.wrappedStmt != null) {

144

this.wrappedStmt.setEscapeProcessing(enable);

145

} else {

146

throw SQLError.createSQLException("Statement already closed",

147

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

148

}

149

} catch (SQLException sqlEx) {

150

checkAndFireConnectionError(sqlEx);

151

}

152

}

153

154

155

* (non-Javadoc)

156

157

* @see java.sql.Statement#setFetchDirection(int)

158

159

public void setFetchDirection(int direction) throws SQLException {

160

try {

161

if (this.wrappedStmt != null) {

162

this.wrappedStmt.setFetchDirection(direction);

163

} else {

164

throw SQLError.createSQLException("Statement already closed",

165

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

166

}

167

} catch (SQLException sqlEx) {

168

checkAndFireConnectionError(sqlEx);

169

}

170

}

171

172

173

* (non-Javadoc)

174

175

* @see java.sql.Statement#getFetchDirection()

176

177

public int getFetchDirection() throws SQLException {

178

try {

179

if (this.wrappedStmt != null) {

180

return this.wrappedStmt.getFetchDirection();

181

}

182

183

throw SQLError.createSQLException("Statement already closed",

184

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

185

} catch (SQLException sqlEx) {

186

checkAndFireConnectionError(sqlEx);

187

}

188

189

return ResultSet.FETCH_FORWARD; // we actually never get here, but the

190

// compiler can't figure

191

192

// that out

193

}

194

195

196

* (non-Javadoc)

197

198

* @see java.sql.Statement#setFetchSize(int)

199

200

public void setFetchSize(int rows) throws SQLException {

201

try {

202

if (this.wrappedStmt != null) {

203

this.wrappedStmt.setFetchSize(rows);

204

} else {

205

throw SQLError.createSQLException("Statement already closed",

206

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

207

}

208

} catch (SQLException sqlEx) {

209

checkAndFireConnectionError(sqlEx);

210

}

211

}

212

213

214

* (non-Javadoc)

215

216

* @see java.sql.Statement#getFetchSize()

217

218

public int getFetchSize() throws SQLException {

219

try {

220

if (this.wrappedStmt != null) {

221

return this.wrappedStmt.getFetchSize();

222

}

223

224

throw SQLError.createSQLException("Statement already closed",

225

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

226

} catch (SQLException sqlEx) {

227

checkAndFireConnectionError(sqlEx);

228

}

229

230

return 0; // we actually never get here, but the compiler can't figure

231

232

// that out

233

}

234

235

236

* (non-Javadoc)

237

238

* @see java.sql.Statement#getGeneratedKeys()

239

240

public ResultSet getGeneratedKeys() throws SQLException {

241

try {

242

if (this.wrappedStmt != null) {

243

return this.wrappedStmt.getGeneratedKeys();

244

}

245

246

throw SQLError.createSQLException("Statement already closed",

247

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

248

} catch (SQLException sqlEx) {

249

checkAndFireConnectionError(sqlEx);

250

}

251

252

return null; // we actually never get here, but the compiler can't

253

// figure

254

255

// that out

256

}

257

258

259

* (non-Javadoc)

260

261

* @see java.sql.Statement#setMaxFieldSize(int)

262

263

public void setMaxFieldSize(int max) throws SQLException {

264

try {

265

if (this.wrappedStmt != null) {

266

this.wrappedStmt.setMaxFieldSize(max);

267

} else {

268

throw SQLError.createSQLException("Statement already closed",

269

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

270

}

271

} catch (SQLException sqlEx) {

272

checkAndFireConnectionError(sqlEx);

273

}

274

}

275

276

277

* (non-Javadoc)

278

279

* @see java.sql.Statement#getMaxFieldSize()

280

281

public int getMaxFieldSize() throws SQLException {

282

try {

283

if (this.wrappedStmt != null) {

284

return this.wrappedStmt.getMaxFieldSize();

285

}

286

287

throw SQLError.createSQLException("Statement already closed",

288

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

289

} catch (SQLException sqlEx) {

290

checkAndFireConnectionError(sqlEx);

291

}

292

293

return 0; // we actually never get here, but the compiler can't figure

294

295

// that out

296

}

297

298

299

* (non-Javadoc)

300

301

* @see java.sql.Statement#setMaxRows(int)

302

303

public void setMaxRows(int max) throws SQLException {

304

try {

305

if (this.wrappedStmt != null) {

306

this.wrappedStmt.setMaxRows(max);

307

} else {

308

throw SQLError.createSQLException("Statement already closed",

309

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

310

}

311

} catch (SQLException sqlEx) {

312

checkAndFireConnectionError(sqlEx);

313

}

314

}

315

316

317

* (non-Javadoc)

318

319

* @see java.sql.Statement#getMaxRows()

320

321

public int getMaxRows() throws SQLException {

322

try {

323

if (this.wrappedStmt != null) {

324

return this.wrappedStmt.getMaxRows();

325

}

326

327

throw SQLError.createSQLException("Statement already closed",

328

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

329

} catch (SQLException sqlEx) {

330

checkAndFireConnectionError(sqlEx);

331

}

332

333

return 0; // we actually never get here, but the compiler can't figure

334

335

// that out

336

}

337

338

339

* (non-Javadoc)

340

341

* @see java.sql.Statement#getMoreResults()

342

343

public boolean getMoreResults() throws SQLException {

344

try {

345

if (this.wrappedStmt != null) {

346

return this.wrappedStmt.getMoreResults();

347

}

348

349

throw SQLError.createSQLException("Statement already closed",

350

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

351

} catch (SQLException sqlEx) {

352

checkAndFireConnectionError(sqlEx);

353

}

354

355

return false;

356

}

357

358

359

* (non-Javadoc)

360

361

* @see java.sql.Statement#getMoreResults(int)

362

363

public boolean getMoreResults(int current) throws SQLException {

364

try {

365

if (this.wrappedStmt != null) {

366

return this.wrappedStmt.getMoreResults(current);

367

}

368

369

throw SQLError.createSQLException("Statement already closed",

370

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

371

} catch (SQLException sqlEx) {

372

checkAndFireConnectionError(sqlEx);

373

}

374

375

return false;

376

}

377

378

379

* (non-Javadoc)

380

381

* @see java.sql.Statement#setQueryTimeout(int)

382

383

public void setQueryTimeout(int seconds) throws SQLException {

384

try {

385

if (this.wrappedStmt != null) {

386

this.wrappedStmt.setQueryTimeout(seconds);

387

} else {

388

throw SQLError.createSQLException("Statement already closed",

389

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

390

}

391

} catch (SQLException sqlEx) {

392

checkAndFireConnectionError(sqlEx);

393

}

394

}

395

396

397

* (non-Javadoc)

398

399

* @see java.sql.Statement#getQueryTimeout()

400

401

public int getQueryTimeout() throws SQLException {

402

try {

403

if (this.wrappedStmt != null) {

404

return this.wrappedStmt.getQueryTimeout();

405

}

406

407

throw SQLError.createSQLException("Statement already closed",

408

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

409

} catch (SQLException sqlEx) {

410

checkAndFireConnectionError(sqlEx);

411

}

412

413

return 0;

414

}

415

416

417

* (non-Javadoc)

418

419

* @see java.sql.Statement#getResultSet()

420

421

public ResultSet getResultSet() throws SQLException {

422

try {

423

if (this.wrappedStmt != null) {

424

ResultSet rs = this.wrappedStmt.getResultSet();

425

426

if (rs != null) {

427

((com.mysql.jdbc.ResultSetInternalMethods) rs).setWrapperStatement(this);

428

}

429

return rs;

430

}

431

432

throw SQLError.createSQLException("Statement already closed",

433

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

434

} catch (SQLException sqlEx) {

435

checkAndFireConnectionError(sqlEx);

436

}

437

438

return null;

439

}

440

441

442

* (non-Javadoc)

443

444

* @see java.sql.Statement#getResultSetConcurrency()

445

446

public int getResultSetConcurrency() throws SQLException {

447

try {

448

if (this.wrappedStmt != null) {

449

return this.wrappedStmt.getResultSetConcurrency();

450

}

451

452

throw SQLError.createSQLException("Statement already closed",

453

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

454

} catch (SQLException sqlEx) {

455

checkAndFireConnectionError(sqlEx);

456

}

457

458

return 0;

459

}

460

461

462

* (non-Javadoc)

463

464

* @see java.sql.Statement#getResultSetHoldability()

465

466

public int getResultSetHoldability() throws SQLException {

467

try {

468

if (this.wrappedStmt != null) {

469

return this.wrappedStmt.getResultSetHoldability();

470

}

471

472

throw SQLError.createSQLException("Statement already closed",

473

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

474

} catch (SQLException sqlEx) {

475

checkAndFireConnectionError(sqlEx);

476

}

477

478

return Statement.CLOSE_CURRENT_RESULT;

479

}

480

481

482

* (non-Javadoc)

483

484

* @see java.sql.Statement#getResultSetType()

485

486

public int getResultSetType() throws SQLException {

487

try {

488

if (this.wrappedStmt != null) {

489

return this.wrappedStmt.getResultSetType();

490

}

491

492

throw SQLError.createSQLException("Statement already closed",

493

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

494

} catch (SQLException sqlEx) {

495

checkAndFireConnectionError(sqlEx);

496

}

497

498

return ResultSet.TYPE_FORWARD_ONLY;

499

}

500

501

502

* (non-Javadoc)

503

504

* @see java.sql.Statement#getUpdateCount()

505

506

public int getUpdateCount() throws SQLException {

507

try {

508

if (this.wrappedStmt != null) {

509

return this.wrappedStmt.getUpdateCount();

510

}

511

512

throw SQLError.createSQLException("Statement already closed",

513

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

514

} catch (SQLException sqlEx) {

515

checkAndFireConnectionError(sqlEx);

516

}

517

518

return -1;

519

}

520

521

522

* (non-Javadoc)

523

524

* @see java.sql.Statement#getWarnings()

525

526

public SQLWarning getWarnings() throws SQLException {

527

try {

528

if (this.wrappedStmt != null) {

529

return this.wrappedStmt.getWarnings();

530

}

531

532

throw SQLError.createSQLException("Statement already closed",

533

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

534

} catch (SQLException sqlEx) {

535

checkAndFireConnectionError(sqlEx);

536

}

537

538

return null;

539

}

540

541

542

* (non-Javadoc)

543

544

* @see java.sql.Statement#addBatch(java.lang.String)

545

546

public void addBatch(String sql) throws SQLException {

547

try {

548

if (this.wrappedStmt != null) {

549

this.wrappedStmt.addBatch(sql);

550

}

551

} catch (SQLException sqlEx) {

552

checkAndFireConnectionError(sqlEx);

553

}

554

}

555

556

557

* (non-Javadoc)

558

559

* @see java.sql.Statement#cancel()

560

561

public void cancel() throws SQLException {

562

try {

563

if (this.wrappedStmt != null) {

564

this.wrappedStmt.cancel();

565

}

566

} catch (SQLException sqlEx) {

567

checkAndFireConnectionError(sqlEx);

568

}

569

}

570

571

572

* (non-Javadoc)

573

574

* @see java.sql.Statement#clearBatch()

575

576

public void clearBatch() throws SQLException {

577

try {

578

if (this.wrappedStmt != null) {

579

this.wrappedStmt.clearBatch();

580

}

581

} catch (SQLException sqlEx) {

582

checkAndFireConnectionError(sqlEx);

583

}

584

}

585

586

587

* (non-Javadoc)

588

589

* @see java.sql.Statement#clearWarnings()

590

591

public void clearWarnings() throws SQLException {

592

try {

593

if (this.wrappedStmt != null) {

594

this.wrappedStmt.clearWarnings();

595

}

596

} catch (SQLException sqlEx) {

597

checkAndFireConnectionError(sqlEx);

598

}

599

}

600

601

602

* (non-Javadoc)

603

604

* @see java.sql.Statement#close()

605

606

public void close() throws SQLException {

607

try {

608

if (this.wrappedStmt != null) {

609

this.wrappedStmt.close();

610

}

611

} catch (SQLException sqlEx) {

612

checkAndFireConnectionError(sqlEx);

613

} finally {

614

this.wrappedStmt = null;

615

this.pooledConnection = null;

616

}

617

}

618

619

620

* (non-Javadoc)

621

622

* @see java.sql.Statement#execute(java.lang.String, int)

623

624

public boolean execute(String sql, int autoGeneratedKeys)

625

throws SQLException {

626

try {

627

if (this.wrappedStmt != null) {

628

return this.wrappedStmt.execute(sql, autoGeneratedKeys);

629

}

630

631

throw SQLError.createSQLException("Statement already closed",

632

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

633

} catch (SQLException sqlEx) {

634

checkAndFireConnectionError(sqlEx);

635

}

636

637

return false; // we actually never get here, but the compiler can't

638

// figure

639

640

// that out

641

}

642

643

644

* (non-Javadoc)

645

646

* @see java.sql.Statement#execute(java.lang.String, int[])

647

648

public boolean execute(String sql, int[] columnIndexes) throws SQLException {

649

try {

650

if (this.wrappedStmt != null) {

651

return this.wrappedStmt.execute(sql, columnIndexes);

652

}

653

654

throw SQLError.createSQLException("Statement already closed",

655

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

656

} catch (SQLException sqlEx) {

657

checkAndFireConnectionError(sqlEx);

658

}

659

660

return false; // we actually never get here, but the compiler can't

661

// figure

662

663

// that out

664

}

665

666

667

* (non-Javadoc)

668

669

* @see java.sql.Statement#execute(java.lang.String, java.lang.String[])

670

671

public boolean execute(String sql, String[] columnNames)

672

throws SQLException {

673

try {

674

if (this.wrappedStmt != null) {

675

return this.wrappedStmt.execute(sql, columnNames);

676

}

677

678

throw SQLError.createSQLException("Statement already closed",

679

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

680

} catch (SQLException sqlEx) {

681

checkAndFireConnectionError(sqlEx);

682

}

683

684

return false; // we actually never get here, but the compiler can't

685

// figure

686

687

// that out

688

}

689

690

691

* (non-Javadoc)

692

693

* @see java.sql.Statement#execute(java.lang.String)

694

695

public boolean execute(String sql) throws SQLException {

696

try {

697

if (this.wrappedStmt != null) {

698

return this.wrappedStmt.execute(sql);

699

}

700

701

throw SQLError.createSQLException("Statement already closed",

702

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

703

} catch (SQLException sqlEx) {

704

checkAndFireConnectionError(sqlEx);

705

}

706

707

return false; // we actually never get here, but the compiler can't

708

// figure

709

710

// that out

711

}

712

713

714

* (non-Javadoc)

715

716

* @see java.sql.Statement#executeBatch()

717

718

public int[] executeBatch() throws SQLException {

719

try {

720

if (this.wrappedStmt != null) {

721

return this.wrappedStmt.executeBatch();

722

}

723

724

throw SQLError.createSQLException("Statement already closed",

725

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

726

} catch (SQLException sqlEx) {

727

checkAndFireConnectionError(sqlEx);

728

}

729

730

return null; // we actually never get here, but the compiler can't

731

// figure

732

733

// that out

734

}

735

736

737

* (non-Javadoc)

738

739

* @see java.sql.Statement#executeQuery(java.lang.String)

740

741

public ResultSet executeQuery(String sql) throws SQLException {

742

try {

743

if (this.wrappedStmt != null) {

744

745

ResultSet rs = this.wrappedStmt.executeQuery(sql);

746

((com.mysql.jdbc.ResultSetInternalMethods) rs).setWrapperStatement(this);

747

748

return rs;

749

}

750

751

throw SQLError.createSQLException("Statement already closed",

752

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

753

} catch (SQLException sqlEx) {

754

checkAndFireConnectionError(sqlEx);

755

}

756

757

return null; // we actually never get here, but the compiler can't

758

// figure

759

760

// that out

761

}

762

763

764

* (non-Javadoc)

765

766

* @see java.sql.Statement#executeUpdate(java.lang.String, int)

767

768

public int executeUpdate(String sql, int autoGeneratedKeys)

769

throws SQLException {

770

try {

771

if (this.wrappedStmt != null) {

772

return this.wrappedStmt.executeUpdate(sql, autoGeneratedKeys);

773

}

774

775

throw SQLError.createSQLException("Statement already closed",

776

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

777

} catch (SQLException sqlEx) {

778

checkAndFireConnectionError(sqlEx);

779

}

780

781

return -1; // we actually never get here, but the compiler can't figure

782

783

// that out

784

}

785

786

787

* (non-Javadoc)

788

789

* @see java.sql.Statement#executeUpdate(java.lang.String, int[])

790

791

public int executeUpdate(String sql, int[] columnIndexes)

792

throws SQLException {

793

try {

794

if (this.wrappedStmt != null) {

795

return this.wrappedStmt.executeUpdate(sql, columnIndexes);

796

}

797

798

throw SQLError.createSQLException("Statement already closed",

799

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

800

} catch (SQLException sqlEx) {

801

checkAndFireConnectionError(sqlEx);

802

}

803

804

return -1; // we actually never get here, but the compiler can't figure

805

806

// that out

807

}

808

809

810

* (non-Javadoc)

811

812

* @see java.sql.Statement#executeUpdate(java.lang.String,

813

* java.lang.String[])

814

815

public int executeUpdate(String sql, String[] columnNames)

816

throws SQLException {

817

try {

818

if (this.wrappedStmt != null) {

819

return this.wrappedStmt.executeUpdate(sql, columnNames);

820

}

821

822

throw SQLError.createSQLException("Statement already closed",

823

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

824

} catch (SQLException sqlEx) {

825

checkAndFireConnectionError(sqlEx);

826

}

827

828

return -1; // we actually never get here, but the compiler can't figure

829

830

// that out

831

}

832

833

834

* (non-Javadoc)

835

836

* @see java.sql.Statement#executeUpdate(java.lang.String)

837

838

public int executeUpdate(String sql) throws SQLException {

839

try {

840

if (this.wrappedStmt != null) {

841

return this.wrappedStmt.executeUpdate(sql);

842

}

843

844

throw SQLError.createSQLException("Statement already closed",

845

SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);

846

} catch (SQLException sqlEx) {

847

checkAndFireConnectionError(sqlEx);

848

}

849

850

return -1; // we actually never get here, but the compiler can't figure

851

852

// that out

853

}

854

855

public void enableStreamingResults() throws SQLException {

856

try {

857

if (this.wrappedStmt != null) {

858

((com.mysql.jdbc.Statement) this.wrappedStmt)

859

.enableStreamingResults();

860

} else {

861

throw SQLError.createSQLException(

862

"No operations allowed after statement closed",

863

SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);

864

}

865

} catch (SQLException sqlEx) {

866

checkAndFireConnectionError(sqlEx);

867

}

868

}

869

}

Older »