You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@tomcat.apache.org by ma...@apache.org on 2018/06/19 10:30:31 UTC
svn commit: r1833804 [5/16] - in /tomcat/tc8.5.x/trunk: ./
java/org/apache/tomcat/dbcp/dbcp2/
java/org/apache/tomcat/dbcp/dbcp2/cpdsadapter/
java/org/apache/tomcat/dbcp/dbcp2/datasources/ webapps/docs/
Modified: tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DelegatingConnection.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DelegatingConnection.java?rev=1833804&r1=1833803&r2=1833804&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DelegatingConnection.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DelegatingConnection.java Tue Jun 19 10:30:31 2018
@@ -44,57 +44,48 @@ import java.util.concurrent.Executor;
/**
* A base delegating implementation of {@link Connection}.
* <p>
- * All of the methods from the {@link Connection} interface
- * simply check to see that the {@link Connection} is active,
- * and call the corresponding method on the "delegate"
- * provided in my constructor.
+ * All of the methods from the {@link Connection} interface simply check to see that the {@link Connection} is active,
+ * and call the corresponding method on the "delegate" provided in my constructor.
+ * </p>
* <p>
- * Extends AbandonedTrace to implement Connection tracking and
- * logging of code which created the Connection. Tracking the
- * Connection ensures that the AbandonedObjectPool can close
- * this connection and recycle it if its pool of connections
- * is nearing exhaustion and this connection's last usage is
- * older than the removeAbandonedTimeout.
+ * Extends AbandonedTrace to implement Connection tracking and logging of code which created the Connection. Tracking
+ * the Connection ensures that the AbandonedObjectPool can close this connection and recycle it if its pool of
+ * connections is nearing exhaustion and this connection's last usage is older than the removeAbandonedTimeout.
+ * </p>
*
- * @param <C> the Connection type
+ * @param <C>
+ * the Connection type
*
- * @author Rodney Waldhoff
- * @author Glenn L. Nielsen
- * @author James House
- * @author Dirk Verbeeck
* @since 2.0
*/
-public class DelegatingConnection<C extends Connection> extends AbandonedTrace
- implements Connection {
+public class DelegatingConnection<C extends Connection> extends AbandonedTrace implements Connection {
- private static final Map<String, ClientInfoStatus> EMPTY_FAILED_PROPERTIES =
- Collections.<String, ClientInfoStatus>emptyMap();
+ private static final Map<String, ClientInfoStatus> EMPTY_FAILED_PROPERTIES = Collections
+ .<String, ClientInfoStatus>emptyMap();
/** My delegate {@link Connection}. */
- private volatile C _conn = null;
+ private volatile C connection;
- private volatile boolean _closed = false;
+ private volatile boolean closed;
- private boolean _cacheState = true;
- private Boolean _autoCommitCached = null;
- private Boolean _readOnlyCached = null;
- private Integer defaultQueryTimeout = null;
+ private boolean cacheState = true;
+ private Boolean autoCommitCached;
+ private Boolean readOnlyCached;
+ private Integer defaultQueryTimeoutSeconds;
/**
- * Create a wrapper for the Connection which traces this
- * Connection in the AbandonedObjectPool.
+ * Creates a wrapper for the Connection which traces this Connection in the AbandonedObjectPool.
*
- * @param c the {@link Connection} to delegate all calls to.
+ * @param c
+ * the {@link Connection} to delegate all calls to.
*/
public DelegatingConnection(final C c) {
super();
- _conn = c;
+ connection = c;
}
-
/**
- * Returns a string representation of the metadata associated with
- * the innermost delegate connection.
+ * Returns a string representation of the metadata associated with the innermost delegate connection.
*/
@Override
public String toString() {
@@ -105,8 +96,7 @@ public class DelegatingConnection<C exte
try {
if (c.isClosed()) {
s = "connection is closed";
- }
- else {
+ } else {
final StringBuffer sb = new StringBuffer();
sb.append(hashCode());
final DatabaseMetaData meta = c.getMetaData();
@@ -120,8 +110,7 @@ public class DelegatingConnection<C exte
s = sb.toString();
}
}
- }
- catch (final SQLException ex) {
+ } catch (final SQLException ex) {
// Ignore
}
}
@@ -135,6 +124,7 @@ public class DelegatingConnection<C exte
/**
* Returns my underlying {@link Connection}.
+ *
* @return my underlying {@link Connection}.
*/
public C getDelegate() {
@@ -142,13 +132,14 @@ public class DelegatingConnection<C exte
}
protected final C getDelegateInternal() {
- return _conn;
+ return connection;
}
/**
* Compares innermost delegate to the given connection.
*
- * @param c connection to compare innermost delegate with
+ * @param c
+ * connection to compare innermost delegate with
* @return true if innermost delegate equals <code>c</code>
*/
public boolean innermostDelegateEquals(final Connection c) {
@@ -159,39 +150,35 @@ public class DelegatingConnection<C exte
return innerCon.equals(c);
}
-
/**
- * If my underlying {@link Connection} is not a
- * {@code DelegatingConnection}, returns it,
- * otherwise recursively invokes this method on
- * my delegate.
+ * If my underlying {@link Connection} is not a {@code DelegatingConnection}, returns it, otherwise recursively
+ * invokes this method on my delegate.
* <p>
- * Hence this method will return the first
- * delegate that is not a {@code DelegatingConnection},
- * or {@code null} when no non-{@code DelegatingConnection}
- * delegate can be found by traversing this chain.
+ * Hence this method will return the first delegate that is not a {@code DelegatingConnection}, or {@code null} when
+ * no non-{@code DelegatingConnection} delegate can be found by traversing this chain.
+ * </p>
* <p>
- * This method is useful when you may have nested
- * {@code DelegatingConnection}s, and you want to make
- * sure to obtain a "genuine" {@link Connection}.
- * @return the connection
+ * This method is useful when you may have nested {@code DelegatingConnection}s, and you want to make sure to obtain
+ * a "genuine" {@link Connection}.
+ * </p>
+ *
+ * @return innermost delegate.
*/
public Connection getInnermostDelegate() {
return getInnermostDelegateInternal();
}
-
/**
- * Although this method is public, it is part of the internal API and should
- * not be used by clients. The signature of this method may change at any
- * time including in ways that break backwards compatibility.
- * @return the connection
+ * Although this method is public, it is part of the internal API and should not be used by clients. The signature
+ * of this method may change at any time including in ways that break backwards compatibility.
+ *
+ * @return innermost delegate.
*/
public final Connection getInnermostDelegateInternal() {
- Connection c = _conn;
- while(c != null && c instanceof DelegatingConnection) {
- c = ((DelegatingConnection<?>)c).getDelegateInternal();
- if(this == c) {
+ Connection c = connection;
+ while (c != null && c instanceof DelegatingConnection) {
+ c = ((DelegatingConnection<?>) c).getDelegateInternal();
+ if (this == c) {
return null;
}
}
@@ -200,50 +187,50 @@ public class DelegatingConnection<C exte
/**
* Sets my delegate.
- * @param c The connection
+ *
+ * @param connection
+ * my delegate.
*/
- public void setDelegate(final C c) {
- _conn = c;
+ public void setDelegate(final C connection) {
+ this.connection = connection;
}
/**
- * Closes the underlying connection, and close any Statements that were not
- * explicitly closed. Sub-classes that override this method must:
+ * Closes the underlying connection, and close any Statements that were not explicitly closed. Sub-classes that
+ * override this method must:
* <ol>
* <li>Call passivate()</li>
- * <li>Call close (or the equivalent appropriate action) on the wrapped
- * connection</li>
+ * <li>Call close (or the equivalent appropriate action) on the wrapped connection</li>
* <li>Set _closed to <code>false</code></li>
* </ol>
- * @throws SQLException Error closing connection
*/
@Override
public void close() throws SQLException {
- if (!_closed) {
+ if (!closed) {
closeInternal();
}
}
protected boolean isClosedInternal() {
- return _closed;
+ return closed;
}
protected void setClosedInternal(final boolean closed) {
- this._closed = closed;
+ this.closed = closed;
}
protected final void closeInternal() throws SQLException {
try {
passivate();
} finally {
- if (_conn != null) {
+ if (connection != null) {
try {
- _conn.close();
+ connection.close();
} finally {
- _closed = true;
+ closed = true;
}
} else {
- _closed = true;
+ closed = true;
}
}
}
@@ -253,9 +240,8 @@ public class DelegatingConnection<C exte
}
private void initializeStatement(final DelegatingStatement ds) throws SQLException {
- if (defaultQueryTimeout != null &&
- defaultQueryTimeout.intValue() != ds.getQueryTimeout()) {
- ds.setQueryTimeout(defaultQueryTimeout.intValue());
+ if (defaultQueryTimeoutSeconds != null && defaultQueryTimeoutSeconds.intValue() != ds.getQueryTimeout()) {
+ ds.setQueryTimeout(defaultQueryTimeoutSeconds.intValue());
}
}
@@ -263,28 +249,24 @@ public class DelegatingConnection<C exte
public Statement createStatement() throws SQLException {
checkOpen();
try {
- final DelegatingStatement ds =
- new DelegatingStatement(this, _conn.createStatement());
+ final DelegatingStatement ds = new DelegatingStatement(this, connection.createStatement());
initializeStatement(ds);
return ds;
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
- public Statement createStatement(final int resultSetType,
- final int resultSetConcurrency) throws SQLException {
+ public Statement createStatement(final int resultSetType, final int resultSetConcurrency) throws SQLException {
checkOpen();
try {
- final DelegatingStatement ds = new DelegatingStatement(
- this, _conn.createStatement(resultSetType,resultSetConcurrency));
+ final DelegatingStatement ds = new DelegatingStatement(this,
+ connection.createStatement(resultSetType, resultSetConcurrency));
initializeStatement(ds);
return ds;
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -294,29 +276,26 @@ public class DelegatingConnection<C exte
public PreparedStatement prepareStatement(final String sql) throws SQLException {
checkOpen();
try {
- final DelegatingPreparedStatement dps = new DelegatingPreparedStatement(
- this, _conn.prepareStatement(sql));
+ final DelegatingPreparedStatement dps = new DelegatingPreparedStatement(this,
+ connection.prepareStatement(sql));
initializeStatement(dps);
return dps;
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
- public PreparedStatement prepareStatement(final String sql,
- final int resultSetType,
- final int resultSetConcurrency) throws SQLException {
+ public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency)
+ throws SQLException {
checkOpen();
try {
- final DelegatingPreparedStatement dps = new DelegatingPreparedStatement(
- this, _conn.prepareStatement(sql,resultSetType,resultSetConcurrency));
+ final DelegatingPreparedStatement dps = new DelegatingPreparedStatement(this,
+ connection.prepareStatement(sql, resultSetType, resultSetConcurrency));
initializeStatement(dps);
return dps;
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -326,221 +305,205 @@ public class DelegatingConnection<C exte
public CallableStatement prepareCall(final String sql) throws SQLException {
checkOpen();
try {
- final DelegatingCallableStatement dcs =
- new DelegatingCallableStatement(this, _conn.prepareCall(sql));
+ final DelegatingCallableStatement dcs = new DelegatingCallableStatement(this, connection.prepareCall(sql));
initializeStatement(dcs);
return dcs;
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
- public CallableStatement prepareCall(final String sql,
- final int resultSetType,
- final int resultSetConcurrency) throws SQLException {
+ public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency)
+ throws SQLException {
checkOpen();
try {
- final DelegatingCallableStatement dcs = new DelegatingCallableStatement(
- this, _conn.prepareCall(sql, resultSetType,resultSetConcurrency));
+ final DelegatingCallableStatement dcs = new DelegatingCallableStatement(this,
+ connection.prepareCall(sql, resultSetType, resultSetConcurrency));
initializeStatement(dcs);
return dcs;
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
}
-
@Override
public void clearWarnings() throws SQLException {
checkOpen();
try {
- _conn.clearWarnings();
+ connection.clearWarnings();
} catch (final SQLException e) {
handleException(e);
}
}
-
@Override
public void commit() throws SQLException {
checkOpen();
try {
- _conn.commit();
+ connection.commit();
} catch (final SQLException e) {
handleException(e);
}
}
-
/**
* Returns the state caching flag.
*
- * @return the state caching flag
+ * @return the state caching flag
*/
public boolean getCacheState() {
- return _cacheState;
+ return cacheState;
}
@Override
public boolean getAutoCommit() throws SQLException {
checkOpen();
- if (_cacheState && _autoCommitCached != null) {
- return _autoCommitCached.booleanValue();
+ if (cacheState && autoCommitCached != null) {
+ return autoCommitCached.booleanValue();
}
try {
- _autoCommitCached = Boolean.valueOf(_conn.getAutoCommit());
- return _autoCommitCached.booleanValue();
+ autoCommitCached = Boolean.valueOf(connection.getAutoCommit());
+ return autoCommitCached.booleanValue();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
-
@Override
public String getCatalog() throws SQLException {
checkOpen();
try {
- return _conn.getCatalog();
+ return connection.getCatalog();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
-
@Override
public DatabaseMetaData getMetaData() throws SQLException {
checkOpen();
try {
- return new DelegatingDatabaseMetaData(this, _conn.getMetaData());
+ return new DelegatingDatabaseMetaData(this, connection.getMetaData());
} catch (final SQLException e) {
handleException(e);
return null;
}
}
-
@Override
public int getTransactionIsolation() throws SQLException {
checkOpen();
try {
- return _conn.getTransactionIsolation();
+ return connection.getTransactionIsolation();
} catch (final SQLException e) {
handleException(e);
return -1;
}
}
-
@Override
- public Map<String,Class<?>> getTypeMap() throws SQLException {
+ public Map<String, Class<?>> getTypeMap() throws SQLException {
checkOpen();
try {
- return _conn.getTypeMap();
+ return connection.getTypeMap();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
-
@Override
public SQLWarning getWarnings() throws SQLException {
checkOpen();
try {
- return _conn.getWarnings();
+ return connection.getWarnings();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
-
@Override
public boolean isReadOnly() throws SQLException {
checkOpen();
- if (_cacheState && _readOnlyCached != null) {
- return _readOnlyCached.booleanValue();
+ if (cacheState && readOnlyCached != null) {
+ return readOnlyCached.booleanValue();
}
try {
- _readOnlyCached = Boolean.valueOf(_conn.isReadOnly());
- return _readOnlyCached.booleanValue();
+ readOnlyCached = Boolean.valueOf(connection.isReadOnly());
+ return readOnlyCached.booleanValue();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
-
@Override
public String nativeSQL(final String sql) throws SQLException {
checkOpen();
try {
- return _conn.nativeSQL(sql);
+ return connection.nativeSQL(sql);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
-
@Override
public void rollback() throws SQLException {
checkOpen();
try {
- _conn.rollback();
+ connection.rollback();
} catch (final SQLException e) {
handleException(e);
}
}
-
/**
- * Obtain the default query timeout that will be used for {@link Statement}s
- * created from this connection. <code>null</code> means that the driver
- * default will be used.
- * @return the timeout
+ * Gets the default query timeout that will be used for {@link Statement}s created from this connection.
+ * <code>null</code> means that the driver default will be used.
+ *
+ * @return query timeout limit in seconds; zero means there is no limit.
*/
public Integer getDefaultQueryTimeout() {
- return defaultQueryTimeout;
+ return defaultQueryTimeoutSeconds;
}
-
/**
- * Set the default query timeout that will be used for {@link Statement}s
- * created from this connection. <code>null</code> means that the driver
- * default will be used.
- * @param defaultQueryTimeout The timeout value
+ * Sets the default query timeout that will be used for {@link Statement}s created from this connection.
+ * <code>null</code> means that the driver default will be used.
+ *
+ * @param defaultQueryTimeoutSeconds
+ * the new query timeout limit in seconds; zero means there is no limit
*/
- public void setDefaultQueryTimeout(final Integer defaultQueryTimeout) {
- this.defaultQueryTimeout = defaultQueryTimeout;
+ public void setDefaultQueryTimeout(final Integer defaultQueryTimeoutSeconds) {
+ this.defaultQueryTimeoutSeconds = defaultQueryTimeoutSeconds;
}
-
/**
* Sets the state caching flag.
*
- * @param cacheState The new value for the state caching flag
+ * @param cacheState
+ * The new value for the state caching flag
*/
public void setCacheState(final boolean cacheState) {
- this._cacheState = cacheState;
+ this.cacheState = cacheState;
}
/**
- * Can be used to clear cached state when it is known that the underlying
- * connection may have been accessed directly.
+ * Can be used to clear cached state when it is known that the underlying connection may have been accessed
+ * directly.
*/
public void clearCachedState() {
- _autoCommitCached = null;
- _readOnlyCached = null;
- if (_conn instanceof DelegatingConnection) {
- ((DelegatingConnection<?>)_conn).clearCachedState();
+ autoCommitCached = null;
+ readOnlyCached = null;
+ if (connection instanceof DelegatingConnection) {
+ ((DelegatingConnection<?>) connection).clearCachedState();
}
}
@@ -548,51 +511,55 @@ public class DelegatingConnection<C exte
public void setAutoCommit(final boolean autoCommit) throws SQLException {
checkOpen();
try {
- _conn.setAutoCommit(autoCommit);
- if (_cacheState) {
- _autoCommitCached = Boolean.valueOf(autoCommit);
+ connection.setAutoCommit(autoCommit);
+ if (cacheState) {
+ autoCommitCached = Boolean.valueOf(autoCommit);
}
} catch (final SQLException e) {
- _autoCommitCached = null;
+ autoCommitCached = null;
handleException(e);
}
}
@Override
- public void setCatalog(final String catalog) throws SQLException
- { checkOpen(); try { _conn.setCatalog(catalog); } catch (final SQLException e) { handleException(e); } }
+ public void setCatalog(final String catalog) throws SQLException {
+ checkOpen();
+ try {
+ connection.setCatalog(catalog);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
public void setReadOnly(final boolean readOnly) throws SQLException {
checkOpen();
try {
- _conn.setReadOnly(readOnly);
- if (_cacheState) {
- _readOnlyCached = Boolean.valueOf(readOnly);
+ connection.setReadOnly(readOnly);
+ if (cacheState) {
+ readOnlyCached = Boolean.valueOf(readOnly);
}
} catch (final SQLException e) {
- _readOnlyCached = null;
+ readOnlyCached = null;
handleException(e);
}
}
-
@Override
public void setTransactionIsolation(final int level) throws SQLException {
checkOpen();
try {
- _conn.setTransactionIsolation(level);
+ connection.setTransactionIsolation(level);
} catch (final SQLException e) {
handleException(e);
}
}
-
@Override
- public void setTypeMap(final Map<String,Class<?>> map) throws SQLException {
+ public void setTypeMap(final Map<String, Class<?>> map) throws SQLException {
checkOpen();
try {
- _conn.setTypeMap(map);
+ connection.setTypeMap(map);
} catch (final SQLException e) {
handleException(e);
}
@@ -600,31 +567,29 @@ public class DelegatingConnection<C exte
@Override
public boolean isClosed() throws SQLException {
- return _closed || _conn == null || _conn.isClosed();
+ return closed || connection == null || connection.isClosed();
}
protected void checkOpen() throws SQLException {
- if(_closed) {
- if (null != _conn) {
+ if (closed) {
+ if (null != connection) {
String label = "";
try {
- label = _conn.toString();
+ label = connection.toString();
} catch (final Exception ex) {
// ignore, leave label empty
}
- throw new SQLException
- ("Connection " + label + " is closed.");
+ throw new SQLException("Connection " + label + " is closed.");
}
- throw new SQLException
- ("Connection is null.");
+ throw new SQLException("Connection is null.");
}
}
protected void activate() {
- _closed = false;
+ closed = false;
setLastUsed();
- if(_conn instanceof DelegatingConnection) {
- ((DelegatingConnection<?>)_conn).activate();
+ if (connection instanceof DelegatingConnection) {
+ ((DelegatingConnection<?>) connection).activate();
}
}
@@ -633,7 +598,7 @@ public class DelegatingConnection<C exte
// Statement's when it is closed.
// DBCP-288. Not all the traced objects will be statements
final List<AbandonedTrace> traces = getTrace();
- if(traces != null && traces.size() > 0) {
+ if (traces != null && traces.size() > 0) {
final Iterator<AbandonedTrace> traceIter = traces.iterator();
while (traceIter.hasNext()) {
final Object trace = traceIter.next();
@@ -650,126 +615,109 @@ public class DelegatingConnection<C exte
setLastUsed(0);
}
-
@Override
public int getHoldability() throws SQLException {
checkOpen();
try {
- return _conn.getHoldability();
+ return connection.getHoldability();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
-
@Override
public void setHoldability(final int holdability) throws SQLException {
checkOpen();
try {
- _conn.setHoldability(holdability);
+ connection.setHoldability(holdability);
} catch (final SQLException e) {
handleException(e);
}
}
-
@Override
public Savepoint setSavepoint() throws SQLException {
checkOpen();
try {
- return _conn.setSavepoint();
+ return connection.setSavepoint();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
-
@Override
public Savepoint setSavepoint(final String name) throws SQLException {
checkOpen();
try {
- return _conn.setSavepoint(name);
+ return connection.setSavepoint(name);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
-
@Override
public void rollback(final Savepoint savepoint) throws SQLException {
checkOpen();
try {
- _conn.rollback(savepoint);
+ connection.rollback(savepoint);
} catch (final SQLException e) {
handleException(e);
}
}
-
@Override
- public void releaseSavepoint(final Savepoint savepoint)
- throws SQLException {
+ public void releaseSavepoint(final Savepoint savepoint) throws SQLException {
checkOpen();
try {
- _conn.releaseSavepoint(savepoint);
+ connection.releaseSavepoint(savepoint);
} catch (final SQLException e) {
handleException(e);
}
}
-
@Override
- public Statement createStatement(final int resultSetType,
- final int resultSetConcurrency,
- final int resultSetHoldability) throws SQLException {
+ public Statement createStatement(final int resultSetType, final int resultSetConcurrency,
+ final int resultSetHoldability) throws SQLException {
checkOpen();
try {
final DelegatingStatement ds = new DelegatingStatement(this,
- _conn.createStatement(resultSetType, resultSetConcurrency,
- resultSetHoldability));
+ connection.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability));
initializeStatement(ds);
return ds;
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
- public PreparedStatement prepareStatement(final String sql, final int resultSetType,
- final int resultSetConcurrency,
- final int resultSetHoldability) throws SQLException {
+ public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency,
+ final int resultSetHoldability) throws SQLException {
checkOpen();
try {
- final DelegatingPreparedStatement dps = new DelegatingPreparedStatement(
- this, _conn.prepareStatement(sql, resultSetType,
- resultSetConcurrency, resultSetHoldability));
+ final DelegatingPreparedStatement dps = new DelegatingPreparedStatement(this,
+ connection.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability));
initializeStatement(dps);
return dps;
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
- public CallableStatement prepareCall(final String sql, final int resultSetType,
- final int resultSetConcurrency,
- final int resultSetHoldability) throws SQLException {
+ public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency,
+ final int resultSetHoldability) throws SQLException {
checkOpen();
try {
- final DelegatingCallableStatement dcs = new DelegatingCallableStatement(
- this, _conn.prepareCall(sql, resultSetType,
- resultSetConcurrency, resultSetHoldability));
+ final DelegatingCallableStatement dcs = new DelegatingCallableStatement(this,
+ connection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability));
initializeStatement(dcs);
return dcs;
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -779,12 +727,11 @@ public class DelegatingConnection<C exte
public PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys) throws SQLException {
checkOpen();
try {
- final DelegatingPreparedStatement dps = new DelegatingPreparedStatement(
- this, _conn.prepareStatement(sql, autoGeneratedKeys));
+ final DelegatingPreparedStatement dps = new DelegatingPreparedStatement(this,
+ connection.prepareStatement(sql, autoGeneratedKeys));
initializeStatement(dps);
return dps;
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -794,12 +741,11 @@ public class DelegatingConnection<C exte
public PreparedStatement prepareStatement(final String sql, final int columnIndexes[]) throws SQLException {
checkOpen();
try {
- final DelegatingPreparedStatement dps = new DelegatingPreparedStatement(
- this, _conn.prepareStatement(sql, columnIndexes));
+ final DelegatingPreparedStatement dps = new DelegatingPreparedStatement(this,
+ connection.prepareStatement(sql, columnIndexes));
initializeStatement(dps);
return dps;
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -809,26 +755,24 @@ public class DelegatingConnection<C exte
public PreparedStatement prepareStatement(final String sql, final String columnNames[]) throws SQLException {
checkOpen();
try {
- final DelegatingPreparedStatement dps = new DelegatingPreparedStatement(
- this, _conn.prepareStatement(sql, columnNames));
+ final DelegatingPreparedStatement dps = new DelegatingPreparedStatement(this,
+ connection.prepareStatement(sql, columnNames));
initializeStatement(dps);
return dps;
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
}
-
@Override
public boolean isWrapperFor(final Class<?> iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return true;
- } else if (iface.isAssignableFrom(_conn.getClass())) {
+ } else if (iface.isAssignableFrom(connection.getClass())) {
return true;
} else {
- return _conn.isWrapperFor(iface);
+ return connection.isWrapperFor(iface);
}
}
@@ -836,10 +780,10 @@ public class DelegatingConnection<C exte
public <T> T unwrap(final Class<T> iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return iface.cast(this);
- } else if (iface.isAssignableFrom(_conn.getClass())) {
- return iface.cast(_conn);
+ } else if (iface.isAssignableFrom(connection.getClass())) {
+ return iface.cast(connection);
} else {
- return _conn.unwrap(iface);
+ return connection.unwrap(iface);
}
}
@@ -847,9 +791,8 @@ public class DelegatingConnection<C exte
public Array createArrayOf(final String typeName, final Object[] elements) throws SQLException {
checkOpen();
try {
- return _conn.createArrayOf(typeName, elements);
- }
- catch (final SQLException e) {
+ return connection.createArrayOf(typeName, elements);
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -859,9 +802,8 @@ public class DelegatingConnection<C exte
public Blob createBlob() throws SQLException {
checkOpen();
try {
- return _conn.createBlob();
- }
- catch (final SQLException e) {
+ return connection.createBlob();
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -871,9 +813,8 @@ public class DelegatingConnection<C exte
public Clob createClob() throws SQLException {
checkOpen();
try {
- return _conn.createClob();
- }
- catch (final SQLException e) {
+ return connection.createClob();
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -883,9 +824,8 @@ public class DelegatingConnection<C exte
public NClob createNClob() throws SQLException {
checkOpen();
try {
- return _conn.createNClob();
- }
- catch (final SQLException e) {
+ return connection.createNClob();
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -895,9 +835,8 @@ public class DelegatingConnection<C exte
public SQLXML createSQLXML() throws SQLException {
checkOpen();
try {
- return _conn.createSQLXML();
- }
- catch (final SQLException e) {
+ return connection.createSQLXML();
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -907,23 +846,21 @@ public class DelegatingConnection<C exte
public Struct createStruct(final String typeName, final Object[] attributes) throws SQLException {
checkOpen();
try {
- return _conn.createStruct(typeName, attributes);
- }
- catch (final SQLException e) {
+ return connection.createStruct(typeName, attributes);
+ } catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
- public boolean isValid(final int timeout) throws SQLException {
+ public boolean isValid(final int timeoutSeconds) throws SQLException {
if (isClosed()) {
return false;
}
try {
- return _conn.isValid(timeout);
- }
- catch (final SQLException e) {
+ return connection.isValid(timeoutSeconds);
+ } catch (final SQLException e) {
handleException(e);
return false;
}
@@ -933,12 +870,10 @@ public class DelegatingConnection<C exte
public void setClientInfo(final String name, final String value) throws SQLClientInfoException {
try {
checkOpen();
- _conn.setClientInfo(name, value);
- }
- catch (final SQLClientInfoException e) {
+ connection.setClientInfo(name, value);
+ } catch (final SQLClientInfoException e) {
throw e;
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
throw new SQLClientInfoException("Connection is closed.", EMPTY_FAILED_PROPERTIES, e);
}
}
@@ -947,12 +882,10 @@ public class DelegatingConnection<C exte
public void setClientInfo(final Properties properties) throws SQLClientInfoException {
try {
checkOpen();
- _conn.setClientInfo(properties);
- }
- catch (final SQLClientInfoException e) {
+ connection.setClientInfo(properties);
+ } catch (final SQLClientInfoException e) {
throw e;
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
throw new SQLClientInfoException("Connection is closed.", EMPTY_FAILED_PROPERTIES, e);
}
}
@@ -961,9 +894,8 @@ public class DelegatingConnection<C exte
public Properties getClientInfo() throws SQLException {
checkOpen();
try {
- return _conn.getClientInfo();
- }
- catch (final SQLException e) {
+ return connection.getClientInfo();
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -973,9 +905,8 @@ public class DelegatingConnection<C exte
public String getClientInfo(final String name) throws SQLException {
checkOpen();
try {
- return _conn.getClientInfo(name);
- }
- catch (final SQLException e) {
+ return connection.getClientInfo(name);
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -985,9 +916,8 @@ public class DelegatingConnection<C exte
public void setSchema(final String schema) throws SQLException {
checkOpen();
try {
- _conn.setSchema(schema);
- }
- catch (final SQLException e) {
+ connection.setSchema(schema);
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -996,9 +926,8 @@ public class DelegatingConnection<C exte
public String getSchema() throws SQLException {
checkOpen();
try {
- return _conn.getSchema();
- }
- catch (final SQLException e) {
+ return connection.getSchema();
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -1008,21 +937,18 @@ public class DelegatingConnection<C exte
public void abort(final Executor executor) throws SQLException {
checkOpen();
try {
- _conn.abort(executor);
- }
- catch (final SQLException e) {
+ connection.abort(executor);
+ } catch (final SQLException e) {
handleException(e);
}
}
@Override
- public void setNetworkTimeout(final Executor executor, final int milliseconds)
- throws SQLException {
+ public void setNetworkTimeout(final Executor executor, final int milliseconds) throws SQLException {
checkOpen();
try {
- _conn.setNetworkTimeout(executor, milliseconds);
- }
- catch (final SQLException e) {
+ connection.setNetworkTimeout(executor, milliseconds);
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -1031,9 +957,8 @@ public class DelegatingConnection<C exte
public int getNetworkTimeout() throws SQLException {
checkOpen();
try {
- return _conn.getNetworkTimeout();
- }
- catch (final SQLException e) {
+ return connection.getNetworkTimeout();
+ } catch (final SQLException e) {
handleException(e);
return 0;
}
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org