You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2016/02/08 22:56:49 UTC
svn commit: r1729274 [3/7] - in /commons/proper/dbcp/trunk/src:
main/java/org/apache/commons/dbcp2/
main/java/org/apache/commons/dbcp2/cpdsadapter/
main/java/org/apache/commons/dbcp2/datasources/
main/java/org/apache/commons/dbcp2/managed/ test/java/or...
Modified: commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java
URL: http://svn.apache.org/viewvc/commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java?rev=1729274&r1=1729273&r2=1729274&view=diff
==============================================================================
--- commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java (original)
+++ commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java Mon Feb 8 21:56:48 2016
@@ -82,7 +82,7 @@ public class DelegatingPreparedStatement
try {
return DelegatingResultSet.wrapResultSet(this,((PreparedStatement)getDelegate()).executeQuery());
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -96,7 +96,7 @@ public class DelegatingPreparedStatement
}
try {
return ((PreparedStatement) getDelegate()).executeUpdate();
- } catch (SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return 0;
}
@@ -104,89 +104,89 @@ public class DelegatingPreparedStatement
@Override
public void setNull(int parameterIndex, int sqlType) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setNull(parameterIndex,sqlType); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setNull(parameterIndex,sqlType); } catch (final SQLException e) { handleException(e); } }
@Override
public void setBoolean(int parameterIndex, boolean x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setBoolean(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setBoolean(parameterIndex,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setByte(int parameterIndex, byte x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setByte(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setByte(parameterIndex,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setShort(int parameterIndex, short x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setShort(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setShort(parameterIndex,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setInt(int parameterIndex, int x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setInt(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setInt(parameterIndex,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setLong(int parameterIndex, long x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setLong(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setLong(parameterIndex,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setFloat(int parameterIndex, float x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setFloat(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setFloat(parameterIndex,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setDouble(int parameterIndex, double x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setDouble(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setDouble(parameterIndex,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setBigDecimal(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setBigDecimal(parameterIndex,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setString(int parameterIndex, String x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setString(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setString(parameterIndex,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setBytes(int parameterIndex, byte[] x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setBytes(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setBytes(parameterIndex,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setDate(int parameterIndex, Date x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setDate(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setDate(parameterIndex,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setTime(int parameterIndex, Time x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setTime(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setTime(parameterIndex,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setTimestamp(parameterIndex,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setTimestamp(parameterIndex,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setAsciiStream(parameterIndex,x,length); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setAsciiStream(parameterIndex,x,length); } catch (final SQLException e) { handleException(e); } }
/** @deprecated Use setAsciiStream(), setCharacterStream() or setNCharacterStream() */
@Deprecated
@Override
public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setUnicodeStream(parameterIndex,x,length); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setUnicodeStream(parameterIndex,x,length); } catch (final SQLException e) { handleException(e); } }
@Override
public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setBinaryStream(parameterIndex,x,length); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setBinaryStream(parameterIndex,x,length); } catch (final SQLException e) { handleException(e); } }
@Override
public void clearParameters() throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).clearParameters(); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).clearParameters(); } catch (final SQLException e) { handleException(e); } }
@Override
public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setObject(parameterIndex, x, targetSqlType, scale); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setObject(parameterIndex, x, targetSqlType, scale); } catch (final SQLException e) { handleException(e); } }
@Override
public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setObject(parameterIndex, x, targetSqlType); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setObject(parameterIndex, x, targetSqlType); } catch (final SQLException e) { handleException(e); } }
@Override
public void setObject(int parameterIndex, Object x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setObject(parameterIndex, x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setObject(parameterIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public boolean execute() throws SQLException {
@@ -196,7 +196,7 @@ public class DelegatingPreparedStatement
}
try {
return ((PreparedStatement) getDelegate()).execute();
- } catch (SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return false;
}
@@ -204,47 +204,47 @@ public class DelegatingPreparedStatement
@Override
public void addBatch() throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).addBatch(); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).addBatch(); } catch (final SQLException e) { handleException(e); } }
@Override
public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setCharacterStream(parameterIndex,reader,length); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setCharacterStream(parameterIndex,reader,length); } catch (final SQLException e) { handleException(e); } }
@Override
public void setRef(int i, Ref x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setRef(i,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setRef(i,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setBlob(int i, Blob x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setBlob(i,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setBlob(i,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setClob(int i, Clob x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setClob(i,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setClob(i,x); } catch (final SQLException e) { handleException(e); } }
@Override
public void setArray(int i, Array x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setArray(i,x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setArray(i,x); } catch (final SQLException e) { handleException(e); } }
@Override
public ResultSetMetaData getMetaData() throws SQLException
- { checkOpen(); try { return ((PreparedStatement)getDelegate()).getMetaData(); } catch (SQLException e) { handleException(e); throw new AssertionError(); } }
+ { checkOpen(); try { return ((PreparedStatement)getDelegate()).getMetaData(); } catch (final SQLException e) { handleException(e); throw new AssertionError(); } }
@Override
public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setDate(parameterIndex,x,cal); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setDate(parameterIndex,x,cal); } catch (final SQLException e) { handleException(e); } }
@Override
public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setTime(parameterIndex,x,cal); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setTime(parameterIndex,x,cal); } catch (final SQLException e) { handleException(e); } }
@Override
public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setTimestamp(parameterIndex,x,cal); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setTimestamp(parameterIndex,x,cal); } catch (final SQLException e) { handleException(e); } }
@Override
public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setNull(paramIndex,sqlType,typeName); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setNull(paramIndex,sqlType,typeName); } catch (final SQLException e) { handleException(e); } }
/**
* Returns a String representation of this object.
@@ -253,17 +253,17 @@ public class DelegatingPreparedStatement
*/
@Override
public String toString() {
- Statement statement = getDelegate();
+ final Statement statement = getDelegate();
return statement == null ? "NULL" : statement.toString();
}
@Override
public void setURL(int parameterIndex, java.net.URL x) throws SQLException
- { checkOpen(); try { ((PreparedStatement)getDelegate()).setURL(parameterIndex, x); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { ((PreparedStatement)getDelegate()).setURL(parameterIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public java.sql.ParameterMetaData getParameterMetaData() throws SQLException
- { checkOpen(); try { return ((PreparedStatement)getDelegate()).getParameterMetaData(); } catch (SQLException e) { handleException(e); throw new AssertionError(); } }
+ { checkOpen(); try { return ((PreparedStatement)getDelegate()).getParameterMetaData(); } catch (final SQLException e) { handleException(e); throw new AssertionError(); } }
@Override
@@ -272,7 +272,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setRowId(parameterIndex, value);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -283,7 +283,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setNString(parameterIndex, value);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -294,7 +294,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setNCharacterStream(parameterIndex, value, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -305,7 +305,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setNClob(parameterIndex, value);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -316,7 +316,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setClob(parameterIndex, reader, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -327,7 +327,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setBlob(parameterIndex, inputStream, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -338,7 +338,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setNClob(parameterIndex, reader, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -349,7 +349,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setSQLXML(parameterIndex, value);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -360,7 +360,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setAsciiStream(parameterIndex, inputStream, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -371,7 +371,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setBinaryStream(parameterIndex, inputStream, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -382,7 +382,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setCharacterStream(parameterIndex, reader, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -393,7 +393,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setAsciiStream(parameterIndex, inputStream);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -404,7 +404,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setBinaryStream(parameterIndex, inputStream);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -415,7 +415,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setCharacterStream(parameterIndex, reader);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -426,7 +426,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setNCharacterStream(parameterIndex, reader);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -437,7 +437,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setClob(parameterIndex, reader);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -448,7 +448,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setBlob(parameterIndex, inputStream);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -459,7 +459,7 @@ public class DelegatingPreparedStatement
try {
((PreparedStatement)getDelegate()).setNClob(parameterIndex, reader);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
Modified: commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingResultSet.java
URL: http://svn.apache.org/viewvc/commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingResultSet.java?rev=1729274&r1=1729273&r2=1729274&view=diff
==============================================================================
--- commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingResultSet.java (original)
+++ commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingResultSet.java Mon Feb 8 21:56:48 2016
@@ -169,7 +169,7 @@ public final class DelegatingResultSet e
}
_res.close();
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -188,560 +188,560 @@ public final class DelegatingResultSet e
@Override
public boolean next() throws SQLException
- { try { return _res.next(); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.next(); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public boolean wasNull() throws SQLException
- { try { return _res.wasNull(); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.wasNull(); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public String getString(int columnIndex) throws SQLException
- { try { return _res.getString(columnIndex); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getString(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public boolean getBoolean(int columnIndex) throws SQLException
- { try { return _res.getBoolean(columnIndex); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.getBoolean(columnIndex); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public byte getByte(int columnIndex) throws SQLException
- { try { return _res.getByte(columnIndex); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getByte(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public short getShort(int columnIndex) throws SQLException
- { try { return _res.getShort(columnIndex); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getShort(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public int getInt(int columnIndex) throws SQLException
- { try { return _res.getInt(columnIndex); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getInt(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public long getLong(int columnIndex) throws SQLException
- { try { return _res.getLong(columnIndex); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getLong(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public float getFloat(int columnIndex) throws SQLException
- { try { return _res.getFloat(columnIndex); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getFloat(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public double getDouble(int columnIndex) throws SQLException
- { try { return _res.getDouble(columnIndex); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getDouble(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
/** @deprecated Use {@link #getBigDecimal(int)} */
@Deprecated
@Override
public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException
- { try { return _res.getBigDecimal(columnIndex); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getBigDecimal(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public byte[] getBytes(int columnIndex) throws SQLException
- { try { return _res.getBytes(columnIndex); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getBytes(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Date getDate(int columnIndex) throws SQLException
- { try { return _res.getDate(columnIndex); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getDate(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Time getTime(int columnIndex) throws SQLException
- { try { return _res.getTime(columnIndex); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getTime(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Timestamp getTimestamp(int columnIndex) throws SQLException
- { try { return _res.getTimestamp(columnIndex); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getTimestamp(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public InputStream getAsciiStream(int columnIndex) throws SQLException
- { try { return _res.getAsciiStream(columnIndex); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getAsciiStream(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
/** @deprecated Use {@link #getCharacterStream(int)} */
@Deprecated
@Override
public InputStream getUnicodeStream(int columnIndex) throws SQLException
- { try { return _res.getUnicodeStream(columnIndex); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getUnicodeStream(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public InputStream getBinaryStream(int columnIndex) throws SQLException
- { try { return _res.getBinaryStream(columnIndex); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getBinaryStream(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public String getString(String columnName) throws SQLException
- { try { return _res.getString(columnName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getString(columnName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public boolean getBoolean(String columnName) throws SQLException
- { try { return _res.getBoolean(columnName); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.getBoolean(columnName); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public byte getByte(String columnName) throws SQLException
- { try { return _res.getByte(columnName); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getByte(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public short getShort(String columnName) throws SQLException
- { try { return _res.getShort(columnName); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getShort(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public int getInt(String columnName) throws SQLException
- { try { return _res.getInt(columnName); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getInt(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public long getLong(String columnName) throws SQLException
- { try { return _res.getLong(columnName); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getLong(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public float getFloat(String columnName) throws SQLException
- { try { return _res.getFloat(columnName); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getFloat(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public double getDouble(String columnName) throws SQLException
- { try { return _res.getDouble(columnName); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getDouble(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
/** @deprecated Use {@link #getBigDecimal(String)} */
@Deprecated
@Override
public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException
- { try { return _res.getBigDecimal(columnName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getBigDecimal(columnName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public byte[] getBytes(String columnName) throws SQLException
- { try { return _res.getBytes(columnName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getBytes(columnName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Date getDate(String columnName) throws SQLException
- { try { return _res.getDate(columnName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getDate(columnName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Time getTime(String columnName) throws SQLException
- { try { return _res.getTime(columnName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getTime(columnName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Timestamp getTimestamp(String columnName) throws SQLException
- { try { return _res.getTimestamp(columnName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getTimestamp(columnName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public InputStream getAsciiStream(String columnName) throws SQLException
- { try { return _res.getAsciiStream(columnName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getAsciiStream(columnName); } catch (final SQLException e) { handleException(e); return null; } }
/** @deprecated Use {@link #getCharacterStream(String)} */
@Deprecated
@Override
public InputStream getUnicodeStream(String columnName) throws SQLException
- { try { return _res.getUnicodeStream(columnName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getUnicodeStream(columnName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public InputStream getBinaryStream(String columnName) throws SQLException
- { try { return _res.getBinaryStream(columnName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getBinaryStream(columnName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public SQLWarning getWarnings() throws SQLException
- { try { return _res.getWarnings(); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getWarnings(); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public void clearWarnings() throws SQLException
- { try { _res.clearWarnings(); } catch (SQLException e) { handleException(e); } }
+ { try { _res.clearWarnings(); } catch (final SQLException e) { handleException(e); } }
@Override
public String getCursorName() throws SQLException
- { try { return _res.getCursorName(); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getCursorName(); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public ResultSetMetaData getMetaData() throws SQLException
- { try { return _res.getMetaData(); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getMetaData(); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Object getObject(int columnIndex) throws SQLException
- { try { return _res.getObject(columnIndex); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getObject(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Object getObject(String columnName) throws SQLException
- { try { return _res.getObject(columnName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getObject(columnName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public int findColumn(String columnName) throws SQLException
- { try { return _res.findColumn(columnName); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.findColumn(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public Reader getCharacterStream(int columnIndex) throws SQLException
- { try { return _res.getCharacterStream(columnIndex); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getCharacterStream(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Reader getCharacterStream(String columnName) throws SQLException
- { try { return _res.getCharacterStream(columnName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getCharacterStream(columnName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public BigDecimal getBigDecimal(int columnIndex) throws SQLException
- { try { return _res.getBigDecimal(columnIndex); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getBigDecimal(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public BigDecimal getBigDecimal(String columnName) throws SQLException
- { try { return _res.getBigDecimal(columnName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getBigDecimal(columnName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public boolean isBeforeFirst() throws SQLException
- { try { return _res.isBeforeFirst(); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.isBeforeFirst(); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public boolean isAfterLast() throws SQLException
- { try { return _res.isAfterLast(); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.isAfterLast(); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public boolean isFirst() throws SQLException
- { try { return _res.isFirst(); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.isFirst(); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public boolean isLast() throws SQLException
- { try { return _res.isLast(); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.isLast(); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public void beforeFirst() throws SQLException
- { try { _res.beforeFirst(); } catch (SQLException e) { handleException(e); } }
+ { try { _res.beforeFirst(); } catch (final SQLException e) { handleException(e); } }
@Override
public void afterLast() throws SQLException
- { try { _res.afterLast(); } catch (SQLException e) { handleException(e); } }
+ { try { _res.afterLast(); } catch (final SQLException e) { handleException(e); } }
@Override
public boolean first() throws SQLException
- { try { return _res.first(); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.first(); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public boolean last() throws SQLException
- { try { return _res.last(); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.last(); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public int getRow() throws SQLException
- { try { return _res.getRow(); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getRow(); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public boolean absolute(int row) throws SQLException
- { try { return _res.absolute(row); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.absolute(row); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public boolean relative(int rows) throws SQLException
- { try { return _res.relative(rows); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.relative(rows); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public boolean previous() throws SQLException
- { try { return _res.previous(); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.previous(); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public void setFetchDirection(int direction) throws SQLException
- { try { _res.setFetchDirection(direction); } catch (SQLException e) { handleException(e); } }
+ { try { _res.setFetchDirection(direction); } catch (final SQLException e) { handleException(e); } }
@Override
public int getFetchDirection() throws SQLException
- { try { return _res.getFetchDirection(); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getFetchDirection(); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public void setFetchSize(int rows) throws SQLException
- { try { _res.setFetchSize(rows); } catch (SQLException e) { handleException(e); } }
+ { try { _res.setFetchSize(rows); } catch (final SQLException e) { handleException(e); } }
@Override
public int getFetchSize() throws SQLException
- { try { return _res.getFetchSize(); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getFetchSize(); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public int getType() throws SQLException
- { try { return _res.getType(); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getType(); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public int getConcurrency() throws SQLException
- { try { return _res.getConcurrency(); } catch (SQLException e) { handleException(e); return 0; } }
+ { try { return _res.getConcurrency(); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public boolean rowUpdated() throws SQLException
- { try { return _res.rowUpdated(); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.rowUpdated(); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public boolean rowInserted() throws SQLException
- { try { return _res.rowInserted(); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.rowInserted(); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public boolean rowDeleted() throws SQLException
- { try { return _res.rowDeleted(); } catch (SQLException e) { handleException(e); return false; } }
+ { try { return _res.rowDeleted(); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public void updateNull(int columnIndex) throws SQLException
- { try { _res.updateNull(columnIndex); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateNull(columnIndex); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateBoolean(int columnIndex, boolean x) throws SQLException
- { try { _res.updateBoolean(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateBoolean(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateByte(int columnIndex, byte x) throws SQLException
- { try { _res.updateByte(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateByte(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateShort(int columnIndex, short x) throws SQLException
- { try { _res.updateShort(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateShort(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateInt(int columnIndex, int x) throws SQLException
- { try { _res.updateInt(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateInt(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateLong(int columnIndex, long x) throws SQLException
- { try { _res.updateLong(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateLong(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateFloat(int columnIndex, float x) throws SQLException
- { try { _res.updateFloat(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateFloat(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateDouble(int columnIndex, double x) throws SQLException
- { try { _res.updateDouble(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateDouble(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException
- { try { _res.updateBigDecimal(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateBigDecimal(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateString(int columnIndex, String x) throws SQLException
- { try { _res.updateString(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateString(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateBytes(int columnIndex, byte[] x) throws SQLException
- { try { _res.updateBytes(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateBytes(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateDate(int columnIndex, Date x) throws SQLException
- { try { _res.updateDate(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateDate(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateTime(int columnIndex, Time x) throws SQLException
- { try { _res.updateTime(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateTime(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException
- { try { _res.updateTimestamp(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateTimestamp(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException
- { try { _res.updateAsciiStream(columnIndex, x, length); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateAsciiStream(columnIndex, x, length); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException
- { try { _res.updateBinaryStream(columnIndex, x, length); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateBinaryStream(columnIndex, x, length); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException
- { try { _res.updateCharacterStream(columnIndex, x, length); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateCharacterStream(columnIndex, x, length); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateObject(int columnIndex, Object x, int scale) throws SQLException
- { try { _res.updateObject(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateObject(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateObject(int columnIndex, Object x) throws SQLException
- { try { _res.updateObject(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateObject(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateNull(String columnName) throws SQLException
- { try { _res.updateNull(columnName); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateNull(columnName); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateBoolean(String columnName, boolean x) throws SQLException
- { try { _res.updateBoolean(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateBoolean(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateByte(String columnName, byte x) throws SQLException
- { try { _res.updateByte(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateByte(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateShort(String columnName, short x) throws SQLException
- { try { _res.updateShort(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateShort(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateInt(String columnName, int x) throws SQLException
- { try { _res.updateInt(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateInt(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateLong(String columnName, long x) throws SQLException
- { try { _res.updateLong(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateLong(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateFloat(String columnName, float x) throws SQLException
- { try { _res.updateFloat(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateFloat(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateDouble(String columnName, double x) throws SQLException
- { try { _res.updateDouble(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateDouble(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException
- { try { _res.updateBigDecimal(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateBigDecimal(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateString(String columnName, String x) throws SQLException
- { try { _res.updateString(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateString(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateBytes(String columnName, byte[] x) throws SQLException
- { try { _res.updateBytes(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateBytes(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateDate(String columnName, Date x) throws SQLException
- { try { _res.updateDate(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateDate(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateTime(String columnName, Time x) throws SQLException
- { try { _res.updateTime(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateTime(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateTimestamp(String columnName, Timestamp x) throws SQLException
- { try { _res.updateTimestamp(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateTimestamp(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateAsciiStream(String columnName, InputStream x, int length) throws SQLException
- { try { _res.updateAsciiStream(columnName, x, length); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateAsciiStream(columnName, x, length); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateBinaryStream(String columnName, InputStream x, int length) throws SQLException
- { try { _res.updateBinaryStream(columnName, x, length); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateBinaryStream(columnName, x, length); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateCharacterStream(String columnName, Reader reader, int length) throws SQLException
- { try { _res.updateCharacterStream(columnName, reader, length); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateCharacterStream(columnName, reader, length); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateObject(String columnName, Object x, int scale) throws SQLException
- { try { _res.updateObject(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateObject(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateObject(String columnName, Object x) throws SQLException
- { try { _res.updateObject(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateObject(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void insertRow() throws SQLException
- { try { _res.insertRow(); } catch (SQLException e) { handleException(e); } }
+ { try { _res.insertRow(); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateRow() throws SQLException
- { try { _res.updateRow(); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateRow(); } catch (final SQLException e) { handleException(e); } }
@Override
public void deleteRow() throws SQLException
- { try { _res.deleteRow(); } catch (SQLException e) { handleException(e); } }
+ { try { _res.deleteRow(); } catch (final SQLException e) { handleException(e); } }
@Override
public void refreshRow() throws SQLException
- { try { _res.refreshRow(); } catch (SQLException e) { handleException(e); } }
+ { try { _res.refreshRow(); } catch (final SQLException e) { handleException(e); } }
@Override
public void cancelRowUpdates() throws SQLException
- { try { _res.cancelRowUpdates(); } catch (SQLException e) { handleException(e); } }
+ { try { _res.cancelRowUpdates(); } catch (final SQLException e) { handleException(e); } }
@Override
public void moveToInsertRow() throws SQLException
- { try { _res.moveToInsertRow(); } catch (SQLException e) { handleException(e); } }
+ { try { _res.moveToInsertRow(); } catch (final SQLException e) { handleException(e); } }
@Override
public void moveToCurrentRow() throws SQLException
- { try { _res.moveToCurrentRow(); } catch (SQLException e) { handleException(e); } }
+ { try { _res.moveToCurrentRow(); } catch (final SQLException e) { handleException(e); } }
@Override
public Object getObject(int i, Map<String,Class<?>> map) throws SQLException
- { try { return _res.getObject(i, map); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getObject(i, map); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Ref getRef(int i) throws SQLException
- { try { return _res.getRef(i); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getRef(i); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Blob getBlob(int i) throws SQLException
- { try { return _res.getBlob(i); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getBlob(i); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Clob getClob(int i) throws SQLException
- { try { return _res.getClob(i); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getClob(i); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Array getArray(int i) throws SQLException
- { try { return _res.getArray(i); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getArray(i); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Object getObject(String colName, Map<String,Class<?>> map) throws SQLException
- { try { return _res.getObject(colName, map); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getObject(colName, map); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Ref getRef(String colName) throws SQLException
- { try { return _res.getRef(colName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getRef(colName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Blob getBlob(String colName) throws SQLException
- { try { return _res.getBlob(colName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getBlob(colName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Clob getClob(String colName) throws SQLException
- { try { return _res.getClob(colName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getClob(colName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Array getArray(String colName) throws SQLException
- { try { return _res.getArray(colName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getArray(colName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Date getDate(int columnIndex, Calendar cal) throws SQLException
- { try { return _res.getDate(columnIndex, cal); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getDate(columnIndex, cal); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Date getDate(String columnName, Calendar cal) throws SQLException
- { try { return _res.getDate(columnName, cal); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getDate(columnName, cal); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Time getTime(int columnIndex, Calendar cal) throws SQLException
- { try { return _res.getTime(columnIndex, cal); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getTime(columnIndex, cal); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Time getTime(String columnName, Calendar cal) throws SQLException
- { try { return _res.getTime(columnName, cal); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getTime(columnName, cal); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException
- { try { return _res.getTimestamp(columnIndex, cal); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getTimestamp(columnIndex, cal); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException
- { try { return _res.getTimestamp(columnName, cal); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getTimestamp(columnName, cal); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public java.net.URL getURL(int columnIndex) throws SQLException
- { try { return _res.getURL(columnIndex); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getURL(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public java.net.URL getURL(String columnName) throws SQLException
- { try { return _res.getURL(columnName); } catch (SQLException e) { handleException(e); return null; } }
+ { try { return _res.getURL(columnName); } catch (final SQLException e) { handleException(e); return null; } }
@Override
public void updateRef(int columnIndex, Ref x) throws SQLException
- { try { _res.updateRef(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateRef(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateRef(String columnName, Ref x) throws SQLException
- { try { _res.updateRef(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateRef(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateBlob(int columnIndex, Blob x) throws SQLException
- { try { _res.updateBlob(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateBlob(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateBlob(String columnName, Blob x) throws SQLException
- { try { _res.updateBlob(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateBlob(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateClob(int columnIndex, Clob x) throws SQLException
- { try { _res.updateClob(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateClob(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateClob(String columnName, Clob x) throws SQLException
- { try { _res.updateClob(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateClob(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateArray(int columnIndex, Array x) throws SQLException
- { try { _res.updateArray(columnIndex, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateArray(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
@Override
public void updateArray(String columnName, Array x) throws SQLException
- { try { _res.updateArray(columnName, x); } catch (SQLException e) { handleException(e); } }
+ { try { _res.updateArray(columnName, x); } catch (final SQLException e) { handleException(e); } }
@Override
@@ -771,7 +771,7 @@ public final class DelegatingResultSet e
try {
return _res.getRowId(columnIndex);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
@@ -782,7 +782,7 @@ public final class DelegatingResultSet e
try {
return _res.getRowId(columnLabel);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
@@ -793,7 +793,7 @@ public final class DelegatingResultSet e
try {
_res.updateRowId(columnIndex, value);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -803,7 +803,7 @@ public final class DelegatingResultSet e
try {
_res.updateRowId(columnLabel, value);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -813,7 +813,7 @@ public final class DelegatingResultSet e
try {
return _res.getHoldability();
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return 0;
}
@@ -824,7 +824,7 @@ public final class DelegatingResultSet e
try {
return _res.isClosed();
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return false;
}
@@ -835,7 +835,7 @@ public final class DelegatingResultSet e
try {
_res.updateNString(columnIndex, value);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -845,7 +845,7 @@ public final class DelegatingResultSet e
try {
_res.updateNString(columnLabel, value);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -855,7 +855,7 @@ public final class DelegatingResultSet e
try {
_res.updateNClob(columnIndex, value);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -865,7 +865,7 @@ public final class DelegatingResultSet e
try {
_res.updateNClob(columnLabel, value);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -875,7 +875,7 @@ public final class DelegatingResultSet e
try {
return _res.getNClob(columnIndex);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
@@ -886,7 +886,7 @@ public final class DelegatingResultSet e
try {
return _res.getNClob(columnLabel);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
@@ -897,7 +897,7 @@ public final class DelegatingResultSet e
try {
return _res.getSQLXML(columnIndex);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
@@ -908,7 +908,7 @@ public final class DelegatingResultSet e
try {
return _res.getSQLXML(columnLabel);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
@@ -919,7 +919,7 @@ public final class DelegatingResultSet e
try {
_res.updateSQLXML(columnIndex, value);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -929,7 +929,7 @@ public final class DelegatingResultSet e
try {
_res.updateSQLXML(columnLabel, value);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -939,7 +939,7 @@ public final class DelegatingResultSet e
try {
return _res.getNString(columnIndex);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
@@ -950,7 +950,7 @@ public final class DelegatingResultSet e
try {
return _res.getNString(columnLabel);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
@@ -961,7 +961,7 @@ public final class DelegatingResultSet e
try {
return _res.getNCharacterStream(columnIndex);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
@@ -972,7 +972,7 @@ public final class DelegatingResultSet e
try {
return _res.getNCharacterStream(columnLabel);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
@@ -983,7 +983,7 @@ public final class DelegatingResultSet e
try {
_res.updateNCharacterStream(columnIndex, reader, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -993,7 +993,7 @@ public final class DelegatingResultSet e
try {
_res.updateNCharacterStream(columnLabel, reader, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1003,7 +1003,7 @@ public final class DelegatingResultSet e
try {
_res.updateAsciiStream(columnIndex, inputStream, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1013,7 +1013,7 @@ public final class DelegatingResultSet e
try {
_res.updateBinaryStream(columnIndex, inputStream, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1023,7 +1023,7 @@ public final class DelegatingResultSet e
try {
_res.updateCharacterStream(columnIndex, reader, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1033,7 +1033,7 @@ public final class DelegatingResultSet e
try {
_res.updateAsciiStream(columnLabel, inputStream, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1043,7 +1043,7 @@ public final class DelegatingResultSet e
try {
_res.updateBinaryStream(columnLabel, inputStream, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1053,7 +1053,7 @@ public final class DelegatingResultSet e
try {
_res.updateCharacterStream(columnLabel, reader, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1063,7 +1063,7 @@ public final class DelegatingResultSet e
try {
_res.updateBlob(columnIndex, inputStream, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1073,7 +1073,7 @@ public final class DelegatingResultSet e
try {
_res.updateBlob(columnLabel, inputStream, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1083,7 +1083,7 @@ public final class DelegatingResultSet e
try {
_res.updateClob(columnIndex, reader, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1093,7 +1093,7 @@ public final class DelegatingResultSet e
try {
_res.updateClob(columnLabel, reader, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1103,7 +1103,7 @@ public final class DelegatingResultSet e
try {
_res.updateNClob(columnIndex, reader, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1113,7 +1113,7 @@ public final class DelegatingResultSet e
try {
_res.updateNClob(columnLabel, reader, length);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1123,7 +1123,7 @@ public final class DelegatingResultSet e
try {
_res.updateNCharacterStream(columnIndex, reader);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1133,7 +1133,7 @@ public final class DelegatingResultSet e
try {
_res.updateNCharacterStream(columnLabel, reader);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1143,7 +1143,7 @@ public final class DelegatingResultSet e
try {
_res.updateAsciiStream(columnIndex, inputStream);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1153,7 +1153,7 @@ public final class DelegatingResultSet e
try {
_res.updateBinaryStream(columnIndex, inputStream);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1163,7 +1163,7 @@ public final class DelegatingResultSet e
try {
_res.updateCharacterStream(columnIndex, reader);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1173,7 +1173,7 @@ public final class DelegatingResultSet e
try {
_res.updateAsciiStream(columnLabel, inputStream);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1183,7 +1183,7 @@ public final class DelegatingResultSet e
try {
_res.updateBinaryStream(columnLabel, inputStream);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1193,7 +1193,7 @@ public final class DelegatingResultSet e
try {
_res.updateCharacterStream(columnLabel, reader);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1203,7 +1203,7 @@ public final class DelegatingResultSet e
try {
_res.updateBlob(columnIndex, inputStream);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1213,7 +1213,7 @@ public final class DelegatingResultSet e
try {
_res.updateBlob(columnLabel, inputStream);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1223,7 +1223,7 @@ public final class DelegatingResultSet e
try {
_res.updateClob(columnIndex, reader);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1233,7 +1233,7 @@ public final class DelegatingResultSet e
try {
_res.updateClob(columnLabel, reader);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1243,7 +1243,7 @@ public final class DelegatingResultSet e
try {
_res.updateNClob(columnIndex, reader);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1253,7 +1253,7 @@ public final class DelegatingResultSet e
try {
_res.updateNClob(columnLabel, reader);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -1263,7 +1263,7 @@ public final class DelegatingResultSet e
try {
return _res.getObject(columnIndex, type);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
@@ -1275,7 +1275,7 @@ public final class DelegatingResultSet e
try {
return _res.getObject(columnLabel, type);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
Re: svn commit: r1729274 [3/7] - in /commons/proper/dbcp/trunk/src: main/java/org/apache/commons/dbcp2/ main/java/org/apache/commons/dbcp2/cpdsadapter/ main/java/org/apache/commons/dbcp2/datasources/ main/java/org/apache/commons/dbcp2/managed/ test/java/or...
Posted by Mark Thomas <ma...@apache.org>.
On 8 February 2016 23:17:35 GMT+00:00, Emmanuel Bourg <eb...@apache.org> wrote:
>Le 8/02/2016 23:51, Gary Gregory a écrit :
>
>> It's simpler to be consistent when using final IMO. The intent is the
>same:
>> https://garygregory.wordpress.com/2013/01/26/the-final-kiss-in-java/
>
>"The road to hell is paved with good intentions" comes to mind here. I
>understand the intent but I don't think it's a good idea for catch
>statements. It brings no technical benefit and harms the readability.
For the record, while I understand where these final changes are coming from , I don't think what they add is worth what they take away in readability.
That said, I don't feel strongly enough to be particular bothered. If someone wants to spend their time on these changes, l'm not going to object ... as long as they don't break anything in the process.
Mark
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@commons.apache.org
For additional commands, e-mail: dev-help@commons.apache.org
Re: svn commit: r1729274 [3/7] - in /commons/proper/dbcp/trunk/src:
main/java/org/apache/commons/dbcp2/ main/java/org/apache/commons/dbcp2/cpdsadapter/
main/java/org/apache/commons/dbcp2/datasources/ main/java/org/apache/commons/dbcp2/managed/
test/java/or...
Posted by Gary Gregory <ga...@gmail.com>.
On Feb 8, 2016 3:17 PM, "Emmanuel Bourg" <eb...@apache.org> wrote:
>
> Le 8/02/2016 23:51, Gary Gregory a écrit :
>
> > It's simpler to be consistent when using final IMO. The intent is the
same:
> > https://garygregory.wordpress.com/2013/01/26/the-final-kiss-in-java/
>
> "The road to hell is paved with good intentions" comes to mind here. I
> understand the intent but I don't think it's a good idea for catch
> statements. It brings no technical benefit and harms the readability.
"Beauty is in the eye of the beholder".
I'd rather have less room for error than succinct code. Java is verbose by
design anyway. I want the compiler to stop me from possibly doing something
silly. If I really want to assign to the exception var, then I can remove
the final.
"Diff'rent strokes for diff'renr folks".
More quotes! As opposed to "more cowbell!"
:-)
Gary
>
> Emmanuel Bourg
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: dev-unsubscribe@commons.apache.org
> For additional commands, e-mail: dev-help@commons.apache.org
>
Re: svn commit: r1729274 [3/7] - in /commons/proper/dbcp/trunk/src:
main/java/org/apache/commons/dbcp2/
main/java/org/apache/commons/dbcp2/cpdsadapter/
main/java/org/apache/commons/dbcp2/datasources/
main/java/org/apache/commons/dbcp2/managed/ test/java/or...
Posted by Emmanuel Bourg <eb...@apache.org>.
Le 8/02/2016 23:51, Gary Gregory a écrit :
> It's simpler to be consistent when using final IMO. The intent is the same:
> https://garygregory.wordpress.com/2013/01/26/the-final-kiss-in-java/
"The road to hell is paved with good intentions" comes to mind here. I
understand the intent but I don't think it's a good idea for catch
statements. It brings no technical benefit and harms the readability.
Emmanuel Bourg
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@commons.apache.org
For additional commands, e-mail: dev-help@commons.apache.org
Re: svn commit: r1729274 [3/7] - in /commons/proper/dbcp/trunk/src:
main/java/org/apache/commons/dbcp2/ main/java/org/apache/commons/dbcp2/cpdsadapter/
main/java/org/apache/commons/dbcp2/datasources/ main/java/org/apache/commons/dbcp2/managed/
test/java/or...
Posted by Gary Gregory <ga...@gmail.com>.
On Feb 8, 2016 2:08 PM, "Emmanuel Bourg" <eb...@apache.org> wrote:
>
> Le 8/02/2016 22:56, ggregory@apache.org a écrit :
> > Modified:
commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java
> > URL:
http://svn.apache.org/viewvc/commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java?rev=1729274&r1=1729273&r2=1729274&view=diff
> >
==============================================================================
> > ---
commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java
(original)
> > +++
commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java
Mon Feb 8 21:56:48 2016
> > @@ -82,7 +82,7 @@ public class DelegatingPreparedStatement
> > try {
> > return
DelegatingResultSet.wrapResultSet(this,((PreparedStatement)getDelegate()).executeQuery());
> > }
> > - catch (SQLException e) {
> > + catch (final SQLException e) {
> > handleException(e);
> > throw new AssertionError();
> > }
>
> Am I the only one to think this syntax is uselessly verbose ? I'm ok
> with final class variables, less with final local parameters, but final
> exceptions look really useless to me.
It's simpler to be consistent when using final IMO. The intent is the same:
https://garygregory.wordpress.com/2013/01/26/the-final-kiss-in-java/
Gary
>
> Emmanuel Bourg
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: dev-unsubscribe@commons.apache.org
> For additional commands, e-mail: dev-help@commons.apache.org
>
Re: svn commit: r1729274 [3/7] - in /commons/proper/dbcp/trunk/src:
main/java/org/apache/commons/dbcp2/
main/java/org/apache/commons/dbcp2/cpdsadapter/
main/java/org/apache/commons/dbcp2/datasources/
main/java/org/apache/commons/dbcp2/managed/ test/java/or...
Posted by Emmanuel Bourg <eb...@apache.org>.
Le 8/02/2016 22:56, ggregory@apache.org a écrit :
> Modified: commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java
> URL: http://svn.apache.org/viewvc/commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java?rev=1729274&r1=1729273&r2=1729274&view=diff
> ==============================================================================
> --- commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java (original)
> +++ commons/proper/dbcp/trunk/src/main/java/org/apache/commons/dbcp2/DelegatingPreparedStatement.java Mon Feb 8 21:56:48 2016
> @@ -82,7 +82,7 @@ public class DelegatingPreparedStatement
> try {
> return DelegatingResultSet.wrapResultSet(this,((PreparedStatement)getDelegate()).executeQuery());
> }
> - catch (SQLException e) {
> + catch (final SQLException e) {
> handleException(e);
> throw new AssertionError();
> }
Am I the only one to think this syntax is uselessly verbose ? I'm ok
with final class variables, less with final local parameters, but final
exceptions look really useless to me.
Emmanuel Bourg
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@commons.apache.org
For additional commands, e-mail: dev-help@commons.apache.org