You've already forked macports-ports
mirror of
https://github.com/encounter/macports-ports.git
synced 2026-03-30 11:29:27 -07:00
Anthony Ramine
a8190267f1
git-svn-id: https://svn.macports.org/repository/macports/trunk/dports@63017 d073be05-634f-4543-b044-5fe20cf6d1d6
3109 lines
95 KiB
Diff
3109 lines
95 KiB
Diff
--- src/com/mysql/jdbc/CallableStatement.java.orig 2009-11-28 20:29:56.000000000 +0100
|
|
+++ src/com/mysql/jdbc/CallableStatement.java 2009-11-28 23:57:51.000000000 +0100
|
|
@@ -32,10 +32,13 @@
|
|
import java.sql.Blob;
|
|
import java.sql.Clob;
|
|
import java.sql.Date;
|
|
+import java.sql.NClob;
|
|
import java.sql.ParameterMetaData;
|
|
import java.sql.Ref;
|
|
import java.sql.ResultSet;
|
|
+import java.sql.RowId;
|
|
import java.sql.SQLException;
|
|
+import java.sql.SQLXML;
|
|
import java.sql.Statement;
|
|
import java.sql.Time;
|
|
import java.sql.Timestamp;
|
|
@@ -2441,5 +2444,86 @@
|
|
return (super.checkReadOnlySafeStatement() || this.checkReadOnlyProcedure());
|
|
}
|
|
|
|
+ public void setNClob(String parameterName, Reader reader)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public Reader getCharacterStream(String parameterName) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public Reader getCharacterStream(int parameterIndex) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public String getNString(String parameterName) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public String getNString(int parameterIndex) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public Reader getNCharacterStream(String parameterName)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public Reader getNCharacterStream(int parameterIndex) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public SQLXML getSQLXML(String parameterName) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public SQLXML getSQLXML(int parameterIndex) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public void setSQLXML(String parameterName, SQLXML xmlObject)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public NClob getNClob(String parameterName) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public NClob getNClob(int parameterIndex) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public void setNClob(String parameterName, Reader reader, long length)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public void setNClob(String parameterName, NClob value)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public void setNString(String parameterName, String value)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public void setRowId(String parameterName, RowId x)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public RowId getRowId(String parameterName)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public RowId getRowId(int parameterIndex)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
|
|
}
|
|
--- src/com/mysql/jdbc/ConnectionImpl.java.orig 2009-11-28 18:58:49.000000000 +0100
|
|
+++ src/com/mysql/jdbc/ConnectionImpl.java 2009-11-29 00:56:52.000000000 +0100
|
|
@@ -34,11 +34,16 @@
|
|
import java.nio.charset.Charset;
|
|
import java.nio.charset.CharsetEncoder;
|
|
import java.sql.Blob;
|
|
+import java.sql.Clob;
|
|
import java.sql.DatabaseMetaData;
|
|
+import java.sql.NClob;
|
|
import java.sql.ResultSet;
|
|
+import java.sql.SQLClientInfoException;
|
|
import java.sql.SQLException;
|
|
import java.sql.SQLWarning;
|
|
+import java.sql.SQLXML;
|
|
import java.sql.Savepoint;
|
|
+import java.sql.Struct;
|
|
import java.util.ArrayList;
|
|
import java.util.Calendar;
|
|
import java.util.GregorianCalendar;
|
|
@@ -5699,4 +5704,60 @@
|
|
public boolean getRequiresEscapingEncoder() {
|
|
return requiresEscapingEncoder;
|
|
}
|
|
+
|
|
+ public Struct createStruct(String typeName, Object[] attributes)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public java.sql.Array createArrayOf(String typeName, Object[] elements)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public Properties getClientInfo() throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public String getClientInfo(String name) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public void setClientInfo(Properties properties)
|
|
+ throws SQLClientInfoException {
|
|
+ throw new SQLClientInfoException();
|
|
+ }
|
|
+
|
|
+ public void setClientInfo(String name, String value)
|
|
+ throws SQLClientInfoException {
|
|
+ throw new SQLClientInfoException();
|
|
+ }
|
|
+
|
|
+ public boolean isValid(int timeout) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public SQLXML createSQLXML() throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public NClob createNClob() throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public Blob createBlob() throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public Clob createClob() throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public <T> T unwrap(Class<T> iface) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
}
|
|
--- src/com/mysql/jdbc/DatabaseMetaData.java.orig 2009-11-28 18:58:49.000000000 +0100
|
|
+++ src/com/mysql/jdbc/DatabaseMetaData.java 2009-11-28 23:31:07.000000000 +0100
|
|
@@ -27,6 +27,7 @@
|
|
import java.io.UnsupportedEncodingException;
|
|
import java.lang.reflect.Constructor;
|
|
import java.sql.ResultSet;
|
|
+import java.sql.RowIdLifetime;
|
|
import java.sql.SQLException;
|
|
import java.sql.Statement;
|
|
import java.sql.Types;
|
|
@@ -8158,4 +8159,29 @@
|
|
|
|
return pStmt;
|
|
}
|
|
+
|
|
+ public ResultSet getFunctions(String catalog, String schemaPattern,
|
|
+ String functionNamePattern) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public ResultSet getClientInfoProperties() throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public RowIdLifetime getRowIdLifetime() throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public <T> T unwrap(Class<T> iface) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
}
|
|
--- src/com/mysql/jdbc/jdbc2/optional/CallableStatementWrapper.java.orig 2009-11-28 22:41:30.000000000 +0100
|
|
+++ src/com/mysql/jdbc/jdbc2/optional/CallableStatementWrapper.java 2009-11-29 01:26:01.000000000 +0100
|
|
@@ -34,8 +34,11 @@
|
|
import java.sql.CallableStatement;
|
|
import java.sql.Clob;
|
|
import java.sql.Date;
|
|
+import java.sql.NClob;
|
|
import java.sql.Ref;
|
|
+import java.sql.RowId;
|
|
import java.sql.SQLException;
|
|
+import java.sql.SQLXML;
|
|
import java.sql.Time;
|
|
import java.sql.Timestamp;
|
|
import java.util.Calendar;
|
|
@@ -1800,817 +1803,817 @@
|
|
|
|
return null;
|
|
}
|
|
-//
|
|
-// public Reader getCharacterStream(int parameterIndex) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((CallableStatement) this.wrappedStmt)
|
|
-// .getCharacterStream(parameterIndex);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return null;
|
|
-// }
|
|
-//
|
|
-// public Reader getCharacterStream(String parameterName) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((CallableStatement) this.wrappedStmt)
|
|
-// .getCharacterStream(parameterName);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return null;
|
|
-// }
|
|
-//
|
|
-// public Reader getNCharacterStream(int parameterIndex) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((CallableStatement) this.wrappedStmt)
|
|
-// .getCharacterStream(parameterIndex);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return null;
|
|
-// }
|
|
-//
|
|
-// public Reader getNCharacterStream(String parameterName) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((CallableStatement) this.wrappedStmt)
|
|
-// .getNCharacterStream(parameterName);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return null;
|
|
-// }
|
|
-//
|
|
-// public NClob getNClob(int parameterIndex) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((CallableStatement) this.wrappedStmt)
|
|
-// .getNClob(parameterIndex);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return null;
|
|
-// }
|
|
-//
|
|
-// public NClob getNClob(String parameterName) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((CallableStatement) this.wrappedStmt)
|
|
-// .getNClob(parameterName);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return null;
|
|
-// }
|
|
-//
|
|
-// public String getNString(int parameterIndex) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((CallableStatement) this.wrappedStmt)
|
|
-// .getNString(parameterIndex);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return null;
|
|
-// }
|
|
-//
|
|
-// public String getNString(String parameterName) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((CallableStatement) this.wrappedStmt)
|
|
-// .getNString(parameterName);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return null;
|
|
-// }
|
|
-//
|
|
-// public RowId getRowId(int parameterIndex) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((CallableStatement) this.wrappedStmt)
|
|
-// .getRowId(parameterIndex);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return null;
|
|
-// }
|
|
-//
|
|
-// public RowId getRowId(String parameterName) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((CallableStatement) this.wrappedStmt)
|
|
-// .getRowId(parameterName);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return null;
|
|
-// }
|
|
-//
|
|
-// public SQLXML getSQLXML(int parameterIndex) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((CallableStatement) this.wrappedStmt)
|
|
-// .getSQLXML(parameterIndex);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return null;
|
|
-// }
|
|
-//
|
|
-// public SQLXML getSQLXML(String parameterName) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((CallableStatement) this.wrappedStmt)
|
|
-// .getSQLXML(parameterName);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return null;
|
|
-// }
|
|
-//
|
|
-// public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setAsciiStream(parameterName, x) ;
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setAsciiStream(parameterName, x, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setBinaryStream(parameterName, x);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setBinaryStream(parameterName, x, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setBlob(String parameterName, Blob x) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setBlob(parameterName, x);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setBlob(parameterName, inputStream);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setBlob(parameterName, inputStream, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setCharacterStream(parameterName, reader);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setCharacterStream(parameterName, reader, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setClob(String parameterName, Clob x) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setClob(parameterName, x);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setClob(String parameterName, Reader reader) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setClob(parameterName, reader);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setClob(String parameterName, Reader reader, long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setClob(parameterName, reader, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setNCharacterStream(parameterName, value);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setNCharacterStream(parameterName, value, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNClob(String parameterName, NClob value) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setNClob(parameterName, value);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNClob(String parameterName, Reader reader) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setNClob(parameterName, reader);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setNClob(parameterName, reader, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNString(String parameterName, String value) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setNString(parameterName, value);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setRowId(String parameterName, RowId x) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setRowId(parameterName, x);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setSQLXML(parameterName, xmlObject);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setAsciiStream(parameterIndex, x);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setAsciiStream(parameterIndex, x, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setBinaryStream(parameterIndex, x) ;
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setBinaryStream(parameterIndex, x, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setBlob(parameterIndex, inputStream);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setBlob(parameterIndex, inputStream, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setCharacterStream(parameterIndex, reader);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .getCharacterStream(parameterIndex);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setClob(int parameterIndex, Reader reader) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setClob(parameterIndex, reader);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setClob(parameterIndex, reader, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setNCharacterStream(parameterIndex, value);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// }
|
|
-//
|
|
-// public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setNCharacterStream(parameterIndex, value, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNClob(int parameterIndex, NClob value) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setNClob(parameterIndex, value);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNClob(int parameterIndex, Reader reader) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setNClob(parameterIndex, reader);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setNClob(parameterIndex, reader, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNString(int parameterIndex, String value) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setNString(parameterIndex, value);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setRowId(int parameterIndex, RowId x) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setRowId(parameterIndex, x);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((CallableStatement) this.wrappedStmt)
|
|
-// .setSQLXML(parameterIndex, xmlObject);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// }
|
|
-//
|
|
-// public boolean isClosed() throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((CallableStatement) this.wrappedStmt)
|
|
-// .isClosed();
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return true;
|
|
-// }
|
|
-//
|
|
-// public boolean isPoolable() throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((CallableStatement) this.wrappedStmt)
|
|
-// . isPoolable();
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return false;
|
|
-// }
|
|
-//
|
|
+
|
|
+ public Reader getCharacterStream(int parameterIndex) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((CallableStatement) this.wrappedStmt)
|
|
+ .getCharacterStream(parameterIndex);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return null;
|
|
+ }
|
|
+
|
|
+ public Reader getCharacterStream(String parameterName) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((CallableStatement) this.wrappedStmt)
|
|
+ .getCharacterStream(parameterName);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return null;
|
|
+ }
|
|
+
|
|
+ public Reader getNCharacterStream(int parameterIndex) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((CallableStatement) this.wrappedStmt)
|
|
+ .getCharacterStream(parameterIndex);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return null;
|
|
+ }
|
|
+
|
|
+ public Reader getNCharacterStream(String parameterName) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((CallableStatement) this.wrappedStmt)
|
|
+ .getNCharacterStream(parameterName);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return null;
|
|
+ }
|
|
+
|
|
+ public NClob getNClob(int parameterIndex) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((CallableStatement) this.wrappedStmt)
|
|
+ .getNClob(parameterIndex);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return null;
|
|
+ }
|
|
+
|
|
+ public NClob getNClob(String parameterName) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((CallableStatement) this.wrappedStmt)
|
|
+ .getNClob(parameterName);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return null;
|
|
+ }
|
|
+
|
|
+ public String getNString(int parameterIndex) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((CallableStatement) this.wrappedStmt)
|
|
+ .getNString(parameterIndex);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return null;
|
|
+ }
|
|
+
|
|
+ public String getNString(String parameterName) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((CallableStatement) this.wrappedStmt)
|
|
+ .getNString(parameterName);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return null;
|
|
+ }
|
|
+
|
|
+ public RowId getRowId(int parameterIndex) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((CallableStatement) this.wrappedStmt)
|
|
+ .getRowId(parameterIndex);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return null;
|
|
+ }
|
|
+
|
|
+ public RowId getRowId(String parameterName) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((CallableStatement) this.wrappedStmt)
|
|
+ .getRowId(parameterName);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return null;
|
|
+ }
|
|
+
|
|
+ public SQLXML getSQLXML(int parameterIndex) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((CallableStatement) this.wrappedStmt)
|
|
+ .getSQLXML(parameterIndex);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return null;
|
|
+ }
|
|
+
|
|
+ public SQLXML getSQLXML(String parameterName) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((CallableStatement) this.wrappedStmt)
|
|
+ .getSQLXML(parameterName);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return null;
|
|
+ }
|
|
+
|
|
+ public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setAsciiStream(parameterName, x) ;
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setAsciiStream(parameterName, x, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setBinaryStream(parameterName, x);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setBinaryStream(parameterName, x, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setBlob(String parameterName, Blob x) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setBlob(parameterName, x);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setBlob(parameterName, inputStream);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setBlob(parameterName, inputStream, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setCharacterStream(parameterName, reader);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setCharacterStream(parameterName, reader, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setClob(String parameterName, Clob x) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setClob(parameterName, x);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setClob(String parameterName, Reader reader) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setClob(parameterName, reader);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setClob(String parameterName, Reader reader, long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setClob(parameterName, reader, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setNCharacterStream(parameterName, value);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setNCharacterStream(parameterName, value, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNClob(String parameterName, NClob value) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setNClob(parameterName, value);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNClob(String parameterName, Reader reader) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setNClob(parameterName, reader);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setNClob(parameterName, reader, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNString(String parameterName, String value) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setNString(parameterName, value);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setRowId(String parameterName, RowId x) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setRowId(parameterName, x);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setSQLXML(parameterName, xmlObject);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setAsciiStream(parameterIndex, x);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setAsciiStream(parameterIndex, x, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setBinaryStream(parameterIndex, x) ;
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setBinaryStream(parameterIndex, x, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setBlob(parameterIndex, inputStream);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setBlob(parameterIndex, inputStream, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setCharacterStream(parameterIndex, reader);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .getCharacterStream(parameterIndex);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setClob(int parameterIndex, Reader reader) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setClob(parameterIndex, reader);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setClob(parameterIndex, reader, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setNCharacterStream(parameterIndex, value);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ }
|
|
+
|
|
+ public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setNCharacterStream(parameterIndex, value, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNClob(int parameterIndex, NClob value) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setNClob(parameterIndex, value);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNClob(int parameterIndex, Reader reader) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setNClob(parameterIndex, reader);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setNClob(parameterIndex, reader, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNString(int parameterIndex, String value) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setNString(parameterIndex, value);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setRowId(int parameterIndex, RowId x) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setRowId(parameterIndex, x);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((CallableStatement) this.wrappedStmt)
|
|
+ .setSQLXML(parameterIndex, xmlObject);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ }
|
|
+
|
|
+ public boolean isClosed() throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((CallableStatement) this.wrappedStmt)
|
|
+ .isClosed();
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return true;
|
|
+ }
|
|
+
|
|
+ public boolean isPoolable() throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((CallableStatement) this.wrappedStmt)
|
|
+ . isPoolable();
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return false;
|
|
+ }
|
|
+
|
|
// public void setPoolable(boolean poolable) throws SQLException {
|
|
// try {
|
|
// if (this.wrappedStmt != null) {
|
|
--- src/com/mysql/jdbc/jdbc2/optional/ConnectionWrapper.java.orig 2009-11-28 18:58:49.000000000 +0100
|
|
+++ src/com/mysql/jdbc/jdbc2/optional/ConnectionWrapper.java 2009-11-29 01:26:55.000000000 +0100
|
|
@@ -25,9 +25,16 @@
|
|
package com.mysql.jdbc.jdbc2.optional;
|
|
|
|
import java.lang.reflect.Constructor;
|
|
+import java.sql.Array;
|
|
+import java.sql.Blob;
|
|
+import java.sql.Clob;
|
|
+import java.sql.NClob;
|
|
+import java.sql.SQLClientInfoException;
|
|
import java.sql.SQLException;
|
|
+import java.sql.SQLXML;
|
|
import java.sql.Savepoint;
|
|
import java.sql.Statement;
|
|
+import java.sql.Struct;
|
|
import java.util.Map;
|
|
import java.util.Properties;
|
|
import java.util.TimeZone;
|
|
@@ -2619,4 +2627,58 @@
|
|
public Properties getProperties() {
|
|
return this.mc.getProperties();
|
|
}
|
|
+
|
|
+ public boolean isValid(int timeout) throws SQLException {
|
|
+ return this.isValid(timeout);
|
|
+ }
|
|
+
|
|
+ public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
|
|
+ return this.mc.createArrayOf(typeName, elements);
|
|
+ }
|
|
+
|
|
+ public Blob createBlob() throws SQLException {
|
|
+ return this.mc.createBlob();
|
|
+ }
|
|
+
|
|
+ public Clob createClob() throws SQLException {
|
|
+ return this.mc.createClob();
|
|
+ }
|
|
+
|
|
+ public NClob createNClob() throws SQLException {
|
|
+ return this.mc.createNClob();
|
|
+ }
|
|
+
|
|
+ public SQLXML createSQLXML() throws SQLException {
|
|
+ return this.mc.createSQLXML();
|
|
+ }
|
|
+
|
|
+ public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
|
|
+ return this.mc.createStruct(typeName, attributes);
|
|
+ }
|
|
+
|
|
+ public Properties getClientInfo() throws SQLException {
|
|
+ return this.mc.getClientInfo();
|
|
+ }
|
|
+
|
|
+ public String getClientInfo(String name) throws SQLException {
|
|
+ return this.mc.getClientInfo(name);
|
|
+ }
|
|
+
|
|
+ public void setClientInfo(Properties properties)
|
|
+ throws SQLClientInfoException {
|
|
+ this.mc.setClientInfo(properties);
|
|
+ }
|
|
+
|
|
+ public void setClientInfo(String name, String value)
|
|
+ throws SQLClientInfoException {
|
|
+ this.mc.setClientInfo(name, value);
|
|
+ }
|
|
+
|
|
+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public <T> T unwrap(Class<T> iface) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
}
|
|
\ No newline at end of file
|
|
--- src/com/mysql/jdbc/jdbc2/optional/MysqlDataSource.java.orig 2009-11-28 18:58:49.000000000 +0100
|
|
+++ src/com/mysql/jdbc/jdbc2/optional/MysqlDataSource.java 2009-11-29 01:15:15.000000000 +0100
|
|
@@ -38,6 +38,7 @@
|
|
|
|
import com.mysql.jdbc.ConnectionPropertiesImpl;
|
|
import com.mysql.jdbc.NonRegisteringDriver;
|
|
+import com.mysql.jdbc.SQLError;
|
|
|
|
/**
|
|
* A JNDI DataSource for a Mysql JDBC connection
|
|
@@ -438,12 +439,12 @@
|
|
|
|
return mysqlDriver.connect(jdbcUrlToUse, props);
|
|
}
|
|
-//
|
|
-// public boolean isWrapperFor(Class<?> iface) throws SQLException {
|
|
-// throw SQLError.notImplemented();
|
|
-// }
|
|
-//
|
|
-// public <T> T unwrap(Class<T> iface) throws SQLException {
|
|
-// throw SQLError.notImplemented();
|
|
-// }
|
|
+
|
|
+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public <T> T unwrap(Class<T> iface) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
}
|
|
--- src/com/mysql/jdbc/jdbc2/optional/MysqlPooledConnection.java.orig 2009-11-28 18:58:49.000000000 +0100
|
|
+++ src/com/mysql/jdbc/jdbc2/optional/MysqlPooledConnection.java 2009-11-29 01:20:09.000000000 +0100
|
|
@@ -33,6 +33,7 @@
|
|
import javax.sql.ConnectionEvent;
|
|
import javax.sql.ConnectionEventListener;
|
|
import javax.sql.PooledConnection;
|
|
+import javax.sql.StatementEventListener;
|
|
|
|
import com.mysql.jdbc.ConnectionImpl;
|
|
import com.mysql.jdbc.ExceptionInterceptor;
|
|
@@ -255,4 +256,10 @@
|
|
protected ExceptionInterceptor getExceptionInterceptor() {
|
|
return this.exceptionInterceptor;
|
|
}
|
|
+
|
|
+ public void addStatementEventListener(StatementEventListener listener) {
|
|
+ }
|
|
+
|
|
+ public void removeStatementEventListener(StatementEventListener listener) {
|
|
+ }
|
|
}
|
|
\ No newline at end of file
|
|
--- src/com/mysql/jdbc/jdbc2/optional/PreparedStatementWrapper.java.orig 2009-11-28 21:35:25.000000000 +0100
|
|
+++ src/com/mysql/jdbc/jdbc2/optional/PreparedStatementWrapper.java 2009-11-29 01:24:42.000000000 +0100
|
|
@@ -33,12 +33,15 @@
|
|
import java.sql.Blob;
|
|
import java.sql.Clob;
|
|
import java.sql.Date;
|
|
+import java.sql.NClob;
|
|
import java.sql.ParameterMetaData;
|
|
import java.sql.PreparedStatement;
|
|
import java.sql.Ref;
|
|
import java.sql.ResultSet;
|
|
import java.sql.ResultSetMetaData;
|
|
+import java.sql.RowId;
|
|
import java.sql.SQLException;
|
|
+import java.sql.SQLXML;
|
|
import java.sql.Time;
|
|
import java.sql.Timestamp;
|
|
import java.util.Calendar;
|
|
@@ -885,323 +888,323 @@
|
|
|
|
// that out
|
|
}
|
|
-//
|
|
-// public void setAsciiStream(int parameterIndex, InputStream x)
|
|
-// throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setAsciiStream(
|
|
-// parameterIndex, x);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setAsciiStream(int parameterIndex, InputStream x, long length)
|
|
-// throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setAsciiStream(
|
|
-// parameterIndex, x, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setBinaryStream(int parameterIndex, InputStream x)
|
|
-// throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setBinaryStream(
|
|
-// parameterIndex, x);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setBinaryStream(int parameterIndex, InputStream x, long length)
|
|
-// throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setBinaryStream(
|
|
-// parameterIndex, x, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setBlob(int parameterIndex, InputStream inputStream)
|
|
-// throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setBlob(parameterIndex,
|
|
-// inputStream);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setBlob(int parameterIndex, InputStream inputStream, long length)
|
|
-// throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setBlob(parameterIndex,
|
|
-// inputStream, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setCharacterStream(int parameterIndex, Reader reader)
|
|
-// throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setCharacterStream(
|
|
-// parameterIndex, reader);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setCharacterStream(int parameterIndex, Reader reader,
|
|
-// long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setCharacterStream(
|
|
-// parameterIndex, reader, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setClob(int parameterIndex, Reader reader) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setClob(parameterIndex,
|
|
-// reader);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setClob(int parameterIndex, Reader reader, long length)
|
|
-// throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setClob(parameterIndex,
|
|
-// reader, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNCharacterStream(int parameterIndex, Reader value)
|
|
-// throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setNCharacterStream(
|
|
-// parameterIndex, value);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNCharacterStream(int parameterIndex, Reader value,
|
|
-// long length) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setNCharacterStream(
|
|
-// parameterIndex, value, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNClob(int parameterIndex, NClob value) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
|
|
-// value);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNClob(int parameterIndex, Reader reader) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
|
|
-// reader);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNClob(int parameterIndex, Reader reader, long length)
|
|
-// throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
|
|
-// reader, length);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setNString(int parameterIndex, String value)
|
|
-// throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setNString(
|
|
-// parameterIndex, value);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setRowId(int parameterIndex, RowId x) throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setRowId(parameterIndex,
|
|
-// x);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public void setSQLXML(int parameterIndex, SQLXML xmlObject)
|
|
-// throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// ((PreparedStatement) this.wrappedStmt).setSQLXML(
|
|
-// parameterIndex, xmlObject);
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-// }
|
|
-//
|
|
-// public boolean isClosed() throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((PreparedStatement) this.wrappedStmt).isClosed();
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return true;
|
|
-// }
|
|
-//
|
|
-// public boolean isPoolable() throws SQLException {
|
|
-// try {
|
|
-// if (this.wrappedStmt != null) {
|
|
-// return ((PreparedStatement) this.wrappedStmt).isPoolable();
|
|
-// } else {
|
|
-// throw SQLError.createSQLException(
|
|
-// "No operations allowed after statement closed",
|
|
-// SQLError.SQL_STATE_GENERAL_ERROR);
|
|
-// }
|
|
-// } catch (SQLException sqlEx) {
|
|
-// checkAndFireConnectionError(sqlEx);
|
|
-// }
|
|
-//
|
|
-// return false;
|
|
-// }
|
|
-//
|
|
+
|
|
+ public void setAsciiStream(int parameterIndex, InputStream x)
|
|
+ throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setAsciiStream(
|
|
+ parameterIndex, x);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setAsciiStream(int parameterIndex, InputStream x, long length)
|
|
+ throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setAsciiStream(
|
|
+ parameterIndex, x, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setBinaryStream(int parameterIndex, InputStream x)
|
|
+ throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setBinaryStream(
|
|
+ parameterIndex, x);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setBinaryStream(int parameterIndex, InputStream x, long length)
|
|
+ throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setBinaryStream(
|
|
+ parameterIndex, x, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setBlob(int parameterIndex, InputStream inputStream)
|
|
+ throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setBlob(parameterIndex,
|
|
+ inputStream);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setBlob(int parameterIndex, InputStream inputStream, long length)
|
|
+ throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setBlob(parameterIndex,
|
|
+ inputStream, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setCharacterStream(int parameterIndex, Reader reader)
|
|
+ throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setCharacterStream(
|
|
+ parameterIndex, reader);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setCharacterStream(int parameterIndex, Reader reader,
|
|
+ long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setCharacterStream(
|
|
+ parameterIndex, reader, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setClob(int parameterIndex, Reader reader) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setClob(parameterIndex,
|
|
+ reader);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setClob(int parameterIndex, Reader reader, long length)
|
|
+ throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setClob(parameterIndex,
|
|
+ reader, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNCharacterStream(int parameterIndex, Reader value)
|
|
+ throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setNCharacterStream(
|
|
+ parameterIndex, value);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNCharacterStream(int parameterIndex, Reader value,
|
|
+ long length) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setNCharacterStream(
|
|
+ parameterIndex, value, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNClob(int parameterIndex, NClob value) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
|
|
+ value);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNClob(int parameterIndex, Reader reader) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
|
|
+ reader);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNClob(int parameterIndex, Reader reader, long length)
|
|
+ throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
|
|
+ reader, length);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setNString(int parameterIndex, String value)
|
|
+ throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setNString(
|
|
+ parameterIndex, value);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setRowId(int parameterIndex, RowId x) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setRowId(parameterIndex,
|
|
+ x);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public void setSQLXML(int parameterIndex, SQLXML xmlObject)
|
|
+ throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ ((PreparedStatement) this.wrappedStmt).setSQLXML(
|
|
+ parameterIndex, xmlObject);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public boolean isClosed() throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((PreparedStatement) this.wrappedStmt).isClosed();
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return true;
|
|
+ }
|
|
+
|
|
+ public boolean isPoolable() throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return ((PreparedStatement) this.wrappedStmt).isPoolable();
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return false;
|
|
+ }
|
|
+
|
|
// public void setPoolable(boolean poolable) throws SQLException {
|
|
// try {
|
|
// if (this.wrappedStmt != null) {
|
|
--- src/com/mysql/jdbc/jdbc2/optional/StatementWrapper.java.orig 2009-11-28 18:58:49.000000000 +0100
|
|
+++ src/com/mysql/jdbc/jdbc2/optional/StatementWrapper.java 2009-11-29 01:26:15.000000000 +0100
|
|
@@ -864,4 +864,58 @@
|
|
checkAndFireConnectionError(sqlEx);
|
|
}
|
|
}
|
|
+
|
|
+ public boolean isPoolable() throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return this.wrappedStmt.isPoolable();
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return false;
|
|
+ }
|
|
+
|
|
+ public void setPoolable(boolean poolable) throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ this.wrappedStmt.setPoolable(poolable);
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public boolean isClosed() throws SQLException {
|
|
+ try {
|
|
+ if (this.wrappedStmt != null) {
|
|
+ return this.wrappedStmt.isClosed();
|
|
+ } else {
|
|
+ throw SQLError.createSQLException(
|
|
+ "No operations allowed after statement closed",
|
|
+ SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
|
|
+ }
|
|
+ } catch (SQLException sqlEx) {
|
|
+ checkAndFireConnectionError(sqlEx);
|
|
+ }
|
|
+
|
|
+ return true;
|
|
+ }
|
|
+
|
|
+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public <T> T unwrap(Class<T> iface) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
}
|
|
--- src/com/mysql/jdbc/PreparedStatement.java.orig 2009-11-28 21:58:03.000000000 +0100
|
|
+++ src/com/mysql/jdbc/PreparedStatement.java 2009-11-28 23:30:09.000000000 +0100
|
|
@@ -44,10 +44,13 @@
|
|
import java.sql.Clob;
|
|
import java.sql.DatabaseMetaData;
|
|
import java.sql.Date;
|
|
+import java.sql.NClob;
|
|
import java.sql.ParameterMetaData;
|
|
import java.sql.Ref;
|
|
import java.sql.ResultSet;
|
|
+import java.sql.RowId;
|
|
import java.sql.SQLException;
|
|
+import java.sql.SQLXML;
|
|
import java.sql.Time;
|
|
import java.sql.Timestamp;
|
|
import java.sql.Types;
|
|
@@ -5595,4 +5598,19 @@
|
|
statementStartPos, sql, "SELECT", "\"'`",
|
|
"\"'`", false) == -1 && rewritableOdku;
|
|
}
|
|
+
|
|
+ public void setSQLXML(int parameterIndex, SQLXML xmlObject)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public void setNClob(int parameterIndex, NClob value)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public void setRowId(int parameterIndex, RowId x)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
}
|
|
--- src/com/mysql/jdbc/ReplicationConnection.java.orig 2009-11-28 18:58:49.000000000 +0100
|
|
+++ src/com/mysql/jdbc/ReplicationConnection.java 2009-11-29 00:59:02.000000000 +0100
|
|
@@ -21,13 +21,20 @@
|
|
*/
|
|
package com.mysql.jdbc;
|
|
|
|
+import java.sql.Array;
|
|
+import java.sql.Blob;
|
|
import java.sql.CallableStatement;
|
|
+import java.sql.Clob;
|
|
import java.sql.DatabaseMetaData;
|
|
+import java.sql.NClob;
|
|
import java.sql.PreparedStatement;
|
|
+import java.sql.SQLClientInfoException;
|
|
import java.sql.SQLException;
|
|
import java.sql.SQLWarning;
|
|
+import java.sql.SQLXML;
|
|
import java.sql.Savepoint;
|
|
import java.sql.Statement;
|
|
+import java.sql.Struct;
|
|
import java.util.Map;
|
|
import java.util.Properties;
|
|
import java.util.TimeZone;
|
|
@@ -2412,4 +2419,60 @@
|
|
boolean queryTimeoutKillsConnection) {
|
|
this.currentConnection.setQueryTimeoutKillsConnection(queryTimeoutKillsConnection);
|
|
}
|
|
+
|
|
+ public boolean isValid(int timeout) throws SQLException {
|
|
+ return this.currentConnection.isValid(timeout);
|
|
+ }
|
|
+
|
|
+ public Properties getClientInfo() throws SQLException {
|
|
+ return this.currentConnection.getClientInfo();
|
|
+ }
|
|
+
|
|
+ public String getClientInfo(String name) throws SQLException {
|
|
+ return this.currentConnection.getClientInfo(name);
|
|
+ }
|
|
+
|
|
+ public void setClientInfo(Properties properties)
|
|
+ throws SQLClientInfoException {
|
|
+ this.currentConnection.setClientInfo(properties);
|
|
+ }
|
|
+
|
|
+ public void setClientInfo(String name, String value)
|
|
+ throws SQLClientInfoException {
|
|
+ this.currentConnection.setClientInfo(name, value);
|
|
+ }
|
|
+
|
|
+ public Array createArrayOf(String typeName, Object[] elements)
|
|
+ throws SQLException {
|
|
+ return this.currentConnection.createArrayOf(typeName, elements);
|
|
+ }
|
|
+
|
|
+ public Blob createBlob() throws SQLException {
|
|
+ return this.currentConnection.createBlob();
|
|
+ }
|
|
+
|
|
+ public Clob createClob() throws SQLException {
|
|
+ return this.currentConnection.createClob();
|
|
+ }
|
|
+
|
|
+ public NClob createNClob() throws SQLException {
|
|
+ return this.currentConnection.createNClob();
|
|
+ }
|
|
+
|
|
+ public SQLXML createSQLXML() throws SQLException {
|
|
+ return this.currentConnection.createSQLXML();
|
|
+ }
|
|
+
|
|
+ public Struct createStruct(String typeName, Object[] attributes)
|
|
+ throws SQLException {
|
|
+ return this.currentConnection.createStruct(typeName, attributes);
|
|
+ }
|
|
+
|
|
+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
|
|
+ return this.currentConnection.isWrapperFor(iface);
|
|
+ }
|
|
+
|
|
+ public <T> T unwrap(Class<T> iface) throws SQLException {
|
|
+ return this.currentConnection.unwrap(iface);
|
|
+ }
|
|
}
|
|
--- src/com/mysql/jdbc/ResultSetImpl.java.orig 2009-11-28 18:58:49.000000000 +0100
|
|
+++ src/com/mysql/jdbc/ResultSetImpl.java 2009-11-29 01:21:22.000000000 +0100
|
|
@@ -25,6 +25,7 @@
|
|
package com.mysql.jdbc;
|
|
|
|
import java.io.ByteArrayInputStream;
|
|
+import java.io.Reader;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.ObjectInputStream;
|
|
@@ -36,10 +37,14 @@
|
|
import java.net.MalformedURLException;
|
|
import java.net.URL;
|
|
import java.sql.Array;
|
|
+import java.sql.Clob;
|
|
import java.sql.Date;
|
|
+import java.sql.NClob;
|
|
import java.sql.Ref;
|
|
+import java.sql.RowId;
|
|
import java.sql.SQLException;
|
|
import java.sql.SQLWarning;
|
|
+import java.sql.SQLXML;
|
|
import java.sql.Time;
|
|
import java.sql.Timestamp;
|
|
import java.sql.Types;
|
|
@@ -8779,4 +8784,244 @@
|
|
protected ExceptionInterceptor getExceptionInterceptor() {
|
|
return this.exceptionInterceptor;
|
|
}
|
|
+
|
|
+ public boolean isClosed() throws SQLException {
|
|
+ return this.isClosed;
|
|
+ }
|
|
+
|
|
+ public int getHoldability() throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public void updateAsciiStream(int columnIndex, InputStream inputStream)
|
|
+ throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateAsciiStream(String columnLabel, InputStream inputStream)
|
|
+ throws SQLException {
|
|
+ updateAsciiStream(findColumn(columnLabel), inputStream);
|
|
+ }
|
|
+
|
|
+ public void updateAsciiStream(int columnIndex, InputStream inputStream,
|
|
+ long length) throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateAsciiStream(String columnLabel, InputStream inputStream,
|
|
+ long length) throws SQLException {
|
|
+ updateAsciiStream(findColumn(columnLabel), inputStream, length);
|
|
+ }
|
|
+
|
|
+ public void updateBinaryStream(int columnIndex, InputStream inputStream)
|
|
+ throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateBinaryStream(String columnLabel,
|
|
+ InputStream inputStream) throws SQLException {
|
|
+ updateBinaryStream(findColumn(columnLabel), inputStream);
|
|
+ }
|
|
+
|
|
+ public void updateBinaryStream(int columnIndex, InputStream inputStream,
|
|
+ long length) throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateBinaryStream(String columnLabel, InputStream inputStream,
|
|
+ long length) throws SQLException {
|
|
+ updateBinaryStream(findColumn(columnLabel), inputStream, length);
|
|
+ }
|
|
+
|
|
+ public void updateBlob(int columnIndex, InputStream inputStream)
|
|
+ throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateBlob(String columnLabel, InputStream inputStream)
|
|
+ throws SQLException {
|
|
+ updateBlob(findColumn(columnLabel), inputStream);
|
|
+ }
|
|
+
|
|
+ public void updateBlob(int columnIndex, InputStream inputStream,
|
|
+ long length) throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateBlob(String columnLabel, InputStream inputStream,
|
|
+ long length) throws SQLException {
|
|
+ updateBlob(findColumn(columnLabel), inputStream, length);
|
|
+ }
|
|
+
|
|
+ public void updateCharacterStream(int columnIndex, Reader reader)
|
|
+ throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateCharacterStream(String columnLabel, Reader reader)
|
|
+ throws SQLException {
|
|
+ updateCharacterStream(findColumn(columnLabel), reader);
|
|
+ }
|
|
+
|
|
+ public void updateCharacterStream(int columnIndex, Reader reader,
|
|
+ long length) throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateCharacterStream(String columnLabel, Reader reader,
|
|
+ long length) throws SQLException {
|
|
+ updateCharacterStream(findColumn(columnLabel), reader, length);
|
|
+ }
|
|
+
|
|
+ public void updateClob(int columnIndex, Reader reader)
|
|
+ throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateClob(String columnLabel, Reader reader)
|
|
+ throws SQLException {
|
|
+ updateClob(findColumn(columnLabel), reader);
|
|
+ }
|
|
+
|
|
+ public void updateClob(int columnIndex, Reader reader, long length)
|
|
+ throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateClob(String columnLabel, Reader reader, long length)
|
|
+ throws SQLException {
|
|
+ updateClob(findColumn(columnLabel), reader, length);
|
|
+ }
|
|
+
|
|
+ public Reader getNCharacterStream(int columnIndex)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public Reader getNCharacterStream(String columnLabel)
|
|
+ throws SQLException {
|
|
+ return getNCharacterStream(findColumn(columnLabel));
|
|
+ }
|
|
+
|
|
+ public void updateNCharacterStream(int columnIndex, Reader reader)
|
|
+ throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateNCharacterStream(String columnLabel, Reader reader)
|
|
+ throws SQLException {
|
|
+ updateNCharacterStream(findColumn(columnLabel), reader);
|
|
+ }
|
|
+
|
|
+ public void updateNCharacterStream(int columnIndex, Reader reader,
|
|
+ long length) throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateNCharacterStream(String columnLabel, Reader reader,
|
|
+ long length) throws SQLException {
|
|
+ updateNCharacterStream(findColumn(columnLabel), reader, length);
|
|
+ }
|
|
+
|
|
+ public NClob getNClob(int columnIndex)
|
|
+ throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public NClob getNClob(String columnLabel)
|
|
+ throws SQLException {
|
|
+ return getNClob(findColumn(columnLabel));
|
|
+ }
|
|
+
|
|
+ public void updateNClob(int columnIndex, NClob value)
|
|
+ throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateNClob(String columnLabel, NClob value)
|
|
+ throws SQLException {
|
|
+ updateNClob(findColumn(columnLabel), value);
|
|
+ }
|
|
+
|
|
+ public void updateNClob(int columnIndex, Reader reader)
|
|
+ throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateNClob(String columnLabel, Reader reader)
|
|
+ throws SQLException {
|
|
+ updateNClob(findColumn(columnLabel), reader);
|
|
+ }
|
|
+
|
|
+ public void updateNClob(int columnIndex, Reader reader, long length)
|
|
+ throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateNClob(String columnLabel, Reader reader, long length)
|
|
+ throws SQLException {
|
|
+ updateNClob(findColumn(columnLabel), reader, length);
|
|
+ }
|
|
+
|
|
+ public String getNString(int columnIndex) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public String getNString(String columnLabel) throws SQLException {
|
|
+ return getNString(findColumn(columnLabel));
|
|
+ }
|
|
+
|
|
+ public void updateNString(int columnIndex, String value)
|
|
+ throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateNString(String columnLabel, String value)
|
|
+ throws SQLException {
|
|
+ updateNString(findColumn(columnLabel), value);
|
|
+ }
|
|
+
|
|
+ public SQLXML getSQLXML(int columnIndex) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public SQLXML getSQLXML(String columnLabel) throws SQLException {
|
|
+ return getSQLXML(findColumn(columnLabel));
|
|
+ }
|
|
+
|
|
+ public void updateSQLXML(int columnIndex, SQLXML xmlObject)
|
|
+ throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateSQLXML(String columnLabel, SQLXML xmlObject)
|
|
+ throws SQLException {
|
|
+ updateSQLXML(findColumn(columnLabel), xmlObject);
|
|
+ }
|
|
+
|
|
+ public RowId getRowId(int columnIndex) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public RowId getRowId(String columnLabel) throws SQLException {
|
|
+ return getRowId(findColumn(columnLabel));
|
|
+ }
|
|
+
|
|
+ public void updateRowId(int columnIndex, RowId x)
|
|
+ throws SQLException {
|
|
+ throw new NotUpdatable();
|
|
+ }
|
|
+
|
|
+ public void updateRowId(String columnLabel, RowId x)
|
|
+ throws SQLException {
|
|
+ updateRowId(findColumn(columnLabel), x);
|
|
+ }
|
|
+
|
|
+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
+
|
|
+ public <T> T unwrap(Class<T> iface) throws SQLException {
|
|
+ throw SQLError.notImplemented();
|
|
+ }
|
|
}
|