openjpa-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From p..@apache.org
Subject svn commit: r417856 [5/22] - in /incubator/openjpa/trunk/openjpa-lib: java/ main/ main/java/ main/java/org/apache/openjpa/lib/ant/ main/java/org/apache/openjpa/lib/conf/ main/java/org/apache/openjpa/lib/jdbc/ main/java/org/apache/openjpa/lib/log/ main/...
Date Wed, 28 Jun 2006 19:34:40 GMT
Modified: incubator/openjpa/trunk/openjpa-lib/main/java/org/apache/openjpa/lib/jdbc/DelegatingCallableStatement.java
URL: http://svn.apache.org/viewvc/incubator/openjpa/trunk/openjpa-lib/main/java/org/apache/openjpa/lib/jdbc/DelegatingCallableStatement.java?rev=417856&r1=415364&r2=417856&view=diff
==============================================================================
--- incubator/openjpa/trunk/openjpa-lib/main/java/org/apache/openjpa/lib/jdbc/DelegatingCallableStatement.java (original)
+++ incubator/openjpa/trunk/openjpa-lib/main/java/org/apache/openjpa/lib/jdbc/DelegatingCallableStatement.java Wed Jun 28 12:34:33 2006
@@ -15,1236 +15,780 @@
  */
 package org.apache.openjpa.lib.jdbc;
 
+import org.apache.openjpa.lib.util.*;
+import org.apache.openjpa.lib.util.Closeable;
 
 import java.io.*;
+
 import java.math.*;
+
 import java.net.*;
+
 import java.sql.*;
-import java.sql.Date;		
-import java.util.*;
+import java.sql.Date;
 
-import org.apache.openjpa.lib.util.Closeable; 
+import java.util.*;
 
 
 /**
- *	<p>{@link CallableStatement} that delegates to an internal statement.</p>
+ *  <p>{@link CallableStatement} that delegates to an internal statement.</p>
  *
- *	@author		Abe White
+ *  @author Abe White
  */
