--- /srv/reproducible-results/rbuild-debian/r-b-build.W43ikOSE/b1/c3p0_0.9.1.2-10_armhf.changes +++ /srv/reproducible-results/rbuild-debian/r-b-build.W43ikOSE/b2/c3p0_0.9.1.2-10_armhf.changes ├── Files │ @@ -1,3 +1,3 @@ │ │ 6c92b77bc1609e8d36366f88ebbdfa3e 303584 doc optional libc3p0-java-doc_0.9.1.2-10_all.deb │ - bcc1a25c7d1fe6261944a68cdb2e72cc 599484 java optional libc3p0-java_0.9.1.2-10_all.deb │ + 34c507d4d709a3e36b1f67bca437061f 599528 java optional libc3p0-java_0.9.1.2-10_all.deb ├── libc3p0-java_0.9.1.2-10_all.deb │ ├── file list │ │ @@ -1,3 +1,3 @@ │ │ -rw-r--r-- 0 0 0 4 2018-12-25 14:16:25.000000 debian-binary │ │ --rw-r--r-- 0 0 0 812 2018-12-25 14:16:25.000000 control.tar.xz │ │ --rw-r--r-- 0 0 0 598480 2018-12-25 14:16:25.000000 data.tar.xz │ │ +-rw-r--r-- 0 0 0 808 2018-12-25 14:16:25.000000 control.tar.xz │ │ +-rw-r--r-- 0 0 0 598528 2018-12-25 14:16:25.000000 data.tar.xz │ ├── control.tar.xz │ │ ├── control.tar │ │ │ ├── ./md5sums │ │ │ │ ├── ./md5sums │ │ │ │ │┄ Files differ │ ├── data.tar.xz │ │ ├── data.tar │ │ │ ├── file list │ │ │ │ @@ -3,15 +3,15 @@ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/doc/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/doc/libc3p0-java/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 1916 2018-12-25 14:16:25.000000 ./usr/share/doc/libc3p0-java/changelog.Debian.gz │ │ │ │ -rw-r--r-- 0 root (0) root (0) 26278 2007-05-21 18:58:41.000000 ./usr/share/doc/libc3p0-java/changelog.gz │ │ │ │ -rw-r--r-- 0 root (0) root (0) 1528 2018-12-25 14:16:25.000000 ./usr/share/doc/libc3p0-java/copyright │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/java/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 629093 2018-12-25 14:16:25.000000 ./usr/share/java/c3p0-0.9.1.2.jar │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 629078 2018-12-25 14:16:25.000000 ./usr/share/java/c3p0-0.9.1.2.jar │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/maven-repo/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/maven-repo/c3p0/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/maven-repo/c3p0/c3p0/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/maven-repo/c3p0/c3p0/0.9.1.2/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 916 2018-12-25 14:16:25.000000 ./usr/share/maven-repo/c3p0/c3p0/0.9.1.2/c3p0-0.9.1.2.pom │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/maven-repo/c3p0/c3p0/debian/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 915 2018-12-25 14:16:25.000000 ./usr/share/maven-repo/c3p0/c3p0/debian/c3p0-debian.pom │ │ │ ├── ./usr/share/java/c3p0-0.9.1.2.jar │ │ │ │ ├── zipinfo {} │ │ │ │ │ @@ -1,8 +1,8 @@ │ │ │ │ │ -Zip file size: 629093 bytes, number of entries: 434 │ │ │ │ │ +Zip file size: 629078 bytes, number of entries: 434 │ │ │ │ │ drwxr-xr-x 2.0 unx 0 bx stor 18-Dec-25 14:16 META-INF/ │ │ │ │ │ -rw-r--r-- 2.0 unx 348 b- defN 18-Dec-25 14:16 META-INF/MANIFEST.MF │ │ │ │ │ drwxr-xr-x 2.0 unx 0 b- stor 18-Dec-25 14:16 com/ │ │ │ │ │ drwxr-xr-x 2.0 unx 0 b- stor 18-Dec-25 14:16 com/mchange/ │ │ │ │ │ -rw-r--r-- 2.0 unx 389 b- defN 18-Dec-25 14:16 com/mchange/Debug.class │ │ │ │ │ drwxr-xr-x 2.0 unx 0 b- stor 18-Dec-25 14:16 com/mchange/lang/ │ │ │ │ │ -rw-r--r-- 2.0 unx 2589 b- defN 18-Dec-25 14:16 com/mchange/lang/ByteUtils.class │ │ │ │ │ @@ -429,8 +429,8 @@ │ │ │ │ │ -rw-r--r-- 2.0 unx 2990 b- defN 18-Dec-25 14:16 com/mchange/v2/util/DoubleWeakHashMap$UserKeySet.class │ │ │ │ │ -rw-r--r-- 2.0 unx 1256 b- defN 18-Dec-25 14:16 com/mchange/v2/util/DoubleWeakHashMap$ValuesCollection$1.class │ │ │ │ │ -rw-r--r-- 2.0 unx 3497 b- defN 18-Dec-25 14:16 com/mchange/v2/util/DoubleWeakHashMap$ValuesCollection.class │ │ │ │ │ -rw-r--r-- 2.0 unx 1307 b- defN 18-Dec-25 14:16 com/mchange/v2/util/DoubleWeakHashMap$WKey.class │ │ │ │ │ -rw-r--r-- 2.0 unx 931 b- defN 18-Dec-25 14:16 com/mchange/v2/util/DoubleWeakHashMap$WVal.class │ │ │ │ │ -rw-r--r-- 2.0 unx 5389 b- defN 18-Dec-25 14:16 com/mchange/v2/util/DoubleWeakHashMap.class │ │ │ │ │ -rw-r--r-- 2.0 unx 1178 b- defN 18-Dec-25 14:16 com/mchange/v2/util/ResourceClosedException.class │ │ │ │ │ -434 files, 1481383 bytes uncompressed, 554623 bytes compressed: 62.6% │ │ │ │ │ +434 files, 1481383 bytes uncompressed, 554608 bytes compressed: 62.6% │ │ │ │ ├── com/mchange/v2/c3p0/impl/NewProxyCallableStatement.class │ │ │ │ │ ├── procyon -ec {} │ │ │ │ │ │ @@ -10,30 +10,30 @@ │ │ │ │ │ │ import java.sql.Connection; │ │ │ │ │ │ import java.sql.ParameterMetaData; │ │ │ │ │ │ import java.sql.Statement; │ │ │ │ │ │ import java.sql.ResultSet; │ │ │ │ │ │ import java.sql.ResultSetMetaData; │ │ │ │ │ │ import java.sql.Ref; │ │ │ │ │ │ import java.util.Map; │ │ │ │ │ │ -import java.sql.Array; │ │ │ │ │ │ -import java.net.URL; │ │ │ │ │ │ -import java.sql.Timestamp; │ │ │ │ │ │ import java.sql.SQLXML; │ │ │ │ │ │ import java.sql.NClob; │ │ │ │ │ │ import java.sql.RowId; │ │ │ │ │ │ import java.sql.Clob; │ │ │ │ │ │ import java.sql.Blob; │ │ │ │ │ │ import java.io.Reader; │ │ │ │ │ │ import java.sql.SQLType; │ │ │ │ │ │ import java.io.InputStream; │ │ │ │ │ │ import java.sql.Time; │ │ │ │ │ │ -import java.util.Calendar; │ │ │ │ │ │ import java.sql.Date; │ │ │ │ │ │ import java.math.BigDecimal; │ │ │ │ │ │ +import java.sql.Array; │ │ │ │ │ │ +import java.net.URL; │ │ │ │ │ │ +import java.util.Calendar; │ │ │ │ │ │ import java.sql.SQLException; │ │ │ │ │ │ +import java.sql.Timestamp; │ │ │ │ │ │ import javax.sql.ConnectionEventListener; │ │ │ │ │ │ import com.mchange.v2.log.MLogger; │ │ │ │ │ │ import com.mchange.v2.c3p0.C3P0ProxyStatement; │ │ │ │ │ │ import java.sql.CallableStatement; │ │ │ │ │ │ │ │ │ │ │ │ public final class NewProxyCallableStatement implements CallableStatement, C3P0ProxyStatement │ │ │ │ │ │ { │ │ │ │ │ │ @@ -46,18 +46,98 @@ │ │ │ │ │ │ │ │ │ │ │ │ public NewProxyCallableStatement(final CallableStatement inner) { │ │ │ │ │ │ this.cel = (ConnectionEventListener)new NewProxyCallableStatement.NewProxyCallableStatement$1(this); │ │ │ │ │ │ this.inner = inner; │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNull(final String a, final int b, final String c) throws SQLException { │ │ │ │ │ │ + public final void setTimestamp(final String a, final Timestamp b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNull(a, b, c); │ │ │ │ │ │ + this.inner.setTimestamp(a, b); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ + @Override │ │ │ │ │ │ + public final void setTimestamp(final String a, final Timestamp b, final Calendar c) throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + this.maybeDirtyTransaction(); │ │ │ │ │ │ + this.inner.setTimestamp(a, b, c); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ + @Override │ │ │ │ │ │ + public final void setURL(final String a, final URL b) throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + this.maybeDirtyTransaction(); │ │ │ │ │ │ + this.inner.setURL(a, b); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ + @Override │ │ │ │ │ │ + public final Array getArray(final String a) throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + this.maybeDirtyTransaction(); │ │ │ │ │ │ + return this.inner.getArray(a); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ + @Override │ │ │ │ │ │ + public final Array getArray(final int a) throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + this.maybeDirtyTransaction(); │ │ │ │ │ │ + return this.inner.getArray(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -86,14 +166,34 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ + public final void setNull(final String a, final int b, final String c) throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + this.maybeDirtyTransaction(); │ │ │ │ │ │ + this.inner.setNull(a, b, c); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ + @Override │ │ │ │ │ │ public final void setBigDecimal(final String a, final BigDecimal b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ this.inner.setBigDecimal(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ @@ -146,18 +246,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setDate(final String a, final Date b, final Calendar c) throws SQLException { │ │ │ │ │ │ + public final void setDate(final String a, final Date b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDate(a, b, c); │ │ │ │ │ │ + this.inner.setDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -166,18 +266,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setDate(final String a, final Date b) throws SQLException { │ │ │ │ │ │ + public final void setDate(final String a, final Date b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDate(a, b); │ │ │ │ │ │ + this.inner.setDate(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -226,18 +326,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setAsciiStream(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setAsciiStream(a, b); │ │ │ │ │ │ + this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -246,15 +346,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setAsciiStream(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final String a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -266,18 +366,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setAsciiStream(final String a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ + this.inner.setAsciiStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -286,15 +386,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBinaryStream(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final String a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -306,18 +406,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBinaryStream(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBinaryStream(a, b); │ │ │ │ │ │ + this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -326,18 +426,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBinaryStream(final String a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ + this.inner.setBinaryStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -346,18 +446,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final String a, final Object b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final String a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -366,18 +466,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final String a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ + public final void setObject(final String a, final Object b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c, d); │ │ │ │ │ │ + this.inner.setObject(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -386,18 +486,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final String a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ + public final void setObject(final String a, final Object b, final int c, final int d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c); │ │ │ │ │ │ + this.inner.setObject(a, b, c, d); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -406,18 +506,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final String a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setObject(final String a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c); │ │ │ │ │ │ + this.inner.setObject(a, b, c, d); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -426,18 +526,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final String a, final Object b, final int c, final int d) throws SQLException { │ │ │ │ │ │ + public final void setObject(final String a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c, d); │ │ │ │ │ │ + this.inner.setObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -446,18 +546,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setCharacterStream(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void setCharacterStream(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setCharacterStream(a, b); │ │ │ │ │ │ + this.inner.setCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -466,18 +566,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setCharacterStream(final String a, final Reader b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setCharacterStream(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setCharacterStream(a, b, c); │ │ │ │ │ │ + this.inner.setCharacterStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -486,15 +586,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setCharacterStream(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setCharacterStream(final String a, final Reader b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ this.inner.setCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -506,18 +606,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBlob(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setBlob(final String a, final Blob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBlob(a, b, c); │ │ │ │ │ │ + this.inner.setBlob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -546,18 +646,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBlob(final String a, final Blob b) throws SQLException { │ │ │ │ │ │ + public final void setBlob(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBlob(a, b); │ │ │ │ │ │ + this.inner.setBlob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -566,15 +666,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setClob(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void setClob(final String a, final Clob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ this.inner.setClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -586,18 +686,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setClob(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setClob(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setClob(a, b, c); │ │ │ │ │ │ + this.inner.setClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -606,18 +706,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setClob(final String a, final Clob b) throws SQLException { │ │ │ │ │ │ + public final void setClob(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setClob(a, b); │ │ │ │ │ │ + this.inner.setClob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -666,18 +766,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNCharacterStream(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void setNCharacterStream(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNCharacterStream(a, b); │ │ │ │ │ │ + this.inner.setNCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -686,18 +786,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNCharacterStream(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setNCharacterStream(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNCharacterStream(a, b, c); │ │ │ │ │ │ + this.inner.setNCharacterStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -726,18 +826,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNClob(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final String a, final NClob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNClob(a, b, c); │ │ │ │ │ │ + this.inner.setNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -746,18 +846,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNClob(final String a, final NClob b) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNClob(a, b); │ │ │ │ │ │ + this.inner.setNClob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -906,15 +1006,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final int a, final int b, final String c) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final String a, final int b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -926,18 +1026,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final int a, final int b, final String c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.registerOutParameter(a, b); │ │ │ │ │ │ + this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -966,15 +1066,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final String a, final int b, final int c) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final int a, final int b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -986,18 +1086,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final int a, final int b, final int c) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ + this.inner.registerOutParameter(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1046,18 +1146,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final BigDecimal getBigDecimal(final String a) throws SQLException { │ │ │ │ │ │ + public final BigDecimal getBigDecimal(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getBigDecimal(a); │ │ │ │ │ │ + return this.inner.getBigDecimal(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1066,15 +1166,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final BigDecimal getBigDecimal(final int a) throws SQLException { │ │ │ │ │ │ + public final BigDecimal getBigDecimal(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getBigDecimal(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -1086,18 +1186,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final BigDecimal getBigDecimal(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public final BigDecimal getBigDecimal(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getBigDecimal(a, b); │ │ │ │ │ │ + return this.inner.getBigDecimal(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1126,18 +1226,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final int a) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getDate(a); │ │ │ │ │ │ + return this.inner.getDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1146,15 +1246,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -1166,18 +1266,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getDate(a, b); │ │ │ │ │ │ + return this.inner.getDate(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1186,18 +1286,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getTime(a, b); │ │ │ │ │ │ + return this.inner.getTime(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1206,15 +1306,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final String a) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getTime(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -1226,15 +1326,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getTime(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -1246,18 +1346,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final int a) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getTime(a); │ │ │ │ │ │ + return this.inner.getTime(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1266,18 +1366,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final int a) throws SQLException { │ │ │ │ │ │ + public final Timestamp getTimestamp(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getTimestamp(a); │ │ │ │ │ │ + return this.inner.getTimestamp(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1306,18 +1406,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Timestamp getTimestamp(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getTimestamp(a, b); │ │ │ │ │ │ + return this.inner.getTimestamp(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1466,15 +1566,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final NClob getNClob(final int a) throws SQLException { │ │ │ │ │ │ + public final NClob getNClob(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getNClob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -1486,15 +1586,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final NClob getNClob(final String a) throws SQLException { │ │ │ │ │ │ + public final NClob getNClob(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getNClob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -1586,34 +1686,14 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Reader getNCharacterStream(final int a) throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getNCharacterStream(a); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ - @Override │ │ │ │ │ │ public final Reader getNCharacterStream(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getNCharacterStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ @@ -1626,18 +1706,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Reader getCharacterStream(final int a) throws SQLException { │ │ │ │ │ │ + public final Reader getNCharacterStream(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getCharacterStream(a); │ │ │ │ │ │ + return this.inner.getNCharacterStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1666,58 +1746,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setURL(final String a, final URL b) throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setURL(a, b); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ - @Override │ │ │ │ │ │ - public final Array getArray(final String a) throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getArray(a); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ - @Override │ │ │ │ │ │ - public final Array getArray(final int a) throws SQLException { │ │ │ │ │ │ + public final Reader getCharacterStream(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getArray(a); │ │ │ │ │ │ + return this.inner.getCharacterStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1726,15 +1766,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getString(final String a) throws SQLException { │ │ │ │ │ │ + public final String getString(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getString(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -1746,15 +1786,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getString(final int a) throws SQLException { │ │ │ │ │ │ + public final String getString(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getString(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -1806,18 +1846,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final int a) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final int a, final Map b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(a); │ │ │ │ │ │ + return this.inner.getObject(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1826,18 +1866,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final String a, final Map b) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(a, b); │ │ │ │ │ │ + return this.inner.getObject(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1846,18 +1886,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final int a, final Map b) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final String a, final Class b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(a, b); │ │ │ │ │ │ + return this.inner.getObject(a, (Class)b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1866,18 +1906,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final String a, final Class b) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final String a, final Map b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(a, (Class)b); │ │ │ │ │ │ + return this.inner.getObject(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1906,15 +1946,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final String a) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getObject(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -1926,15 +1966,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean getBoolean(final String a) throws SQLException { │ │ │ │ │ │ + public final boolean getBoolean(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getBoolean(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -1946,15 +1986,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean getBoolean(final int a) throws SQLException { │ │ │ │ │ │ + public final boolean getBoolean(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getBoolean(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -1966,15 +2006,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte getByte(final String a) throws SQLException { │ │ │ │ │ │ + public final byte getByte(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getByte(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -1986,15 +2026,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte getByte(final int a) throws SQLException { │ │ │ │ │ │ + public final byte getByte(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getByte(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -2006,15 +2046,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final short getShort(final String a) throws SQLException { │ │ │ │ │ │ + public final short getShort(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getShort(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -2026,15 +2066,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final short getShort(final int a) throws SQLException { │ │ │ │ │ │ + public final short getShort(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getShort(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -2166,15 +2206,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final double getDouble(final String a) throws SQLException { │ │ │ │ │ │ + public final double getDouble(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getDouble(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -2186,15 +2226,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final double getDouble(final int a) throws SQLException { │ │ │ │ │ │ + public final double getDouble(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getDouble(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -2425,16 +2465,15 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - @Override │ │ │ │ │ │ - public final void setTimestamp(final String a, final Timestamp b, final Calendar c) throws SQLException { │ │ │ │ │ │ + public final void setTimestamp(final int a, final Timestamp b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ this.inner.setTimestamp(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -2445,16 +2484,15 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - @Override │ │ │ │ │ │ - public final void setTimestamp(final String a, final Timestamp b) throws SQLException { │ │ │ │ │ │ + public final void setTimestamp(final int a, final Timestamp b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ this.inner.setTimestamp(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -2465,14 +2503,52 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ + public final void setURL(final int a, final URL b) throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + this.maybeDirtyTransaction(); │ │ │ │ │ │ + this.inner.setURL(a, b); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ + public final void setArray(final int a, final Array b) throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + this.maybeDirtyTransaction(); │ │ │ │ │ │ + this.inner.setArray(a, b); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ public final ResultSetMetaData getMetaData() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getMetaData(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ @@ -2565,18 +2641,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setNull(final int a, final int b, final String c) throws SQLException { │ │ │ │ │ │ + public final void setNull(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNull(a, b, c); │ │ │ │ │ │ + this.inner.setNull(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2584,18 +2660,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setNull(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public final void setNull(final int a, final int b, final String c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNull(a, b); │ │ │ │ │ │ + this.inner.setNull(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2660,18 +2736,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setDate(final int a, final Date b) throws SQLException { │ │ │ │ │ │ + public final void setDate(final int a, final Date b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDate(a, b); │ │ │ │ │ │ + this.inner.setDate(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2679,18 +2755,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setDate(final int a, final Date b, final Calendar c) throws SQLException { │ │ │ │ │ │ + public final void setDate(final int a, final Date b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDate(a, b, c); │ │ │ │ │ │ + this.inner.setDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2736,18 +2812,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setAsciiStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ + this.inner.setAsciiStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2755,18 +2831,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setAsciiStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setAsciiStream(a, b); │ │ │ │ │ │ + this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2774,15 +2850,15 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setAsciiStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -2812,18 +2888,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setBinaryStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBinaryStream(a, b); │ │ │ │ │ │ + this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2831,15 +2907,15 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setBinaryStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -2850,18 +2926,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setBinaryStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ + this.inner.setBinaryStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2907,18 +2983,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setObject(final int a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c); │ │ │ │ │ │ + this.inner.setObject(a, b, c, d); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2926,18 +3002,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setObject(final int a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c, d); │ │ │ │ │ │ + this.inner.setObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2945,18 +3021,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setObject(final int a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c); │ │ │ │ │ │ + this.inner.setObject(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2964,18 +3040,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setObject(final int a, final Object b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3078,18 +3154,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setBlob(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setBlob(final int a, final Blob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBlob(a, b, c); │ │ │ │ │ │ + this.inner.setBlob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3097,18 +3173,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setBlob(final int a, final Blob b) throws SQLException { │ │ │ │ │ │ + public final void setBlob(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBlob(a, b); │ │ │ │ │ │ + this.inner.setBlob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3268,18 +3344,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setNClob(final int a, final NClob b) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNClob(a, b); │ │ │ │ │ │ + this.inner.setNClob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3287,15 +3363,15 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setNClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final int a, final NClob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ this.inner.setNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -3306,18 +3382,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setNClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNClob(a, b, c); │ │ │ │ │ │ + this.inner.setNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3344,52 +3420,14 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setURL(final int a, final URL b) throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setURL(a, b); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ - public final void setArray(final int a, final Array b) throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setArray(a, b); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ public final boolean execute() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.execute(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ @@ -3526,52 +3564,14 @@ │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ - public final void setTimestamp(final int a, final Timestamp b) throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(a, b); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ - public final void setTimestamp(final int a, final Timestamp b, final Calendar c) throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(a, b, c); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ catch (final Exception exc2) { │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ ├── com/mchange/v2/c3p0/impl/NewProxyPreparedStatement.class │ │ │ │ │ ├── procyon -ec {} │ │ │ │ │ │ @@ -4,35 +4,35 @@ │ │ │ │ │ │ import com.mchange.v2.log.MLog; │ │ │ │ │ │ import java.lang.reflect.InvocationTargetException; │ │ │ │ │ │ import java.lang.reflect.Method; │ │ │ │ │ │ import com.mchange.v2.sql.SqlUtils; │ │ │ │ │ │ import com.mchange.v2.log.MLevel; │ │ │ │ │ │ import java.sql.SQLWarning; │ │ │ │ │ │ import java.sql.Connection; │ │ │ │ │ │ -import java.sql.Timestamp; │ │ │ │ │ │ -import java.sql.Array; │ │ │ │ │ │ -import java.net.URL; │ │ │ │ │ │ import java.sql.SQLXML; │ │ │ │ │ │ import java.sql.NClob; │ │ │ │ │ │ import java.sql.RowId; │ │ │ │ │ │ import java.sql.ParameterMetaData; │ │ │ │ │ │ import java.sql.Clob; │ │ │ │ │ │ import java.sql.Blob; │ │ │ │ │ │ import java.sql.Ref; │ │ │ │ │ │ import java.io.Reader; │ │ │ │ │ │ import java.sql.SQLType; │ │ │ │ │ │ import java.io.InputStream; │ │ │ │ │ │ import java.sql.Time; │ │ │ │ │ │ -import java.util.Calendar; │ │ │ │ │ │ import java.sql.Date; │ │ │ │ │ │ import java.math.BigDecimal; │ │ │ │ │ │ import java.sql.Statement; │ │ │ │ │ │ import java.sql.ResultSet; │ │ │ │ │ │ -import java.sql.SQLException; │ │ │ │ │ │ import java.sql.ResultSetMetaData; │ │ │ │ │ │ +import java.sql.Array; │ │ │ │ │ │ +import java.net.URL; │ │ │ │ │ │ +import java.sql.SQLException; │ │ │ │ │ │ +import java.util.Calendar; │ │ │ │ │ │ +import java.sql.Timestamp; │ │ │ │ │ │ import javax.sql.ConnectionEventListener; │ │ │ │ │ │ import com.mchange.v2.log.MLogger; │ │ │ │ │ │ import com.mchange.v2.c3p0.C3P0ProxyStatement; │ │ │ │ │ │ import java.sql.PreparedStatement; │ │ │ │ │ │ │ │ │ │ │ │ public final class NewProxyPreparedStatement implements PreparedStatement, C3P0ProxyStatement │ │ │ │ │ │ { │ │ │ │ │ │ @@ -45,14 +45,94 @@ │ │ │ │ │ │ │ │ │ │ │ │ public NewProxyPreparedStatement(final PreparedStatement inner) { │ │ │ │ │ │ this.cel = (ConnectionEventListener)new NewProxyPreparedStatement.NewProxyPreparedStatement$1(this); │ │ │ │ │ │ this.inner = inner; │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ + public final void setTimestamp(final int a, final Timestamp b, final Calendar c) throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + this.maybeDirtyTransaction(); │ │ │ │ │ │ + this.inner.setTimestamp(a, b, c); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ + @Override │ │ │ │ │ │ + public final void setTimestamp(final int a, final Timestamp b) throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + this.maybeDirtyTransaction(); │ │ │ │ │ │ + this.inner.setTimestamp(a, b); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ + @Override │ │ │ │ │ │ + public final void setURL(final int a, final URL b) throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + this.maybeDirtyTransaction(); │ │ │ │ │ │ + this.inner.setURL(a, b); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ + @Override │ │ │ │ │ │ + public final void setArray(final int a, final Array b) throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + this.maybeDirtyTransaction(); │ │ │ │ │ │ + this.inner.setArray(a, b); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ + @Override │ │ │ │ │ │ public final ResultSetMetaData getMetaData() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.getMetaData(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ @@ -150,18 +230,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNull(final int a, final int b, final String c) throws SQLException { │ │ │ │ │ │ + public final void setNull(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNull(a, b, c); │ │ │ │ │ │ + this.inner.setNull(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -170,18 +250,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNull(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public final void setNull(final int a, final int b, final String c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNull(a, b); │ │ │ │ │ │ + this.inner.setNull(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -250,18 +330,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setDate(final int a, final Date b) throws SQLException { │ │ │ │ │ │ + public final void setDate(final int a, final Date b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDate(a, b); │ │ │ │ │ │ + this.inner.setDate(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -270,18 +350,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setDate(final int a, final Date b, final Calendar c) throws SQLException { │ │ │ │ │ │ + public final void setDate(final int a, final Date b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDate(a, b, c); │ │ │ │ │ │ + this.inner.setDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -330,18 +410,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setAsciiStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ + this.inner.setAsciiStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -350,18 +430,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setAsciiStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setAsciiStream(a, b); │ │ │ │ │ │ + this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -370,15 +450,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setAsciiStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -410,18 +490,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBinaryStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBinaryStream(a, b); │ │ │ │ │ │ + this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -430,15 +510,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBinaryStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -450,18 +530,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBinaryStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ + this.inner.setBinaryStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -510,18 +590,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final int a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c); │ │ │ │ │ │ + this.inner.setObject(a, b, c, d); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -530,18 +610,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final int a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c, d); │ │ │ │ │ │ + this.inner.setObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -550,18 +630,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final int a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c); │ │ │ │ │ │ + this.inner.setObject(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -570,18 +650,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final int a, final Object b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -690,18 +770,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBlob(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setBlob(final int a, final Blob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBlob(a, b, c); │ │ │ │ │ │ + this.inner.setBlob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -710,18 +790,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBlob(final int a, final Blob b) throws SQLException { │ │ │ │ │ │ + public final void setBlob(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBlob(a, b); │ │ │ │ │ │ + this.inner.setBlob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -890,18 +970,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNClob(final int a, final NClob b) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNClob(a, b); │ │ │ │ │ │ + this.inner.setNClob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -910,15 +990,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final int a, final NClob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ this.inner.setNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ @@ -930,18 +1010,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNClob(a, b, c); │ │ │ │ │ │ + this.inner.setNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -970,54 +1050,14 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setURL(final int a, final URL b) throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setURL(a, b); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ - @Override │ │ │ │ │ │ - public final void setArray(final int a, final Array b) throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setArray(a, b); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ - @Override │ │ │ │ │ │ public final boolean execute() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ return this.inner.execute(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ @@ -1161,54 +1201,14 @@ │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ - @Override │ │ │ │ │ │ - public final void setTimestamp(final int a, final Timestamp b) throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(a, b); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ - @Override │ │ │ │ │ │ - public final void setTimestamp(final int a, final Timestamp b, final Calendar c) throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(a, b, c); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ catch (final Exception exc2) { │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ ├── com/mchange/v2/c3p0/impl/NewProxyResultSet.class │ │ │ │ │ ├── procyon -ec {} │ │ │ │ │ │ @@ -3,17 +3,17 @@ │ │ │ │ │ │ │ │ │ │ │ │ import com.mchange.v2.log.MLog; │ │ │ │ │ │ import java.sql.Connection; │ │ │ │ │ │ import java.util.Map; │ │ │ │ │ │ import java.net.URL; │ │ │ │ │ │ import java.util.Calendar; │ │ │ │ │ │ import java.sql.SQLWarning; │ │ │ │ │ │ +import java.sql.ResultSetMetaData; │ │ │ │ │ │ import java.sql.DatabaseMetaData; │ │ │ │ │ │ import java.sql.Statement; │ │ │ │ │ │ -import java.sql.ResultSetMetaData; │ │ │ │ │ │ import java.sql.SQLXML; │ │ │ │ │ │ import java.sql.NClob; │ │ │ │ │ │ import java.sql.RowId; │ │ │ │ │ │ import java.sql.Array; │ │ │ │ │ │ import java.sql.Clob; │ │ │ │ │ │ import java.sql.Blob; │ │ │ │ │ │ import java.sql.Ref; │ │ │ │ │ │ @@ -2373,20 +2373,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean absolute(final int a) throws SQLException { │ │ │ │ │ │ + public final Array getArray(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.absolute(a); │ │ │ │ │ │ + return this.inner.getArray(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2395,20 +2395,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final ResultSetMetaData getMetaData() throws SQLException { │ │ │ │ │ │ + public final Array getArray(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getMetaData(); │ │ │ │ │ │ + return this.inner.getArray(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2417,20 +2417,26 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean isClosed() throws SQLException { │ │ │ │ │ │ + public final Statement getStatement() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.isDetached(); │ │ │ │ │ │ + if (this.creator instanceof Statement) { │ │ │ │ │ │ + return (Statement)this.creatorProxy; │ │ │ │ │ │ + } │ │ │ │ │ │ + if (this.creator instanceof DatabaseMetaData) { │ │ │ │ │ │ + return null; │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new InternalError("Must be Statement or DatabaseMetaData -- Bad Creator: " + this.creator); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2439,26 +2445,42 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Statement getStatement() throws SQLException { │ │ │ │ │ │ + public final ResultSetMetaData getMetaData() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - if (this.creator instanceof Statement) { │ │ │ │ │ │ - return (Statement)this.creatorProxy; │ │ │ │ │ │ + return this.inner.getMetaData(); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ - if (this.creator instanceof DatabaseMetaData) { │ │ │ │ │ │ - return null; │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ - throw new InternalError("Must be Statement or DatabaseMetaData -- Bad Creator: " + this.creator); │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ + @Override │ │ │ │ │ │ + public final boolean isClosed() throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + if (this.proxyConn != null) { │ │ │ │ │ │ + this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ + } │ │ │ │ │ │ + return this.isDetached(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2643,20 +2665,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final BigDecimal getBigDecimal(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public final BigDecimal getBigDecimal(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBigDecimal(a, b); │ │ │ │ │ │ + return this.inner.getBigDecimal(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2665,20 +2687,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final BigDecimal getBigDecimal(final int a) throws SQLException { │ │ │ │ │ │ + public final BigDecimal getBigDecimal(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBigDecimal(a); │ │ │ │ │ │ + return this.inner.getBigDecimal(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2731,15 +2753,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final String a) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getDate(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2753,20 +2775,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getDate(a, b); │ │ │ │ │ │ + return this.inner.getDate(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2775,20 +2797,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final int a) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getDate(a); │ │ │ │ │ │ + return this.inner.getDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2797,15 +2819,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2841,20 +2863,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final int a) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTime(a); │ │ │ │ │ │ + return this.inner.getTime(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2863,15 +2885,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getTime(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2885,20 +2907,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTime(a, b); │ │ │ │ │ │ + return this.inner.getTime(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2951,20 +2973,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Timestamp getTimestamp(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTimestamp(a, b); │ │ │ │ │ │ + return this.inner.getTimestamp(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2973,20 +2995,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final String a) throws SQLException { │ │ │ │ │ │ + public final Timestamp getTimestamp(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTimestamp(a); │ │ │ │ │ │ + return this.inner.getTimestamp(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3083,15 +3105,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final RowId getRowId(final int a) throws SQLException { │ │ │ │ │ │ + public final RowId getRowId(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getRowId(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3105,15 +3127,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final RowId getRowId(final String a) throws SQLException { │ │ │ │ │ │ + public final RowId getRowId(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getRowId(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3215,15 +3237,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getNString(final int a) throws SQLException { │ │ │ │ │ │ + public final String getNString(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getNString(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3237,15 +3259,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getNString(final String a) throws SQLException { │ │ │ │ │ │ + public final String getNString(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getNString(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3259,15 +3281,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Reader getNCharacterStream(final String a) throws SQLException { │ │ │ │ │ │ + public final Reader getNCharacterStream(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getNCharacterStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3281,15 +3303,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Reader getNCharacterStream(final int a) throws SQLException { │ │ │ │ │ │ + public final Reader getNCharacterStream(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getNCharacterStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3347,36 +3369,14 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final InputStream getAsciiStream(final int a) throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - if (this.proxyConn != null) { │ │ │ │ │ │ - this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ - } │ │ │ │ │ │ - return this.inner.getAsciiStream(a); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ - @Override │ │ │ │ │ │ public final InputStream getAsciiStream(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getAsciiStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3391,20 +3391,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final InputStream getBinaryStream(final String a) throws SQLException { │ │ │ │ │ │ + public final InputStream getAsciiStream(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBinaryStream(a); │ │ │ │ │ │ + return this.inner.getAsciiStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3435,20 +3435,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Array getArray(final String a) throws SQLException { │ │ │ │ │ │ + public final InputStream getBinaryStream(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getArray(a); │ │ │ │ │ │ + return this.inner.getBinaryStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3457,20 +3457,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Array getArray(final int a) throws SQLException { │ │ │ │ │ │ + public final boolean absolute(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getArray(a); │ │ │ │ │ │ + return this.inner.absolute(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3479,15 +3479,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getString(final String a) throws SQLException { │ │ │ │ │ │ + public final String getString(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getString(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3501,15 +3501,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getString(final int a) throws SQLException { │ │ │ │ │ │ + public final String getString(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getString(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) {