-public class DelegatingCallableStatement 
-	implements CallableStatement, Closeable
-{
-	private final CallableStatement 			_stmnt;
-	private final DelegatingCallableStatement	_del;
-	private final Connection					_conn;
-
-
-	public DelegatingCallableStatement (CallableStatement stmnt, 
-		Connection conn)
-	{
-		_conn = conn;
-		_stmnt = stmnt;
-		if (_stmnt instanceof DelegatingCallableStatement)
-			_del = (DelegatingCallableStatement) _stmnt;
-		else
-			_del = null;
-	}
-
-
-	private ResultSet wrapResult (boolean wrap, ResultSet rs)
-	{
-		if (!wrap)
-			return rs;
-
-		// never wrap null
-		if (rs == null)
-			return null;
-
-		return new DelegatingResultSet (rs, this);
-	}
-
-
-	/**
-	 *	Return the wrapped statement.
-	 */
-	public CallableStatement getDelegate ()
-	{
-		return _stmnt;
-	}
-
-
-	/**
-	 *	Return the base underlying data store statement.
-	 */
-	public CallableStatement getInnermostDelegate ()
-	{
-		return (_del == null) ? _stmnt : _del.getInnermostDelegate ();
-	}
-
-
-	public int hashCode ()
-	{
-		return getInnermostDelegate ().hashCode ();
-	}
-
-
-	public boolean equals (Object other)
-	{
-		if (other == this)
-			return true;
-		if (other instanceof DelegatingCallableStatement)
-			other = ((DelegatingCallableStatement) other).
-				getInnermostDelegate ();
-		return getInnermostDelegate ().equals (other);
-	}
-
-
-	public String toString ()
-	{
-		StringBuffer buf = new StringBuffer ("prepstmnt ").append (hashCode ());
-		appendInfo (buf);
-		return buf.toString ();
-	}
-
-
-	protected void appendInfo (StringBuffer buf)
-	{
-		if (_del != null)
-			_del.appendInfo (buf);
-	}
-
-
-    public ResultSet executeQuery (String str) 
-		throws SQLException
-	{
-		return executeQuery (true);
-	}
-
-
-	/**
- 	 *	Execute the query, with the option of not wrapping it in a
-	 *	{@link DelegatingResultSet}, which is the default.
-	 */
-	protected ResultSet executeQuery (String sql, boolean wrap)
-		throws SQLException
-	{
-		ResultSet rs;
-		if (_del != null)
-			rs = _del.executeQuery (sql, false);
-		else
-			rs = _stmnt.executeQuery (sql);
-
-		return wrapResult (wrap, rs);
-	}
-
-
-    public int executeUpdate (String str) 
-		throws SQLException
-	{
-		return _stmnt.executeUpdate (str);
-	}
-
-
-    public boolean execute (String str) 
-		throws SQLException
-	{
-		return _stmnt.execute (str);
-	}
-
-
-    public void close () 
-		throws SQLException
-	{
-		_stmnt.close ();
-	}
-
-
-    public int getMaxFieldSize () 
-		throws SQLException
-	{
-		return _stmnt.getMaxFieldSize ();
-	}
-
-
-    public void setMaxFieldSize (int i) 
-		throws SQLException
-	{
-		_stmnt.setMaxFieldSize (i);
-	}
-
-
-    public int getMaxRows () 
-		throws SQLException
-	{
-		return _stmnt.getMaxRows ();
-	}
-
-
-    public void setMaxRows (int i) 
-		throws SQLException
-	{
-		_stmnt.setMaxRows (i);
-	}
-
-
-    public void setEscapeProcessing (boolean bool) 
-		throws SQLException
-	{
-		_stmnt.setEscapeProcessing (bool);
-	}
-
-
-    public int getQueryTimeout () 
-		throws SQLException
-	{
-		return _stmnt.getQueryTimeout ();
-	}
-
-
-    public void setQueryTimeout (int i) 
-		throws SQLException
-	{
-		_stmnt.setQueryTimeout (i);
-	}
-
-
-    public void cancel () 
-		throws SQLException
-	{
-		_stmnt.cancel ();
-	}
-
-
-    public SQLWarning getWarnings () 
-		throws SQLException
-	{
-		return _stmnt.getWarnings ();
-	}
-
-
-    public void clearWarnings () 
-		throws SQLException
-	{
-		_stmnt.clearWarnings ();
-	}
-
-
-    public void setCursorName (String str) 
-		throws SQLException
-	{
-		_stmnt.setCursorName (str);
-	}
-
-
-    public ResultSet getResultSet () 
-		throws SQLException
-	{
-		return getResultSet (true);
-	}
-
-
-	/**
- 	 *	Get the last result set, with the option of not wrapping it in a
-	 *	{@link DelegatingResultSet}, which is the default.
-	 */
-	protected ResultSet getResultSet (boolean wrap)
-		throws SQLException
-	{
-		ResultSet rs;
-		if (_del != null)
-			rs = _del.getResultSet (false);
-		else
-			rs = _stmnt.getResultSet ();
-
-		return wrapResult (wrap, rs);
-	}
-
-
-    public int getUpdateCount () 
-		throws SQLException
-	{
-		return _stmnt.getUpdateCount ();
-	}
-
-
-    public boolean getMoreResults () 
-		throws SQLException
-	{
-		return _stmnt.getMoreResults ();
-	}
-
-
-    public void setFetchDirection (int i) 
-		throws SQLException
-	{
-		_stmnt.setFetchDirection (i);
-	}
-
-
-    public int getFetchDirection () 
-		throws SQLException
-	{
-		return _stmnt.getFetchDirection ();
-	}
-
-
-    public void setFetchSize (int i) 
-		throws SQLException
-	{
-		_stmnt.setFetchSize (i);
-	}
-
-
-    public int getFetchSize () 
-		throws SQLException
-	{
-		return _stmnt.getFetchSize ();
-	}
-
-
-    public int getResultSetConcurrency () 
-		throws SQLException
-	{
-		return _stmnt.getResultSetConcurrency ();
-	}
-
-
-    public int getResultSetType () 
-		throws SQLException
-	{
-		return _stmnt.getResultSetType ();
-	}
-
-
-    public void addBatch (String str) 
-		throws SQLException
-	{
-		_stmnt.addBatch (str);
-	}
-
-
-    public void clearBatch () 
-		throws SQLException
-	{
-		_stmnt.clearBatch ();
-	}
-
-
-    public int[] executeBatch ()
-		throws SQLException
-	{
-		return _stmnt.executeBatch ();
-	}
-
-
-    public Connection getConnection () 
-		throws SQLException
-	{
-		return _conn;
-	}
-
-
-	public ResultSet executeQuery () 
-		throws SQLException
-	{
-		return executeQuery (true);
-	}
-
-
-	/**
- 	 *	Execute the query, with the option of not wrapping it in a
-	 *	{@link DelegatingResultSet}, which is the default.
-	 */
-	protected ResultSet executeQuery (boolean wrap)
-		throws SQLException
-	{
-		ResultSet rs;
-		if (_del != null)
-			rs = _del.executeQuery (false);
-		else
-			rs = _stmnt.executeQuery ();
-
-		return wrapResult (wrap, rs);
-	}
-
-
-	public int executeUpdate  () 
-		throws SQLException
-	{
-		return _stmnt.executeUpdate ();
-	}
-
-
-	public void setNull (int i1, int i2) 
-		throws SQLException
-	{
-		_stmnt.setNull (i1, i2);
-	}
-
-
-	public void setBoolean (int i, boolean b) 
-		throws SQLException
-	{
-		_stmnt.setBoolean (i, b);
-	}
-
-
-	public void setByte (int i, byte b) 
-		throws SQLException
-	{
-		_stmnt.setByte (i, b);
-	}
-
-
-	public void setShort (int i, short s) 
-		throws SQLException
-	{
-		_stmnt.setShort (i, s);
-	}
-
-
-	public void setInt (int i1, int i2) 
-		throws SQLException
-	{
-		_stmnt.setInt (i1, i2);
-	}
-
-
-	public void setLong (int i, long l) 
-		throws SQLException
-	{
-		_stmnt.setLong (i, l);
-	}
-
-
-	public void setFloat (int i, float f) 
-		throws SQLException
-	{
-		_stmnt.setFloat (i, f);
-	}
-
-
-	public void setDouble (int i, double d) 
-		throws SQLException
-	{
-		_stmnt.setDouble (i, d);
-	}
-
-
-	public void setBigDecimal (int i, BigDecimal bd) 
-		throws SQLException
-	{
-		_stmnt.setBigDecimal (i, bd);
-	}
-
-
-	public void setString (int i, String s) 
-		throws SQLException
-	{
-		_stmnt.setString (i, s);
-	}
-
-
-	public void setBytes (int i, byte[] b) 
-		throws SQLException
-	{
-		_stmnt.setBytes (i, b);
-	}
-
-
-	public void setDate (int i, Date d) 
-		throws SQLException
-	{
-		_stmnt.setDate (i, d);
-	}
-
-
-	public void setTime (int i, Time t) 
-		throws SQLException
-	{
-		_stmnt.setTime (i, t);
-	}
-
-
-	public void setTimestamp (int i, Timestamp t) 
-		throws SQLException
-	{
-		_stmnt.setTimestamp (i, t);
-	}
-
-
-	public void setAsciiStream (int i1, InputStream is, int i2) 
-		throws SQLException
-	{
-		_stmnt.setAsciiStream (i1, is, i2);
-	}
-
-
-	public void setUnicodeStream (int i1, InputStream is, int i2) 
-		throws SQLException
-	{
-		_stmnt.setUnicodeStream (i1, is, i2);
-	}
-
-
-	public void setBinaryStream (int i1, InputStream is, int i2) 
-		throws SQLException
-	{
-		_stmnt.setBinaryStream (i1, is, i2);
-	}
-
-
-    public void clearParameters () 
-		throws SQLException
-	{
-		_stmnt.clearParameters ();
-	}
-
-
-	public void setObject (int i1, Object o, int i2, int i3) 
-		throws SQLException
-	{
-		_stmnt.setObject (i1, o, i2, i3);
-	}
-
-
-	public void setObject (int i1, Object o, int i2)
-		throws SQLException
-	{
-		_stmnt.setObject (i1, o, i2);
-	}
-
-
-	public void setObject (int i, Object o) 
-		throws SQLException
-	{
-		_stmnt.setObject (i, o);
-	}
-
-
-    public boolean execute () 
-		throws SQLException
-	{
-		return _stmnt.execute ();
-	}
-
-
-    public void addBatch () 
-		throws SQLException
-	{
-		_stmnt.addBatch ();
-	}
-
-
-	public void setCharacterStream (int i1, Reader r, int i2)
-		throws SQLException
-	{
-		_stmnt.setCharacterStream (i1, r, i2);
-	}
-
-
-	public void setRef (int i, Ref r) 
-		throws SQLException
-	{
-		_stmnt.setRef (i, r);
-	}
-
-
-	public void setBlob (int i, Blob b) 
-		throws SQLException
-	{
-		_stmnt.setBlob (i, b);
-	}
-
-
-	public void setClob (int i, Clob c) 
-		throws SQLException
-	{
-		_stmnt.setClob (i, c);
-	}
-
-
-	public void setArray (int i, Array a) 
-		throws SQLException
-	{
-		_stmnt.setArray (i, a);
-	}
-
-
-    public ResultSetMetaData getMetaData () 
-		throws SQLException
-	{
-		return _stmnt.getMetaData ();
-	}
-
-
-	public void setDate (int i, Date d, Calendar c) 
-		throws SQLException
-	{
-		_stmnt.setDate (i, d, c);
-	}
-
-
-	public void setTime (int i, Time t, Calendar c) 
-		throws SQLException
-	{
-		_stmnt.setTime (i, t, c);
-	}
-
-
-	public void setTimestamp (int i, Timestamp t, Calendar c) 
-		throws SQLException
-	{
-		_stmnt.setTimestamp (i, t, c);
-	}
-
-
-	public void setNull (int i1, int i2, String s) 
-		throws SQLException
-	{
-		_stmnt.setNull (i1, i2, s);
-	}
-
-
-	// JDBC 3.0 (unsupported) methods follow; these are required to be able 
-	// to compile against JDK 1.4
-
-
-	public boolean getMoreResults (int i)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public ResultSet getGeneratedKeys ()
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public int executeUpdate (String s, int i) 
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public int executeUpdate (String s, int[] ia)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public int executeUpdate (String s, String[] sa)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public boolean execute (String s, int i)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public boolean execute (String s, int[] ia)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public boolean execute (String s, String[] sa)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public int getResultSetHoldability ()
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setURL (int i, URL url)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public ParameterMetaData getParameterMetaData ()
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	/////////////////////////////
-	// CallableStatement methods
-	/////////////////////////////
-
-
-	public void registerOutParameter (int i1, int i2)
-		throws SQLException
-	{
-		_stmnt.registerOutParameter (i1, i2);
-	}
-
-
-	public void registerOutParameter (int i1, int i2, int i3)
-		throws SQLException
-	{
-		_stmnt.registerOutParameter (i1, i2, i3);
-	}
-
-
-	public boolean wasNull ()
-		throws SQLException
-	{
-		return _stmnt.wasNull ();
-	}
-
-
-	public String getString (int i)
-		throws SQLException
-	{
-		return _stmnt.getString (i);
-	}
-
-
-	public boolean getBoolean (int i)
-		throws SQLException
-	{
-		return _stmnt.getBoolean (i);
-	}
-
-
-	public byte getByte (int i)
-		throws SQLException
-	{
-		return _stmnt.getByte (i);
-	}
-
-
-	public short getShort (int i)
-		throws SQLException
-	{
-		return _stmnt.getShort (i);
-	}
-
-
-	public int getInt (int i)
-		throws SQLException
-	{
-		return _stmnt.getInt (i);
-	}
-
-
-	public long getLong (int i)
-		throws SQLException
-	{
-		return _stmnt.getLong (i);
-	}
-
-
-	public float getFloat (int i)
-		throws SQLException
-	{
-		return _stmnt.getFloat (i);
-	}
-
-
-	public double getDouble (int i)
-		throws SQLException
-	{
-		return _stmnt.getDouble (i);
-	}
-
-
-	public BigDecimal getBigDecimal (int a, int b)
-		throws SQLException
-	{
-		return _stmnt.getBigDecimal (a, b);
-	}
-
-
-	public byte[] getBytes (int i)
-		throws SQLException
-	{
-		return _stmnt.getBytes (i);
-	}
-
-
-	public Date getDate (int i)
-		throws SQLException
-	{
-		return _stmnt.getDate (i);
-	}
-
-
-	public Time getTime (int i)
-		throws SQLException
-	{
-		return _stmnt.getTime (i);
-	}
-
-
-	public Timestamp getTimestamp (int i)
-		throws SQLException
-	{
-		return _stmnt.getTimestamp (i);
-	}
-
-
-	public Object getObject (int i)
-		throws SQLException
-	{
-		return _stmnt.getObject (i);
-	}
-
-
-	public BigDecimal getBigDecimal (int i)
-		throws SQLException
-	{
-		return _stmnt.getBigDecimal (i);
-	}
-
-
-	public Object getObject (int i, Map m)
-		throws SQLException
-	{
-		return _stmnt.getObject (i, m);
-	}
-
-
-	public Ref getRef (int i)
-		throws SQLException
-	{
-		return _stmnt.getRef (i);
-	}
-
-
-	public Blob getBlob (int i)
-		throws SQLException
-	{
-		return _stmnt.getBlob (i);
-	}
-
-
-	public Clob getClob (int i)
-		throws SQLException
-	{
-		return _stmnt.getClob (i);
-	}
-
-
-	public Array getArray (int i)
-		throws SQLException
-	{
-		return _stmnt.getArray (i);
-	}
-
-
-	public Date getDate (int i, Calendar c)
-		throws SQLException
-	{
-		return _stmnt.getDate (i, c);
-	}
-
-
-	public Time getTime (int i, Calendar c)
-		throws SQLException
-	{
-		return _stmnt.getTime (i, c);
-	}
-
-
-	public Timestamp getTimestamp (int i, Calendar c)
-		throws SQLException
-	{
-		return _stmnt.getTimestamp (i, c);
-	}
-
-
-	public void registerOutParameter (int i1, int i2, String s)
-		throws SQLException
-	{
-		_stmnt.registerOutParameter (i1, i2, s);
-	}
-
-
-	// JDBC 3.0 (unsupported) methods follow; these are required to be able 
-	// to compile against JDK 1.4
-
-
-	public void registerOutParameter (String s, int i)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void registerOutParameter (String s, int i1, int i2)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void registerOutParameter (String s1, int i, String s2)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public URL getURL (int i)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setURL (String a, URL b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public URL getURL (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setNull (String a, int b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setBoolean (String a, boolean b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setByte (String a, byte b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setShort (String a, short b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setInt (String a, int b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setLong (String a, long b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setFloat (String a, float b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setDouble (String a, double b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setBigDecimal (String a, BigDecimal b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setString (String a, String b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setBytes (String a, byte[] b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setDate (String a, Date b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setTime (String a, Time b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setTimestamp (String a, Timestamp b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setAsciiStream (String a, InputStream b, int c)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setBinaryStream (String a, InputStream b, int c)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setObject (String a, Object b, int c, int d)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setObject (String a, Object b, int c)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setObject (String a, Object b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setCharacterStream (String a, Reader b, int c)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setDate (String a, Date b, Calendar c)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setTime (String a, Time b, Calendar c)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setTimestamp (String a, Timestamp b, Calendar c)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public void setNull (String a, int b, String c)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public String getString (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public boolean getBoolean (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public byte getByte (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public short getShort (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public int getInt (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public long getLong (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public float getFloat (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public double getDouble (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public byte[] getBytes (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public Date getDate (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public Time getTime (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public Timestamp getTimestamp (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public Object getObject (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public BigDecimal getBigDecimal (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public Object getObject (String a, Map b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public Ref getRef (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public Blob getBlob (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public Clob getClob (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public Array getArray (String a)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public Date getDate (String a, Calendar b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public Time getTime (String a, Calendar b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
-
-
-	public Timestamp getTimestamp (String a, Calendar b)
-		throws SQLException
-	{
-		throw new UnsupportedOperationException ();
-	}
+public class DelegatingCallableStatement implements CallableStatement,
+    Closeable {
+    private final CallableStatement _stmnt;
+    private final DelegatingCallableStatement _del;
+    private final Connection _conn;
+
+    public DelegatingCallableStatement(CallableStatement stmnt, Connection conn) {
+        _conn = conn;
+        _stmnt = stmnt;
+
+        if (_stmnt instanceof DelegatingCallableStatement) {
+            _del = (DelegatingCallableStatement) _stmnt;
+        } else {
+            _del = null;
+        }
+    }
+
+    private ResultSet wrapResult(boolean wrap, ResultSet rs) {
+        if (!wrap) {
+            return rs;
+        }
+
+        // never wrap null
+        if (rs == null) {
+            return null;
+        }
+
+        return new DelegatingResultSet(rs, this);
+    }
+
+    /**
+     *  Return the wrapped statement.
+     */
+    public CallableStatement getDelegate() {
+        return _stmnt;
+    }
+
+    /**
+     *  Return the base underlying data store statement.
+     */
+    public CallableStatement getInnermostDelegate() {
+        return (_del == null) ? _stmnt : _del.getInnermostDelegate();
+    }
+
+    public int hashCode() {
+        return getInnermostDelegate().hashCode();
+    }
+
+    public boolean equals(Object other) {
+        if (other == this) {
+            return true;
+        }
+
+        if (other instanceof DelegatingCallableStatement) {
+            other = ((DelegatingCallableStatement) other).getInnermostDelegate();
+        }
+
+        return getInnermostDelegate().equals(other);
+    }
+
+    public String toString() {
+        StringBuffer buf = new StringBuffer("prepstmnt ").append(hashCode());
+        appendInfo(buf);
+
+        return buf.toString();
+    }
+
+    protected void appendInfo(StringBuffer buf) {
+        if (_del != null) {
+            _del.appendInfo(buf);
+        }
+    }
+
+    public ResultSet executeQuery(String str) throws SQLException {
+        return executeQuery(true);
+    }
+
+    /**
+      *  Execute the query, with the option of not wrapping it in a
+     *  {@link DelegatingResultSet}, which is the default.
+     */
+    protected ResultSet executeQuery(String sql, boolean wrap)
+        throws SQLException {
+        ResultSet rs;
+
+        if (_del != null) {
+            rs = _del.executeQuery(sql, false);
+        } else {
+            rs = _stmnt.executeQuery(sql);
+        }
+
+        return wrapResult(wrap, rs);
+    }
+
+    public int executeUpdate(String str) throws SQLException {
+        return _stmnt.executeUpdate(str);
+    }
+
+    public boolean execute(String str) throws SQLException {
+        return _stmnt.execute(str);
+    }
+
+    public void close() throws SQLException {
+        _stmnt.close();
+    }
+
+    public int getMaxFieldSize() throws SQLException {
+        return _stmnt.getMaxFieldSize();
+    }
+
+    public void setMaxFieldSize(int i) throws SQLException {
+        _stmnt.setMaxFieldSize(i);
+    }
+
+    public int getMaxRows() throws SQLException {
+        return _stmnt.getMaxRows();
+    }
+
+    public void setMaxRows(int i) throws SQLException {
+        _stmnt.setMaxRows(i);
+    }
+
+    public void setEscapeProcessing(boolean bool) throws SQLException {
+        _stmnt.setEscapeProcessing(bool);
+    }
+
+    public int getQueryTimeout() throws SQLException {
+        return _stmnt.getQueryTimeout();
+    }
+
+    public void setQueryTimeout(int i) throws SQLException {
+        _stmnt.setQueryTimeout(i);
+    }
+
+    public void cancel() throws SQLException {
+        _stmnt.cancel();
+    }
+
+    public SQLWarning getWarnings() throws SQLException {
+        return _stmnt.getWarnings();
+    }
+
+    public void clearWarnings() throws SQLException {
+        _stmnt.clearWarnings();
+    }
+
+    public void setCursorName(String str) throws SQLException {
+        _stmnt.setCursorName(str);
+    }
+
+    public ResultSet getResultSet() throws SQLException {
+        return getResultSet(true);
+    }
+
+    /**
+      *  Get the last result set, with the option of not wrapping it in a
+     *  {@link DelegatingResultSet}, which is the default.
+     */
+    protected ResultSet getResultSet(boolean wrap) throws SQLException {
+        ResultSet rs;
+
+        if (_del != null) {
+            rs = _del.getResultSet(false);
+        } else {
+            rs = _stmnt.getResultSet();
+        }
+
+        return wrapResult(wrap, rs);
+    }
+
+    public int getUpdateCount() throws SQLException {
+        return _stmnt.getUpdateCount();
+    }
+
+    public boolean getMoreResults() throws SQLException {
+        return _stmnt.getMoreResults();
+    }
+
+    public void setFetchDirection(int i) throws SQLException {
+        _stmnt.setFetchDirection(i);
+    }
+
+    public int getFetchDirection() throws SQLException {
+        return _stmnt.getFetchDirection();
+    }
+
+    public void setFetchSize(int i) throws SQLException {
+        _stmnt.setFetchSize(i);
+    }
+
+    public int getFetchSize() throws SQLException {
+        return _stmnt.getFetchSize();
+    }
+
+    public int getResultSetConcurrency() throws SQLException {
+        return _stmnt.getResultSetConcurrency();
+    }
+
+    public int getResultSetType() throws SQLException {
+        return _stmnt.getResultSetType();
+    }
+
+    public void addBatch(String str) throws SQLException {
+        _stmnt.addBatch(str);
+    }
+
+    public void clearBatch() throws SQLException {
+        _stmnt.clearBatch();
+    }
+
+    public int[] executeBatch() throws SQLException {
+        return _stmnt.executeBatch();
+    }
+
+    public Connection getConnection() throws SQLException {
+        return _conn;
+    }
+
+    public ResultSet executeQuery() throws SQLException {
+        return executeQuery(true);
+    }
+
+    /**
+      *  Execute the query, with the option of not wrapping it in a
+     *  {@link DelegatingResultSet}, which is the default.
+     */
+    protected ResultSet executeQuery(boolean wrap) throws SQLException {
+        ResultSet rs;
+
+        if (_del != null) {
+            rs = _del.executeQuery(false);
+        } else {
+            rs = _stmnt.executeQuery();
+        }
+
+        return wrapResult(wrap, rs);
+    }
+
+    public int executeUpdate() throws SQLException {
+        return _stmnt.executeUpdate();
+    }
+
+    public void setNull(int i1, int i2) throws SQLException {
+        _stmnt.setNull(i1, i2);
+    }
+
+    public void setBoolean(int i, boolean b) throws SQLException {
+        _stmnt.setBoolean(i, b);
+    }
+
+    public void setByte(int i, byte b) throws SQLException {
+        _stmnt.setByte(i, b);
+    }
+
+    public void setShort(int i, short s) throws SQLException {
+        _stmnt.setShort(i, s);
+    }
+
+    public void setInt(int i1, int i2) throws SQLException {
+        _stmnt.setInt(i1, i2);
+    }
+
+    public void setLong(int i, long l) throws SQLException {
+        _stmnt.setLong(i, l);
+    }
+
+    public void setFloat(int i, float f) throws SQLException {
+        _stmnt.setFloat(i, f);
+    }
+
+    public void setDouble(int i, double d) throws SQLException {
+        _stmnt.setDouble(i, d);
+    }
+
+    public void setBigDecimal(int i, BigDecimal bd) throws SQLException {
+        _stmnt.setBigDecimal(i, bd);
+    }
+
+    public void setString(int i, String s) throws SQLException {
+        _stmnt.setString(i, s);
+    }
+
+    public void setBytes(int i, byte[] b) throws SQLException {
+        _stmnt.setBytes(i, b);
+    }
+
+    public void setDate(int i, Date d) throws SQLException {
+        _stmnt.setDate(i, d);
+    }
+
+    public void setTime(int i, Time t) throws SQLException {
+        _stmnt.setTime(i, t);
+    }
+
+    public void setTimestamp(int i, Timestamp t) throws SQLException {
+        _stmnt.setTimestamp(i, t);
+    }
+
+    public void setAsciiStream(int i1, InputStream is, int i2)
+        throws SQLException {
+        _stmnt.setAsciiStream(i1, is, i2);
+    }
+
+    public void setUnicodeStream(int i1, InputStream is, int i2)
+        throws SQLException {
+        _stmnt.setUnicodeStream(i1, is, i2);
+    }
+
+    public void setBinaryStream(int i1, InputStream is, int i2)
+        throws SQLException {
+        _stmnt.setBinaryStream(i1, is, i2);
+    }
+
+    public void clearParameters() throws SQLException {
+        _stmnt.clearParameters();
+    }
+
+    public void setObject(int i1, Object o, int i2, int i3)
+        throws SQLException {
+        _stmnt.setObject(i1, o, i2, i3);
+    }
+
+    public void setObject(int i1, Object o, int i2) throws SQLException {
+        _stmnt.setObject(i1, o, i2);
+    }
+
+    public void setObject(int i, Object o) throws SQLException {
+        _stmnt.setObject(i, o);
+    }
+
+    public boolean execute() throws SQLException {
+        return _stmnt.execute();
+    }
+
+    public void addBatch() throws SQLException {
+        _stmnt.addBatch();
+    }
+
+    public void setCharacterStream(int i1, Reader r, int i2)
+        throws SQLException {
+        _stmnt.setCharacterStream(i1, r, i2);
+    }
+
+    public void setRef(int i, Ref r) throws SQLException {
+        _stmnt.setRef(i, r);
+    }
+
+    public void setBlob(int i, Blob b) throws SQLException {
+        _stmnt.setBlob(i, b);
+    }
+
+    public void setClob(int i, Clob c) throws SQLException {
+        _stmnt.setClob(i, c);
+    }
+
+    public void setArray(int i, Array a) throws SQLException {
+        _stmnt.setArray(i, a);
+    }
+
+    public ResultSetMetaData getMetaData() throws SQLException {
+        return _stmnt.getMetaData();
+    }
+
+    public void setDate(int i, Date d, Calendar c) throws SQLException {
+        _stmnt.setDate(i, d, c);
+    }
+
+    public void setTime(int i, Time t, Calendar c) throws SQLException {
+        _stmnt.setTime(i, t, c);
+    }
+
+    public void setTimestamp(int i, Timestamp t, Calendar c)
+        throws SQLException {
+        _stmnt.setTimestamp(i, t, c);
+    }
+
+    public void setNull(int i1, int i2, String s) throws SQLException {
+        _stmnt.setNull(i1, i2, s);
+    }
+
+    // JDBC 3.0 (unsupported) methods follow; these are required to be able 
+    // to compile against JDK 1.4
+    public boolean getMoreResults(int i) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public ResultSet getGeneratedKeys() throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public int executeUpdate(String s, int i) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public int executeUpdate(String s, int[] ia) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public int executeUpdate(String s, String[] sa) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public boolean execute(String s, int i) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public boolean execute(String s, int[] ia) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public boolean execute(String s, String[] sa) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public int getResultSetHoldability() throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setURL(int i, URL url) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public ParameterMetaData getParameterMetaData() throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    /////////////////////////////
+    // CallableStatement methods
+    /////////////////////////////
+    public void registerOutParameter(int i1, int i2) throws SQLException {
+        _stmnt.registerOutParameter(i1, i2);
+    }
+
+    public void registerOutParameter(int i1, int i2, int i3)
+        throws SQLException {
+        _stmnt.registerOutParameter(i1, i2, i3);
+    }
+
+    public boolean wasNull() throws SQLException {
+        return _stmnt.wasNull();
+    }
+
+    public String getString(int i) throws SQLException {
+        return _stmnt.getString(i);
+    }
+
+    public boolean getBoolean(int i) throws SQLException {
+        return _stmnt.getBoolean(i);
+    }
+
+    public byte getByte(int i) throws SQLException {
+        return _stmnt.getByte(i);
+    }
+
+    public short getShort(int i) throws SQLException {
+        return _stmnt.getShort(i);
+    }
+
+    public int getInt(int i) throws SQLException {
+        return _stmnt.getInt(i);
+    }
+
+    public long getLong(int i) throws SQLException {
+        return _stmnt.getLong(i);
+    }
+
+    public float getFloat(int i) throws SQLException {
+        return _stmnt.getFloat(i);
+    }
+
+    public double getDouble(int i) throws SQLException {
+        return _stmnt.getDouble(i);
+    }
+
+    public BigDecimal getBigDecimal(int a, int b) throws SQLException {
+        return _stmnt.getBigDecimal(a, b);
+    }
+
+    public byte[] getBytes(int i) throws SQLException {
+        return _stmnt.getBytes(i);
+    }
+
+    public Date getDate(int i) throws SQLException {
+        return _stmnt.getDate(i);
+    }
+
+    public Time getTime(int i) throws SQLException {
+        return _stmnt.getTime(i);
+    }
+
+    public Timestamp getTimestamp(int i) throws SQLException {
+        return _stmnt.getTimestamp(i);
+    }
+
+    public Object getObject(int i) throws SQLException {
+        return _stmnt.getObject(i);
+    }
+
+    public BigDecimal getBigDecimal(int i) throws SQLException {
+        return _stmnt.getBigDecimal(i);
+    }
+
+    public Object getObject(int i, Map m) throws SQLException {
+        return _stmnt.getObject(i, m);
+    }
+
+    public Ref getRef(int i) throws SQLException {
+        return _stmnt.getRef(i);
+    }
+
+    public Blob getBlob(int i) throws SQLException {
+        return _stmnt.getBlob(i);
+    }
+
+    public Clob getClob(int i) throws SQLException {
+        return _stmnt.getClob(i);
+    }
+
+    public Array getArray(int i) throws SQLException {
+        return _stmnt.getArray(i);
+    }
+
+    public Date getDate(int i, Calendar c) throws SQLException {
+        return _stmnt.getDate(i, c);
+    }
+
+    public Time getTime(int i, Calendar c) throws SQLException {
+        return _stmnt.getTime(i, c);
+    }
+
+    public Timestamp getTimestamp(int i, Calendar c) throws SQLException {
+        return _stmnt.getTimestamp(i, c);
+    }
+
+    public void registerOutParameter(int i1, int i2, String s)
+        throws SQLException {
+        _stmnt.registerOutParameter(i1, i2, s);
+    }
+
+    // JDBC 3.0 (unsupported) methods follow; these are required to be able 
+    // to compile against JDK 1.4
+    public void registerOutParameter(String s, int i) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void registerOutParameter(String s, int i1, int i2)
+        throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void registerOutParameter(String s1, int i, String s2)
+        throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public URL getURL(int i) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setURL(String a, URL b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public URL getURL(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setNull(String a, int b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setBoolean(String a, boolean b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setByte(String a, byte b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setShort(String a, short b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setInt(String a, int b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setLong(String a, long b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setFloat(String a, float b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setDouble(String a, double b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setBigDecimal(String a, BigDecimal b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setString(String a, String b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setBytes(String a, byte[] b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setDate(String a, Date b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setTime(String a, Time b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setTimestamp(String a, Timestamp b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setAsciiStream(String a, InputStream b, int c)
+        throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setBinaryStream(String a, InputStream b, int c)
+        throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setObject(String a, Object b, int c, int d)
+        throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setObject(String a, Object b, int c) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setObject(String a, Object b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setCharacterStream(String a, Reader b, int c)
+        throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setDate(String a, Date b, Calendar c) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setTime(String a, Time b, Calendar c) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setTimestamp(String a, Timestamp b, Calendar c)
+        throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void setNull(String a, int b, String c) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public String getString(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public boolean getBoolean(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public byte getByte(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public short getShort(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public int getInt(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public long getLong(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public float getFloat(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public double getDouble(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public byte[] getBytes(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Date getDate(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Time getTime(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Timestamp getTimestamp(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Object getObject(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public BigDecimal getBigDecimal(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Object getObject(String a, Map b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Ref getRef(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Blob getBlob(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Clob getClob(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Array getArray(String a) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Date getDate(String a, Calendar b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Time getTime(String a, Calendar b) throws SQLException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Timestamp getTimestamp(String a, Calendar b)
+        throws SQLException {
+        throw new UnsupportedOperationException();
+    }
 }

Modified: incubator/openjpa/trunk/openjpa-lib/main/java/org/apache/openjpa/lib/jdbc/DelegatingConnection.java
URL: http://svn.apache.org/viewvc/incubator/openjpa/trunk/openjpa-lib/main/java/org/apache/openjpa/lib/jdbc/DelegatingConnection.java?rev=417856&r1=415364&r2=417856&view=diff
==============================================================================
--- incubator/openjpa/trunk/openjpa-lib/main/java/org/apache/openjpa/lib/jdbc/DelegatingConnection.java (original)
+++ incubator/openjpa/trunk/openjpa-lib/main/java/org/apache/openjpa/lib/jdbc/DelegatingConnection.java Wed Jun 28 12:34:33 2006
@@ -15,11 +15,6 @@
  */
 package org.apache.openjpa.lib.jdbc;
 
-
-import java.lang.reflect.*;
-import java.sql.*;
-import java.util.*;
-
 import org.apache.commons.lang.exception.*;
 
 import org.apache.openjpa.lib.util.*;
@@ -27,725 +22,690 @@
 
 import serp.util.*;
 
+import java.io.*;
+
+import java.lang.reflect.*;
+
+import java.sql.*;
+
+import java.util.*;
+
 
 /**
- *	<p>Wrapper around an existing connection.  Subclasses can override the
- *	methods whose behavior they mean to change.  The <code>equals</code> and 
- *	<code>hashCode</code> methods pass through to the base underlying data 
- *	store connection.</p>
+ *  <p>Wrapper around an existing connection.  Subclasses can override the
+ *  methods whose behavior they mean to change.  The <code>equals</code> and
+ *  <code>hashCode</code> methods pass through to the base underlying data
+ *  store connection.</p>
  *
- *	@author		Abe White
+ *  @author Abe White
  */
-public class DelegatingConnection
-	implements Connection, Closeable
-{
-	// jdbc 3 method keys
-	private static final Object SET_HOLDABILITY         = new Object ();
-	private static final Object GET_HOLDABILITY         = new Object ();
-	private static final Object SET_SAVEPOINT_NONAME    = new Object ();
-	private static final Object SET_SAVEPOINT           = new Object ();
-	private static final Object ROLLBACK_SAVEPOINT      = new Object ();
-	private static final Object RELEASE_SAVEPOINT       = new Object ();
-	private static final Object CREATE_STATEMENT        = new Object ();
-	private static final Object PREPARE_STATEMENT       = new Object ();
-	private static final Object PREPARE_CALL            = new Object ();
-	private static final Object PREPARE_WITH_KEYS       = new Object ();
-	private static final Object PREPARE_WITH_INDEX      = new Object ();
-    private static final Object PREPARE_WITH_NAMES      = new Object ();
-
-	private static final Localizer _loc = Localizer.forPackage
-		(DelegatingConnection.class);
-
-	private static final Map _jdbc3;
-	static
-	{
-		boolean jdbc3 = false;
-		Method m = null;
-		try
-		{
-			m = Connection.class.getMethod ("setSavepoint",
-				new Class[] { String.class });
-			jdbc3 = true;
-		}
-		catch (Throwable t) {}
-
-		if (jdbc3)
-		{
-			_jdbc3 = new HashMap ();
-			_jdbc3.put (SET_SAVEPOINT, m);
-		}
-		else
-			_jdbc3 = null;
-    }
-
-	private final Connection 			_conn;
-	private final DelegatingConnection 	_del;
-
-
-	public DelegatingConnection (Connection conn)
-	{
-		_conn = conn;
-		if (conn instanceof DelegatingConnection)
-			_del = (DelegatingConnection) _conn;
-		else
-			_del = null;
-	}
-
-
-	/**
-	 *	Return the wrapped connection.
-	 */
-	public Connection getDelegate ()
-	{
-		return _conn;
-	}
-
-	
-	/**
-	 *	Return the base underlying data store connection.
-	 */
-	public Connection getInnermostDelegate ()
-	{
-		return (_del == null) ? _conn : _del.getInnermostDelegate ();
-	}
-
-
-	public int hashCode ()
-	{
-		return getInnermostDelegate ().hashCode ();
-	}
-
-
-	public boolean equals (Object other)
-	{
-		if (other == this)
-			return true;
-		if (other instanceof DelegatingConnection)
-			other = ((DelegatingConnection) other).getInnermostDelegate ();
-		return getInnermostDelegate ().equals (other);
-	}
-
-
-	public String toString ()
-	{
-		StringBuffer buf = new StringBuffer ("conn ").append (hashCode ());
-		appendInfo (buf);
-		return buf.toString ();
-	}
-
-
-	protected void appendInfo (StringBuffer buf)
-	{
-		if (_del != null)
-			_del.appendInfo (buf);
-	}
-
-
-	public Statement createStatement () 
-		throws SQLException
-	{
-		return createStatement (true);
-	}
-
-
-	/**
- 	 *	Create a statement, with the option of not wrapping it in a
-	 *	{@link DelegatingStatement}, which is the default.
-	 */
-	protected Statement createStatement (boolean wrap)
-		throws SQLException
-	{
-		Statement stmnt;
-		if (_del != null)
-			stmnt = _del.createStatement (false);
-		else
-			stmnt = _conn.createStatement ();
-		if (wrap)
-			stmnt = new DelegatingStatement (stmnt, this);
-		return stmnt;
-	}
-
-
-	public PreparedStatement prepareStatement (String str) 
-		throws SQLException
-	{
-		return prepareStatement (str, true);
-	}
-
-
-	/**
- 	 *	Prepare a statement, with the option of not wrapping it in a
-	 *	{@link DelegatingPreparedStatement}, which is the default.
-	 */
-	protected PreparedStatement prepareStatement (String str, boolean wrap) 
-		throws SQLException
-	{
-		PreparedStatement stmnt;
-		if (_del != null)
-			stmnt = _del.prepareStatement (str, false);
-		else
-			stmnt = _conn.prepareStatement (str);
-		if (wrap)
-			stmnt = new DelegatingPreparedStatement (stmnt, this);
-		return stmnt;
-	}
-
-
-	public CallableStatement prepareCall (String str) 
-		throws SQLException
-	{
-		return prepareCall (str, true);
-	}
-
-
-	/**
- 	 *	Prepare a call, with the option of not wrapping it in a
-	 *	{@link DelegatingCallableStatement}, which is the default.
-	 */
-	protected CallableStatement prepareCall (String str, boolean wrap) 
-		throws SQLException
-	{
-		CallableStatement stmnt;
-		if (_del != null)
-			stmnt = _del.prepareCall (str, false);
-		else
-			stmnt = _conn.prepareCall (str);
-		if (wrap)
-			stmnt = new DelegatingCallableStatement (stmnt, this);
-		return stmnt;
-	}
-
-
-	public String nativeSQL (String str) 
-		throws SQLException
-	{
-		return _conn.nativeSQL (str);
-	}
-
-
-	public void setAutoCommit (boolean bool) 
-		throws SQLException
-	{
-		_conn.setAutoCommit (bool);
-	}
-
-
-	public boolean getAutoCommit () 
-		throws SQLException
-	{
-		return _conn.getAutoCommit ();
-	}
-
-
-	public void commit () 
-		throws SQLException
-	{
-		_conn.commit ();
-	}
-
-
-	public void rollback () 
-		throws SQLException
-	{
-		_conn.rollback ();
-	}
-
-
-	public void close () 
-		throws SQLException
-	{
-		_conn.close ();
-	}
-
-
-	public boolean isClosed () 
-		throws SQLException
-	{
-		return _conn.isClosed ();
-	}
-
-
-	public DatabaseMetaData getMetaData () 
-		throws SQLException
-	{
-		return getMetaData (true);
-	}
-
-
-	/**
- 	 *	Return the metadata, with the option of not wrapping it in a
-	 *	{@link DelegatingDatabaseMetaData}, which is the default.
-	 */
-	protected DatabaseMetaData getMetaData (boolean wrap)
-		throws SQLException
-	{
-		DatabaseMetaData meta;
-		if (_del != null)
-			meta = _del.getMetaData (false);
-		else
-			meta = _conn.getMetaData ();
-		if (wrap)
-			meta = new DelegatingDatabaseMetaData (meta, this);
-		return meta;
-	}
-
-
-	public void setReadOnly (boolean bool) 
-		throws SQLException
-	{
-		_conn.setReadOnly (bool);
-	}
-
-
-	public boolean isReadOnly () 
-		throws SQLException
-	{
-		return _conn.isReadOnly ();
-	}
-
-
-	public void setCatalog (String str) 
-		throws SQLException
-	{
-		_conn.setCatalog (str);
-	}
-
-
-	public String getCatalog () 
-		throws SQLException
-	{
-		return _conn.getCatalog ();
-	}
-
-
-	public void setTransactionIsolation (int i) 
-		throws SQLException
-	{
-		_conn.setTransactionIsolation (i);
-	}
-
-
-	public int getTransactionIsolation () 
-		throws SQLException
-	{
-		return _conn.getTransactionIsolation ();
-	}
-
-
-	public SQLWarning getWarnings () 
-		throws SQLException
-	{
-		return _conn.getWarnings ();
-	}
-
-
-	public void clearWarnings () 
-		throws SQLException
-	{
-		_conn.clearWarnings ();
-	}
-
-
-	public Statement createStatement (int type, int concur) 
-		throws SQLException
-	{
-		return createStatement (type, concur, true);
-	}
-
-
-	/**
- 	 *	Create a statement, with the option of not wrapping it in a
-	 *	{@link DelegatingStatement}, which is the default.
-	 */
-	protected Statement createStatement (int type, int concur, boolean wrap)
-		throws SQLException
-	{
-		Statement stmnt;
-		if (_del != null)
-			stmnt = _del.createStatement (type, concur, false);
-		else
-			stmnt = _conn.createStatement (type, concur);
-		if (wrap)
-			stmnt = new DelegatingStatement (stmnt, this);
-		return stmnt;
-	}
-
-
-	public PreparedStatement prepareStatement (String str, int type,
-		int concur) 
-		throws SQLException
-	{
-		return prepareStatement (str, type, concur, true);
-	}
-
-
-	/**
- 	 *	Prepare a statement, with the option of not wrapping it in a
-	 *	{@link DelegatingPreparedStatement}, which is the default.
-	 */
-	protected PreparedStatement prepareStatement (String str, int type,
-		int concur, boolean wrap) 
-		throws SQLException
-	{
-		PreparedStatement stmnt;
-		if (_del != null)
-			stmnt = _del.prepareStatement (str, type, concur, false);
-		else
-			stmnt = _conn.prepareStatement (str, type, concur);
-		if (wrap)
-			stmnt = new DelegatingPreparedStatement (stmnt, this);
-		return stmnt;
-	}
-
-
-	public CallableStatement prepareCall (String str, int type, int concur) 
-		throws SQLException
-	{
-		return prepareCall (str, type, concur, true);
-	}
-
-
-	/**
- 	 *	Prepare a call, with the option of not wrapping it in a
-	 *	{@link DelegatingCallableStatement}, which is the default.
-	 */
-	protected CallableStatement prepareCall (String str, int type, int concur, 
-		boolean wrap) 
-		throws SQLException
-	{
-		CallableStatement stmnt;
-		if (_del != null)
-			stmnt = _del.prepareCall (str, type, concur, false);
-		else
-			stmnt = _conn.prepareCall (str, type, concur);
-		if (wrap)
-			stmnt = new DelegatingCallableStatement (stmnt, this);
-		return stmnt;
-	}
-
-
-	public Map getTypeMap () 
-		throws SQLException
-	{
-		return _conn.getTypeMap ();
-	}
-
-
-	public void setTypeMap (Map map) 
-		throws SQLException
-	{
-		_conn.setTypeMap (map);
-	}
-
-
-	// JDBC 3.0 methods follow; these are required to be able to 
-	// compile against JDK 1.4; these methods will not work on
-	// previous JVMs
-
-
-	public void setHoldability (int holdability)
-		throws SQLException
-	{
-		assertJDBC3 ();
-		Method m = (Method) _jdbc3.get (SET_HOLDABILITY);
-		if (m == null)
-			m = createJDBC3Method (SET_HOLDABILITY, "setHoldability",
-				new Class[] {int.class});
-		invokeJDBC3 (m, new Object[] {Numbers.valueOf (holdability)});
-	}
-
-
-	public int getHoldability ()
-		throws SQLException
-	{
-		assertJDBC3 ();
-		Method m = (Method) _jdbc3.get (GET_HOLDABILITY);
-		if (m == null)
-			m = createJDBC3Method (GET_HOLDABILITY, "getHoldability", null);
-		return ((Number) invokeJDBC3 (m, null)).intValue ();
-	}
-
-
-	public Savepoint setSavepoint ()
-		throws SQLException
-	{
-		assertJDBC3 ();
-		Method m = (Method) _jdbc3.get (SET_SAVEPOINT_NONAME);
-		if (m == null)
-			m = createJDBC3Method (SET_SAVEPOINT_NONAME, "setSavepoint", null);
-		return (Savepoint) invokeJDBC3 (m, null);
-	}
-
-
-	public Savepoint setSavepoint (String savepoint)
-		throws SQLException
-	{
-		assertJDBC3 ();
-		Method m = (Method) _jdbc3.get (SET_SAVEPOINT);
-		if (m == null)
-			m = createJDBC3Method (SET_SAVEPOINT, "setSavepoint", 
-				new Class[] {String.class});
-		return (Savepoint) invokeJDBC3 (m, new Object[] {savepoint});
-	}
-
-
-	public void rollback (Savepoint savepoint)
-		throws SQLException
-	{
-		assertJDBC3 ();
-		Method m = (Method) _jdbc3.get (ROLLBACK_SAVEPOINT);
-		if (m == null)
-			m = createJDBC3Method (ROLLBACK_SAVEPOINT, "rollback", 
-				new Class[] {Savepoint.class});
-		invokeJDBC3 (m, new Object[] {savepoint});
-	}
-
-
-	public void releaseSavepoint (Savepoint savepoint)
-		throws SQLException
-	{
-		assertJDBC3 ();
-		Method m = (Method) _jdbc3.get (RELEASE_SAVEPOINT);
-		if (m == null)
-			m = createJDBC3Method (RELEASE_SAVEPOINT, "releaseSavepoint", 
-				new Class[] {Savepoint.class});
-		invokeJDBC3 (m, new Object[] {savepoint});
-	}
-
-
-	public Statement createStatement (int resultSetType,
-		int resultSetConcurrency, int resultSetHoldability)
-		throws SQLException
-	{
-		assertJDBC3 ();
-		return createStatement (resultSetType, resultSetConcurrency, 
-			resultSetHoldability, true);
-	}
-
-
-	protected Statement createStatement (int resultSetType,
-		int resultSetConcurrency, int resultSetHoldability, boolean wrap)
-		throws SQLException
-	{
-		Statement stmnt;
-		if (_del != null)
-			stmnt = _del.createStatement (resultSetType, resultSetConcurrency,
-				resultSetHoldability, false);
-		else
-		{
-			Method m = (Method) _jdbc3.get (CREATE_STATEMENT);
-			if (m == null)
-				m = createJDBC3Method (CREATE_STATEMENT, "createStatement", 
-					new Class[] {int.class, int.class, int.class});
-			stmnt = (Statement) invokeJDBC3 (m, new Object[] {
-				Numbers.valueOf (resultSetType), 
-				Numbers.valueOf (resultSetConcurrency),
-				Numbers.valueOf (resultSetHoldability)});
-		}
-		if (wrap)
-			stmnt = new DelegatingStatement (stmnt, this);
-		return stmnt;
-	}
-
-
-	public PreparedStatement prepareStatement (String sql,
-		int resultSetType, int resultSetConcurrency, int resultSetHoldability)
-		throws SQLException
-	{
-		assertJDBC3 ();
-		return prepareStatement (sql, resultSetType, resultSetConcurrency,
-			resultSetHoldability, true);
-	}
-
-
-	protected PreparedStatement prepareStatement (String sql,
-		int resultSetType, int resultSetConcurrency, int resultSetHoldability,
-		boolean wrap)
-		throws SQLException
-	{
-		PreparedStatement stmnt;
-		if (_del != null)
-			stmnt = _del.prepareStatement (sql, resultSetType, 
-				resultSetConcurrency, resultSetHoldability, false);
-		else
-		{
-			Method m = (Method) _jdbc3.get (PREPARE_STATEMENT);
-			if (m == null)
-				m = createJDBC3Method (PREPARE_STATEMENT, "prepareStatement", 
-					new Class[]{String.class, int.class, int.class, int.class});
-			stmnt = (PreparedStatement) invokeJDBC3 (m, new Object[] { sql,
-				Numbers.valueOf (resultSetType), 
-				Numbers.valueOf (resultSetConcurrency),
-				Numbers.valueOf (resultSetHoldability)});
-		}
-		if (wrap)
-			stmnt = new DelegatingPreparedStatement (stmnt, this);
-		return stmnt;
-	}
-
-
-	public CallableStatement prepareCall (String sql,
-		int resultSetType, int resultSetConcurrency, int resultSetHoldability)
-		throws SQLException
-	{
-		assertJDBC3 ();
-		return prepareCall (sql, resultSetType, resultSetConcurrency,
-			resultSetHoldability, true);
-	}
-
-
-	protected CallableStatement prepareCall (String sql, int resultSetType, 
-		int resultSetConcurrency, int resultSetHoldability, boolean wrap)
-		throws SQLException
-	{
-		CallableStatement stmnt;
-		if (_del != null)
-			stmnt = _del.prepareCall (sql, resultSetType, 
-				resultSetConcurrency, resultSetHoldability, false);
-		else
-		{
-			Method m = (Method) _jdbc3.get (PREPARE_CALL);
-			if (m == null)
-				m = createJDBC3Method (PREPARE_CALL, "prepareCall", 
-					new Class[]{String.class, int.class, int.class, int.class});
-			stmnt = (CallableStatement) invokeJDBC3 (m, new Object[] { sql,
-				Numbers.valueOf (resultSetType), 
-				Numbers.valueOf (resultSetConcurrency),
-				Numbers.valueOf (resultSetHoldability)});
-		}
-		if (wrap)
-			stmnt = new DelegatingCallableStatement (stmnt, this);
-		return stmnt;
-	}
-
-
-	public PreparedStatement prepareStatement (String sql,
-		int autoGeneratedKeys)
-		throws SQLException
-	{
-		assertJDBC3 ();
-		return prepareStatement (sql, autoGeneratedKeys, true);
-	}
-
-
-	protected PreparedStatement prepareStatement (String sql,
-		int autoGeneratedKeys, boolean wrap)
-		throws SQLException
-	{
-		PreparedStatement stmnt;
-		if (_del != null)
-			stmnt = _del.prepareStatement (sql, autoGeneratedKeys); 
-		else
-		{
-			Method m = (Method) _jdbc3.get (PREPARE_WITH_KEYS);
-			if (m == null)
-				m = createJDBC3Method (PREPARE_WITH_KEYS, "prepareStatement", 
-					new Class[] {String.class, int.class});
-			stmnt = (PreparedStatement) invokeJDBC3 (m, new Object[] { sql,
-				Numbers.valueOf (autoGeneratedKeys)});
-		}
-		if (wrap)
-			stmnt = new DelegatingPreparedStatement (stmnt, this);
-		return stmnt;
-	}
-
-
-	public PreparedStatement prepareStatement (String sql, int[] columnIndexes)
-		throws SQLException
-	{
-		assertJDBC3 ();
-		return prepareStatement (sql, columnIndexes, true);
-	}
-
-
-	protected PreparedStatement prepareStatement (String sql, 
-		int[] columnIndexes, boolean wrap)
-		throws SQLException
-	{
-		PreparedStatement stmnt;
-		if (_del != null)
-			stmnt = _del.prepareStatement (sql, columnIndexes, wrap); 
-		else
-		{
-			Method m = (Method) _jdbc3.get (PREPARE_WITH_INDEX);
-			if (m == null)
-				m = createJDBC3Method (PREPARE_WITH_INDEX, "prepareStatement", 
-					new Class[] {String.class, int[].class});
-			stmnt = (PreparedStatement) invokeJDBC3 (m, new Object[] { sql,
-				columnIndexes});
-		}
-		if (wrap)
-			stmnt = new DelegatingPreparedStatement (stmnt, this);
-		return stmnt;
-	}
-
-
-	public PreparedStatement prepareStatement (String sql, String[] columnNames)
-		throws SQLException
-	{
-		assertJDBC3 ();
-		return prepareStatement (sql, columnNames, true);
-	}
-
-
-	protected PreparedStatement prepareStatement (String sql, 
-		String[] columnNames, boolean wrap)
-		throws SQLException
-	{
-		assertJDBC3 ();
-		PreparedStatement stmnt;
-		if (_del != null)
-			stmnt = _del.prepareStatement (sql, columnNames, wrap); 
-		else
-		{
-			Method m = (Method) _jdbc3.get (PREPARE_WITH_NAMES);
-			if (m == null)
-				m = createJDBC3Method (PREPARE_WITH_NAMES, "prepareStatement", 
-					new Class[] {String.class, String[].class});
-			stmnt = (PreparedStatement) invokeJDBC3 (m, new Object[] { sql,
-				columnNames});
-		}
-		if (wrap)
-			stmnt = new DelegatingPreparedStatement (stmnt, this);
-		return stmnt;
-	}
-
-
-	private static void assertJDBC3 ()
-	{
-		if (_jdbc3 == null)
-			throw new UnsupportedOperationException (_loc.get ("not-jdbc3"));
-	}
-
-
-	private Object invokeJDBC3 (Method m, Object[] args)
-		throws SQLException
-	{
-		try
-		{
-			return m.invoke (_conn, args);
-		}
-		catch (Throwable t)
-		{
-			if (t instanceof SQLException)
-				throw (SQLException) t;
-			throw new NestableRuntimeException (_loc.get ("invoke-jdbc3"), t);
-		}
-	}
-
-
-	private static Method createJDBC3Method (Object key, String name, 
-		Class[] args)
-	{
-		try
-		{
-			Method m = Connection.class.getMethod (name, args);
-			_jdbc3.put (key, m);
-			return m;
-		}
-		catch (Throwable t)
-		{
-			throw new NestableRuntimeException (_loc.get ("error-jdbc3"), t);
-		}
-	}
+public class DelegatingConnection implements Connection, Closeable {
+    // jdbc 3 method keys
+    private static final Object SET_HOLDABILITY = new Object();
+    private static final Object GET_HOLDABILITY = new Object();
+    private static final Object SET_SAVEPOINT_NONAME = new Object();
+    private static final Object SET_SAVEPOINT = new Object();
+    private static final Object ROLLBACK_SAVEPOINT = new Object();
+    private static final Object RELEASE_SAVEPOINT = new Object();
+    private static final Object CREATE_STATEMENT = new Object();
+    private static final Object PREPARE_STATEMENT = new Object();
+    private static final Object PREPARE_CALL = new Object();
+    private static final Object PREPARE_WITH_KEYS = new Object();
+    private static final Object PREPARE_WITH_INDEX = new Object();
+    private static final Object PREPARE_WITH_NAMES = new Object();
+    private static final Localizer _loc = Localizer.forPackage(DelegatingConnection.class);
+    private static final Map _jdbc3;
+
+    static {
+        boolean jdbc3 = false;
+        Method m = null;
+
+        try {
+            m = Connection.class.getMethod("setSavepoint",
+                    new Class[] { String.class });
+            jdbc3 = true;
+        } catch (Throwable t) {
+        }
+
+        if (jdbc3) {
+            _jdbc3 = new HashMap();
+            _jdbc3.put(SET_SAVEPOINT, m);
+        } else {
+            _jdbc3 = null;
+        }
+    }
+
+    private final Connection _conn;
+    private final DelegatingConnection _del;
+
+    public DelegatingConnection(Connection conn) {
+        _conn = conn;
+
+        if (conn instanceof DelegatingConnection) {
+            _del = (DelegatingConnection) _conn;
+        } else {
+            _del = null;
+        }
+    }
+
+    /**
+     *  Return the wrapped connection.
+     */
+    public Connection getDelegate() {
+        return _conn;
+    }
+
+    /**
+     *  Return the base underlying data store connection.
+     */
+    public Connection getInnermostDelegate() {
+        return (_del == null) ? _conn : _del.getInnermostDelegate();
+    }
+
+    public int hashCode() {
+        return getInnermostDelegate().hashCode();
+    }
+
+    public boolean equals(Object other) {
+        if (other == this) {
+            return true;
+        }
+
+        if (other instanceof DelegatingConnection) {
+            other = ((DelegatingConnection) other).getInnermostDelegate();
+        }
+
+        return getInnermostDelegate().equals(other);
+    }
+
+    public String toString() {
+        StringBuffer buf = new StringBuffer("conn ").append(hashCode());
+        appendInfo(buf);
+
+        return buf.toString();
+    }
+
+    protected void appendInfo(StringBuffer buf) {
+        if (_del != null) {
+            _del.appendInfo(buf);
+        }
+    }
+
+    public Statement createStatement() throws SQLException {
+        return createStatement(true);
+    }
+
+    /**
+      *  Create a statement, with the option of not wrapping it in a
+     *  {@link DelegatingStatement}, which is the default.
+     */
+    protected Statement createStatement(boolean wrap) throws SQLException {
+        Statement stmnt;
+
+        if (_del != null) {
+            stmnt = _del.createStatement(false);
+        } else {
+            stmnt = _conn.createStatement();
+        }
+
+        if (wrap) {
+            stmnt = new DelegatingStatement(stmnt, this);
+        }
+
+        return stmnt;
+    }
+
+    public PreparedStatement prepareStatement(String str)
+        throws SQLException {
+        return prepareStatement(str, true);
+    }
+
+    /**
+      *  Prepare a statement, with the option of not wrapping it in a
+     *  {@link DelegatingPreparedStatement}, which is the default.
+     */
+    protected PreparedStatement prepareStatement(String str, boolean wrap)
+        throws SQLException {
+        PreparedStatement stmnt;
+
+        if (_del != null) {
+            stmnt = _del.prepareStatement(str, false);
+        } else {
+            stmnt = _conn.prepareStatement(str);
+        }
+
+        if (wrap) {
+            stmnt = new DelegatingPreparedStatement(stmnt, this);
+        }
+
+        return stmnt;
+    }
+
+    public CallableStatement prepareCall(String str) throws SQLException {
+        return prepareCall(str, true);
+    }
+
+    /**
+      *  Prepare a call, with the option of not wrapping it in a
+     *  {@link DelegatingCallableStatement}, which is the default.
+     */
+    protected CallableStatement prepareCall(String str, boolean wrap)
+        throws SQLException {
+        CallableStatement stmnt;
+
+        if (_del != null) {
+            stmnt = _del.prepareCall(str, false);
+        } else {
+            stmnt = _conn.prepareCall(str);
+        }
+
+        if (wrap) {
+            stmnt = new DelegatingCallableStatement(stmnt, this);
+        }
+
+        return stmnt;
+    }
+
+    public String nativeSQL(String str) throws SQLException {
+        return _conn.nativeSQL(str);
+    }
+
+    public void setAutoCommit(boolean bool) throws SQLException {
+        _conn.setAutoCommit(bool);
+    }
+
+    public boolean getAutoCommit() throws SQLException {
+        return _conn.getAutoCommit();
+    }
+
+    public void commit() throws SQLException {
+        _conn.commit();
+    }
+
+    public void rollback() throws SQLException {
+        _conn.rollback();
+    }
+
+    public void close() throws SQLException {
+        _conn.close();
+    }
+
+    public boolean isClosed() throws SQLException {
+        return _conn.isClosed();
+    }
+
+    public DatabaseMetaData getMetaData() throws SQLException {
+        return getMetaData(true);
+    }
+
+    /**
+      *  Return the metadata, with the option of not wrapping it in a
+     *  {@link DelegatingDatabaseMetaData}, which is the default.
+     */
+    protected DatabaseMetaData getMetaData(boolean wrap)
+        throws SQLException {
+        DatabaseMetaData meta;
+
+        if (_del != null) {
+            meta = _del.getMetaData(false);
+        } else {
+            meta = _conn.getMetaData();
+        }
+
+        if (wrap) {
+            meta = new DelegatingDatabaseMetaData(meta, this);
+        }
+
+        return meta;
+    }
+
+    public void setReadOnly(boolean bool) throws SQLException {
+        _conn.setReadOnly(bool);
+    }
+
+    public boolean isReadOnly() throws SQLException {
+        return _conn.isReadOnly();
+    }
+
+    public void setCatalog(String str) throws SQLException {
+        _conn.setCatalog(str);
+    }
+
+    public String getCatalog() throws SQLException {
+        return _conn.getCatalog();
+    }
+
+    public void setTransactionIsolation(int i) throws SQLException {
+        _conn.setTransactionIsolation(i);
+    }
+
+    public int getTransactionIsolation() throws SQLException {
+        return _conn.getTransactionIsolation();
+    }
+
+    public SQLWarning getWarnings() throws SQLException {
+        return _conn.getWarnings();
+    }
+
+    public void clearWarnings() throws SQLException {
+        _conn.clearWarnings();
+    }
+
+    public Statement createStatement(int type, int concur)
+        throws SQLException {
+        return createStatement(type, concur, true);
+    }
+
+    /**
+      *  Create a statement, with the option of not wrapping it in a
+     *  {@link DelegatingStatement}, which is the default.
+     */
+    protected Statement createStatement(int type, int concur, boolean wrap)
+        throws SQLException {
+        Statement stmnt;
+
+        if (_del != null) {
+            stmnt = _del.createStatement(type, concur, false);
+        } else {
+            stmnt = _conn.createStatement(type, concur);
+        }
+
+        if (wrap) {
+            stmnt = new DelegatingStatement(stmnt, this);
+        }
+
+        return stmnt;
+    }
+
+    public PreparedStatement prepareStatement(String str, int type, int concur)
+        throws SQLException {
+        return prepareStatement(str, type, concur, true);
+    }
+
+    /**
+      *  Prepare a statement, with the option of not wrapping it in a
+     *  {@link DelegatingPreparedStatement}, which is the default.
+     */
+    protected PreparedStatement prepareStatement(String str, int type,
+        int concur, boolean wrap) throws SQLException {
+        PreparedStatement stmnt;
+
+        if (_del != null) {
+            stmnt = _del.prepareStatement(str, type, concur, false);
+        } else {
+            stmnt = _conn.prepareStatement(str, type, concur);
+        }
+
+        if (wrap) {
+            stmnt = new DelegatingPreparedStatement(stmnt, this);
+        }
+
+        return stmnt;
+    }
+
+    public CallableStatement prepareCall(String str, int type, int concur)
+        throws SQLException {
+        return prepareCall(str, type, concur, true);
+    }
+
+    /**
+      *  Prepare a call, with the option of not wrapping it in a
+     *  {@link DelegatingCallableStatement}, which is the default.
+     */
+    protected CallableStatement prepareCall(String str, int type, int concur,
+        boolean wrap) throws SQLException {
+        CallableStatement stmnt;
+
+        if (_del != null) {
+            stmnt = _del.prepareCall(str, type, concur, false);
+        } else {
+            stmnt = _conn.prepareCall(str, type, concur);
+        }
+
+        if (wrap) {
+            stmnt = new DelegatingCallableStatement(stmnt, this);
+        }
+
+        return stmnt;
+    }
+
+    public Map getTypeMap() throws SQLException {
+        return _conn.getTypeMap();
+    }
+
+    public void setTypeMap(Map map) throws SQLException {
+        _conn.setTypeMap(map);
+    }
+
+    // JDBC 3.0 methods follow; these are required to be able to 
+    // compile against JDK 1.4; these methods will not work on
+    // previous JVMs
+    public void setHoldability(int holdability) throws SQLException {
+        assertJDBC3();
+
+        Method m = (Method) _jdbc3.get(SET_HOLDABILITY);
+
+        if (m == null) {
+            m = createJDBC3Method(SET_HOLDABILITY, "setHoldability",
+                    new Class[] { int.class });
+        }
+
+        invokeJDBC3(m, new Object[] { Numbers.valueOf(holdability) });
+    }
+
+    public int getHoldability() throws SQLException {
+        assertJDBC3();
+
+        Method m = (Method) _jdbc3.get(GET_HOLDABILITY);
+
+        if (m == null) {
+            m = createJDBC3Method(GET_HOLDABILITY, "getHoldability", null);
+        }
+
+        return ((Number) invokeJDBC3(m, null)).intValue();
+    }
+
+    public Savepoint setSavepoint() throws SQLException {
+        assertJDBC3();
+
+        Method m = (Method) _jdbc3.get(SET_SAVEPOINT_NONAME);
+
+        if (m == null) {
+            m = createJDBC3Method(SET_SAVEPOINT_NONAME, "setSavepoint", null);
+        }
+
+        return (Savepoint) invokeJDBC3(m, null);
+    }
+
+    public Savepoint setSavepoint(String savepoint) throws SQLException {
+        assertJDBC3();
+
+        Method m = (Method) _jdbc3.get(SET_SAVEPOINT);
+
+        if (m == null) {
+            m = createJDBC3Method(SET_SAVEPOINT, "setSavepoint",
+                    new Class[] { String.class });
+        }
+
+        return (Savepoint) invokeJDBC3(m, new Object[] { savepoint });
+    }
+
+    public void rollback(Savepoint savepoint) throws SQLException {
+        assertJDBC3();
+
+        Method m = (Method) _jdbc3.get(ROLLBACK_SAVEPOINT);
+
+        if (m == null) {
+            m = createJDBC3Method(ROLLBACK_SAVEPOINT, "rollback",
+                    new Class[] { Savepoint.class });
+        }
+
+        invokeJDBC3(m, new Object[] { savepoint });
+    }
+
+    public void releaseSavepoint(Savepoint savepoint) throws SQLException {
+        assertJDBC3();
+
+        Method m = (Method) _jdbc3.get(RELEASE_SAVEPOINT);
+
+        if (m == null) {
+            m = createJDBC3Method(RELEASE_SAVEPOINT, "releaseSavepoint",
+                    new Class[] { Savepoint.class });
+        }
+
+        invokeJDBC3(m, new Object[] { savepoint });
+    }
+
+    public Statement createStatement(int resultSetType,
+        int resultSetConcurrency, int resultSetHoldability)
+        throws SQLException {
+        assertJDBC3();
+
+        return createStatement(resultSetType, resultSetConcurrency,
+            resultSetHoldability, true);
+    }
+
+    protected Statement createStatement(int resultSetType,
+        int resultSetConcurrency, int resultSetHoldability, boolean wrap)
+        throws SQLException {
+        Statement stmnt;
+
+        if (_del != null) {
+            stmnt = _del.createStatement(resultSetType, resultSetConcurrency,
+                    resultSetHoldability, false);
+        } else {
+            Method m = (Method) _jdbc3.get(CREATE_STATEMENT);
+
+            if (m == null) {
+                m = createJDBC3Method(CREATE_STATEMENT, "createStatement",
+                        new Class[] { int.class, int.class, int.class });
+            }
+
+            stmnt = (Statement) invokeJDBC3(m,
+                    new Object[] {
+                        Numbers.valueOf(resultSetType),
+                        Numbers.valueOf(resultSetConcurrency),
+                        Numbers.valueOf(resultSetHoldability)
+                    });
+        }
+
+        if (wrap) {
+            stmnt = new DelegatingStatement(stmnt, this);
+        }
+
+        return stmnt;
+    }
+
+    public PreparedStatement prepareStatement(String sql, int resultSetType,
+        int resultSetConcurrency, int resultSetHoldability)
+        throws SQLException {
+        assertJDBC3();
+
+        return prepareStatement(sql, resultSetType, resultSetConcurrency,
+            resultSetHoldability, true);
+    }
+
+    protected PreparedStatement prepareStatement(String sql, int resultSetType,
+        int resultSetConcurrency, int resultSetHoldability, boolean wrap)
+        throws SQLException {
+        PreparedStatement stmnt;
+
+        if (_del != null) {
+            stmnt = _del.prepareStatement(sql, resultSetType,
+                    resultSetConcurrency, resultSetHoldability, false);
+        } else {
+            Method m = (Method) _jdbc3.get(PREPARE_STATEMENT);
+
+            if (m == null) {
+                m = createJDBC3Method(PREPARE_STATEMENT, "prepareStatement",
+                        new Class[] {
+                            String.class, int.class, int.class, int.class
+                        });
+            }
+
+            stmnt = (PreparedStatement) invokeJDBC3(m,
+                    new Object[] {
+                        sql, Numbers.valueOf(resultSetType),
+                        Numbers.valueOf(resultSetConcurrency),
+                        Numbers.valueOf(resultSetHoldability)
+                    });
+        }
+
+        if (wrap) {
+            stmnt = new DelegatingPreparedStatement(stmnt, this);
+        }
+
+        return stmnt;
+    }
+
+    public CallableStatement prepareCall(String sql, int resultSetType,
+        int resultSetConcurrency, int resultSetHoldability)
+        throws SQLException {
+        assertJDBC3();
+
+        return prepareCall(sql, resultSetType, resultSetConcurrency,
+            resultSetHoldability, true);
+    }
+
+    protected CallableStatement prepareCall(String sql, int resultSetType,
+        int resultSetConcurrency, int resultSetHoldability, boolean wrap)
+        throws SQLException {
+        CallableStatement stmnt;
+
+        if (_del != null) {
+            stmnt = _del.prepareCall(sql, resultSetType, resultSetConcurrency,
+                    resultSetHoldability, false);
+        } else {
+            Method m = (Method) _jdbc3.get(PREPARE_CALL);
+
+            if (m == null) {
+                m = createJDBC3Method(PREPARE_CALL, "prepareCall",
+                        new Class[] {
+                            String.class, int.class, int.class, int.class
+                        });
+            }
+
+            stmnt = (CallableStatement) invokeJDBC3(m,
+                    new Object[] {
+                        sql, Numbers.valueOf(resultSetType),
+                        Numbers.valueOf(resultSetConcurrency),
+                        Numbers.valueOf(resultSetHoldability)
+                    });
+        }
+
+        if (wrap) {
+            stmnt = new DelegatingCallableStatement(stmnt, this);
+        }
+
+        return stmnt;
+    }
+
+    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
+        throws SQLException {
+        assertJDBC3();
+
+        return prepareStatement(sql, autoGeneratedKeys, true);
+    }
+
+    protected PreparedStatement prepareStatement(String sql,
+        int autoGeneratedKeys, boolean wrap) throws SQLException {
+        PreparedStatement stmnt;
+
+        if (_del != null) {
+            stmnt = _del.prepareStatement(sql, autoGeneratedKeys);
+        } else {
+            Method m = (Method) _jdbc3.get(PREPARE_WITH_KEYS);
+
+            if (m == null) {
+                m = createJDBC3Method(PREPARE_WITH_KEYS, "prepareStatement",
+                        new Class[] { String.class, int.class });
+            }
+
+            stmnt = (PreparedStatement) invokeJDBC3(m,
+                    new Object[] { sql, Numbers.valueOf(autoGeneratedKeys) });
+        }
+
+        if (wrap) {
+            stmnt = new DelegatingPreparedStatement(stmnt, this);
+        }
+
+        return stmnt;
+    }
+
+    public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
+        throws SQLException {
+        assertJDBC3();
+
+        return prepareStatement(sql, columnIndexes, true);
+    }
+
+    protected PreparedStatement prepareStatement(String sql,
+        int[] columnIndexes, boolean wrap) throws SQLException {
+        PreparedStatement stmnt;
+
+        if (_del != null) {
+            stmnt = _del.prepareStatement(sql, columnIndexes, wrap);
+        } else {
+            Method m = (Method) _jdbc3.get(PREPARE_WITH_INDEX);
+
+            if (m == null) {
+                m = createJDBC3Method(PREPARE_WITH_INDEX, "prepareStatement",
+                        new Class[] { String.class, int[].class });
+            }
+
+            stmnt = (PreparedStatement) invokeJDBC3(m,
+                    new Object[] { sql, columnIndexes });
+        }
+
+        if (wrap) {
+            stmnt = new DelegatingPreparedStatement(stmnt, this);
+        }
+
+        return stmnt;
+    }
+
+    public PreparedStatement prepareStatement(String sql, String[] columnNames)
+        throws SQLException {
+        assertJDBC3();
+
+        return prepareStatement(sql, columnNames, true);
+    }
+
+    protected PreparedStatement prepareStatement(String sql,
+        String[] columnNames, boolean wrap) throws SQLException {
+        assertJDBC3();
+
+        PreparedStatement stmnt;
+
+        if (_del != null) {
+            stmnt = _del.prepareStatement(sql, columnNames, wrap);
+        } else {
+            Method m = (Method) _jdbc3.get(PREPARE_WITH_NAMES);
+
+            if (m == null) {
+                m = createJDBC3Method(PREPARE_WITH_NAMES, "prepareStatement",
+                        new Class[] { String.class, String[].class });
+            }
+
+            stmnt = (PreparedStatement) invokeJDBC3(m,
+                    new Object[] { sql, columnNames });
+        }
+
+        if (wrap) {
+            stmnt = new DelegatingPreparedStatement(stmnt, this);
+        }
+
+        return stmnt;
+    }
+
+    private static void assertJDBC3() {
+        if (_jdbc3 == null) {
+            throw new UnsupportedOperationException(_loc.get("not-jdbc3"));
+        }
+    }
+
+    private Object invokeJDBC3(Method m, Object[] args)
+        throws SQLException {
+        try {
+            return m.invoke(_conn, args);
+        } catch (Throwable t) {
+            if (t instanceof SQLException) {
+                throw (SQLException) t;
+            }
+
+            throw new NestableRuntimeException(_loc.get("invoke-jdbc3"), t);
+        }
+    }
+
+    private static Method createJDBC3Method(Object key, String name,
+        Class[] args) {
+        try {
+            Method m = Connection.class.getMethod(name, args);
+            _jdbc3.put(key, m);
+
+            return m;
+        } catch (Throwable t) {
+            throw new NestableRuntimeException(_loc.get("error-jdbc3"), t);
+        }
+    }
 }

Modified: incubator/openjpa/trunk/openjpa-lib/main/java/org/apache/openjpa/lib/jdbc/DelegatingDataSource.java
URL: http://svn.apache.org/viewvc/incubator/openjpa/trunk/openjpa-lib/main/java/org/apache/openjpa/lib/jdbc/DelegatingDataSource.java?rev=417856&r1=415364&r2=417856&view=diff
==============================================================================
--- incubator/openjpa/trunk/openjpa-lib/main/java/org/apache/openjpa/lib/jdbc/DelegatingDataSource.java (original)
+++ incubator/openjpa/trunk/openjpa-lib/main/java/org/apache/openjpa/lib/jdbc/DelegatingDataSource.java Wed Jun 28 12:34:33 2006
@@ -15,141 +15,116 @@
  */
 package org.apache.openjpa.lib.jdbc;
 
+import org.apache.openjpa.lib.util.*;
+import org.apache.openjpa.lib.util.Closeable;
 
 import java.io.*;
+
 import java.sql.*;
-import javax.sql.*;
 
-import org.apache.openjpa.lib.util.Closeable; 
+import javax.sql.*;
 
 
 /**
- *	<p>Wrapper around an existing data source.  Subclasses can override the
- *	methods whose behavior they mean to change.  The <code>equals</code> and 
- *	<code>hashCode</code> methods pass through to the base underlying data 
- *	store.</p>
+ *  <p>Wrapper around an existing data source.  Subclasses can override the
+ *  methods whose behavior they mean to change.  The <code>equals</code> and
+ *  <code>hashCode</code> methods pass through to the base underlying data
+ *  store.</p>
  *
- *	@author		Abe White
+ *  @author Abe White
  */
-public class DelegatingDataSource
-	implements DataSource, Closeable
-{
-	private final DataSource 			_ds;
-	private final DelegatingDataSource	_del;
-
-
-	/**
-	 *	Constructor.  Supply wrapped data source.
-	 */
-	public DelegatingDataSource (DataSource ds)
-	{
-		_ds = ds;
-
-		if (_ds instanceof DelegatingDataSource)
-			_del = (DelegatingDataSource) _ds;
-		else
-			_del = null;
-	}
-
-
-	/**
-	 *	Return the wrapped data source.
-	 */
-	public DataSource getDelegate ()
-	{
-		return _ds;
-	}
-
-
-	/**
-	 *	Return the inner-most wrapped delegate.
-	 */
-	public DataSource getInnermostDelegate ()
-	{
-		return (_del == null) ? _ds : _del.getInnermostDelegate ();
-	}
-
-
-	public int hashCode ()
-	{
-		return getInnermostDelegate ().hashCode ();
-	}
-
-
-	public boolean equals (Object other)
-	{
-		if (other == this)
-			return true;
-		if (other instanceof DelegatingDataSource)
-			other = ((DelegatingDataSource) other).getInnermostDelegate ();
-		return getInnermostDelegate ().equals (other);	
-	}
-
-
-	public String toString ()
-	{
-		StringBuffer buf = new StringBuffer ("datasource ").
-			append (hashCode ());
-		appendInfo (buf);
-		return buf.toString ();
-	}
-
-
-	protected void appendInfo (StringBuffer buf)
-	{
-		if (_del != null)
-			_del.appendInfo (buf);
-	}
-
-
-	public PrintWriter getLogWriter ()
-		throws SQLException
-	{
-		return _ds.getLogWriter ();
-	}
-
-
-    public void setLogWriter (PrintWriter out) 
-		throws SQLException
-	{
-		_ds.setLogWriter (out);
-	}
-
-
-	public int getLoginTimeout ()
-		throws SQLException
-	{
-		return _ds.getLoginTimeout ();
-	}
-
-
-    public void setLoginTimeout (int timeout)
-		throws SQLException
-	{
-		_ds.setLoginTimeout (timeout);
-	}
-
-
-	public Connection getConnection ()
-		throws SQLException
-	{
-		return _ds.getConnection ();
-	}
-
-
-	public Connection getConnection (String user, String pass)
-		throws SQLException
-	{
-		if (user == null && pass == null)
-			return _ds.getConnection ();
-		return _ds.getConnection (user, pass);
-	}
-
-
-	public void close ()
-		throws Exception
-	{
-		if (_ds instanceof Closeable)
-			((Closeable) _ds).close ();
-	}
+public class DelegatingDataSource implements DataSource, Closeable {
+    private final DataSource _ds;
+    private final DelegatingDataSource _del;
+
+    /**
+     *  Constructor.  Supply wrapped data source.
+     */
+    public DelegatingDataSource(DataSource ds) {
+        _ds = ds;
+
+        if (_ds instanceof DelegatingDataSource) {
+            _del = (DelegatingDataSource) _ds;
+        } else {
+            _del = null;
+        }
+    }
+
+    /**
+     *  Return the wrapped data source.
+     */
+    public DataSource getDelegate() {
+        return _ds;
+    }
+
+    /**
+     *  Return the inner-most wrapped delegate.
+     */
+    public DataSource getInnermostDelegate() {
+        return (_del == null) ? _ds : _del.getInnermostDelegate();
+    }
+
+    public int hashCode() {
+        return getInnermostDelegate().hashCode();
+    }
+
+    public boolean equals(Object other) {
+        if (other == this) {
+            return true;
+        }
+
+        if (other instanceof DelegatingDataSource) {
+            other = ((DelegatingDataSource) other).getInnermostDelegate();
+        }
+
+        return getInnermostDelegate().equals(other);
+    }
+
+    public String toString() {
+        StringBuffer buf = new StringBuffer("datasource ").append(hashCode());
+        appendInfo(buf);
+
+        return buf.toString();
+    }
+
+    protected void appendInfo(StringBuffer buf) {
+        if (_del != null) {
+            _del.appendInfo(buf);
+        }
+    }
+
+    public PrintWriter getLogWriter() throws SQLException {
+        return _ds.getLogWriter();
+    }
+
+    public void setLogWriter(PrintWriter out) throws SQLException {
+        _ds.setLogWriter(out);
+    }
+
+    public int getLoginTimeout() throws SQLException {
+        return _ds.getLoginTimeout();
+    }
+
+    public void setLoginTimeout(int timeout) throws SQLException {
+        _ds.setLoginTimeout(timeout);
+    }
+
+    public Connection getConnection() throws SQLException {
+        return _ds.getConnection();
+    }
+
+    public Connection getConnection(String user, String pass)
+        throws SQLException {
+        if ((user == null) && (pass == null)) {
+            return _ds.getConnection();
+        }
+
+        return _ds.getConnection(user, pass);
+    }
+
+    public void close() throws Exception {
+        if (_ds instanceof Closeable) {
+            ((Closeable) _ds).close();
+        }
+    }
 }



Mime
View raw message