harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r413642 [3/12] - in /incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java: java/sql/ javax/sql/ javax/transaction/ javax/transaction/xa/ org/apache/harmony/sql/internal/common/
Date Mon, 12 Jun 2006 12:13:44 GMT
Modified: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Clob.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Clob.java?rev=413642&r1=413641&r2=413642&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Clob.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Clob.java Mon Jun 12 05:13:42 2006
@@ -11,123 +11,162 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-
-package java.sql;
-
-import java.io.InputStream;
-import java.io.Reader;
-import java.io.OutputStream;
-import java.io.Writer;
-
-/**
- * A Java interface mapping for the SQL CLOB type.
- * <p>
- * An SQL CLOB type stores a large array of characters as the value in a column of a 
- * database.
- * <p>
- * The java.sql.Clob interface provides methods for setting and retrieving data in the
- * Clob, for querying Clob data length, for searching for data within the Clob.  
- * 
- */
-public interface Clob {
-
-	/**
-	 * Gets the value of this Clob object as an ASCII stream.
-	 * @return an ASCII InputStream giving access to the Clob data
-	 * @throws SQLException if an error occurs accessing the Clob
-	 */ 
-	public InputStream 	getAsciiStream() throws SQLException;
-    
-	/**
-	 * Gets the value of this Clob object as a java.io.Reader.
-	 * @return a character stream Reader object giving access to the Clob data
-	 * @throws SQLException if an error occurs accessing the Clob
-	 */
-	public Reader 	getCharacterStream() throws SQLException;
-     
-	 /**
-	  * Gets a copy of a specified substring in this Clob.
-	  * @param pos the index of the start of the substring in the Clob
-	  * @param length the length of the data to retrieve
-	  * @return A String containing the requested data
-	  * @throws SQLException if an error occurs accessing the Clob
-	  */
-	 public String 	getSubString(long pos, int length) throws SQLException;
-     
-	 /**
-	  * Retrieves the number of characters in this Clob object.
-	  * @return a long value with the number of character in this Clob.
-	  * @throws SQLException if an error occurs accessing the Clob
-	  */
-	 public long 	length() throws SQLException;
-     
-	 /**
-	  * Retrieves the character position at which a specified Clob object appears in this Clob object.
-	  * @param searchstr the specified Clob to search for
-	  * @param start the position within this Clob to start the search
-	  * @return a long value with the position at which the specified Clob occurs within
-	  * this Clob.
-	  * @throws SQLException if an error occurs accessing the Clob
-	  */
-	 public long 	position(Clob searchstr, long start) throws SQLException;
-     
-	 /**
-	  * Retrieves the character position at which a specified substring appears in this Clob object.
-	  * @param searchstr th String to seach for
-	  * @param start the position at which to start the search within this Clob.
-	  * @return a long value with the position at which the specificed String occurs within 
-	  * this Clob.
-	  * @throws SQLException if an error occurs accessing the Clob
-	  */
-	 public long 	position(String searchstr, long start) throws SQLException;
-     
-	 /**
-	  * Retrieves a stream which can be used to write Ascii characters to this Clob object, 
-	  * starting at specified position.
-	  * @param pos the position at which to start the writing
-	  * @return an OutputStream which can be used to write ASCII characters to this Clob.
-	  * @throws SQLException if an error occurs accessing the Clob
-	  */
-	 public OutputStream 	setAsciiStream(long pos) throws SQLException;
-     
-	 /**
-	  * Retrieves a stream which can be used to write a stream of Unicode characters 
-	  * to this Clob object, at a specified position.
-	  * @param pos the position at which to start the writing
-	  * @return a Writer which can be used to write Unicode characters to this Clob.
-	  * @throws SQLException if an error occurs accessing the Clob
-	  */
-	 public Writer 	setCharacterStream(long pos) throws SQLException;
-     
-	 /**
-	  * Writes a given Java String to this Clob object at a specified position.
-	  * @param pos the position at which to start the writing
-	  * @param str the String to write
-	  * @return the number of characters written
-	  * @throws SQLException if an error occurs accessing the Clob
-	  */
-	 public int 	setString(long pos, String str) throws SQLException;
-     
-	 /**
-	  * Writes len characters of String, starting at a specified character offset, to this Clob.
-	  * @param pos the position at which to start the writing
-	  * @param str the String to write
-	  * @param offset the offset within str to start writing from
-	  * @param len the number of characters to write
-	  * @return the number of characters written
-	  * @throws SQLException if an error occurs accessing the Clob
-	  */
-	 public int 	setString(long pos, String str, int offset, int len) throws SQLException;
-     
-	 /**
-	  * Truncates this Clob to have a specified length of characters.
-	  * @param len the length in characters to truncate this Clob
-	  * @throws SQLException if an error occurs accessing the Clob
-	  */
-	 public void 	truncate(long len) throws SQLException;
-     
-} // end interface Clob
-
-
+ */
+
+package java.sql;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.io.OutputStream;
+import java.io.Writer;
+
+/**
+ * A Java interface mapping for the SQL CLOB type.
+ * <p>
+ * An SQL CLOB type stores a large array of characters as the value in a column
+ * of a database.
+ * <p>
+ * The java.sql.Clob interface provides methods for setting and retrieving data
+ * in the Clob, for querying Clob data length, for searching for data within the
+ * Clob.
+ */
+public interface Clob {
+
+    /**
+     * Gets the value of this Clob object as an ASCII stream.
+     * 
+     * @return an ASCII InputStream giving access to the Clob data
+     * @throws SQLException
+     *             if an error occurs accessing the Clob
+     */
+    public InputStream getAsciiStream() throws SQLException;
+
+    /**
+     * Gets the value of this Clob object as a java.io.Reader.
+     * 
+     * @return a character stream Reader object giving access to the Clob data
+     * @throws SQLException
+     *             if an error occurs accessing the Clob
+     */
+    public Reader getCharacterStream() throws SQLException;
+
+    /**
+     * Gets a copy of a specified substring in this Clob.
+     * 
+     * @param pos
+     *            the index of the start of the substring in the Clob
+     * @param length
+     *            the length of the data to retrieve
+     * @return A String containing the requested data
+     * @throws SQLException
+     *             if an error occurs accessing the Clob
+     */
+    public String getSubString(long pos, int length) throws SQLException;
+
+    /**
+     * Retrieves the number of characters in this Clob object.
+     * 
+     * @return a long value with the number of character in this Clob.
+     * @throws SQLException
+     *             if an error occurs accessing the Clob
+     */
+    public long length() throws SQLException;
+
+    /**
+     * Retrieves the character position at which a specified Clob object appears
+     * in this Clob object.
+     * 
+     * @param searchstr
+     *            the specified Clob to search for
+     * @param start
+     *            the position within this Clob to start the search
+     * @return a long value with the position at which the specified Clob occurs
+     *         within this Clob.
+     * @throws SQLException
+     *             if an error occurs accessing the Clob
+     */
+    public long position(Clob searchstr, long start) throws SQLException;
+
+    /**
+     * Retrieves the character position at which a specified substring appears
+     * in this Clob object.
+     * 
+     * @param searchstr
+     *            th String to seach for
+     * @param start
+     *            the position at which to start the search within this Clob.
+     * @return a long value with the position at which the specificed String
+     *         occurs within this Clob.
+     * @throws SQLException
+     *             if an error occurs accessing the Clob
+     */
+    public long position(String searchstr, long start) throws SQLException;
+
+    /**
+     * Retrieves a stream which can be used to write Ascii characters to this
+     * Clob object, starting at specified position.
+     * 
+     * @param pos
+     *            the position at which to start the writing
+     * @return an OutputStream which can be used to write ASCII characters to
+     *         this Clob.
+     * @throws SQLException
+     *             if an error occurs accessing the Clob
+     */
+    public OutputStream setAsciiStream(long pos) throws SQLException;
+
+    /**
+     * Retrieves a stream which can be used to write a stream of Unicode
+     * characters to this Clob object, at a specified position.
+     * 
+     * @param pos
+     *            the position at which to start the writing
+     * @return a Writer which can be used to write Unicode characters to this
+     *         Clob.
+     * @throws SQLException
+     *             if an error occurs accessing the Clob
+     */
+    public Writer setCharacterStream(long pos) throws SQLException;
+
+    /**
+     * Writes a given Java String to this Clob object at a specified position.
+     * 
+     * @param pos
+     *            the position at which to start the writing
+     * @param str
+     *            the String to write
+     * @return the number of characters written
+     * @throws SQLException
+     *             if an error occurs accessing the Clob
+     */
+    public int setString(long pos, String str) throws SQLException;
+
+    /**
+     * Writes len characters of String, starting at a specified character
+     * offset, to this Clob.
+     * 
+     * @param pos
+     *            the position at which to start the writing
+     * @param str
+     *            the String to write
+     * @param offset
+     *            the offset within str to start writing from
+     * @param len
+     *            the number of characters to write
+     * @return the number of characters written
+     * @throws SQLException
+     *             if an error occurs accessing the Clob
+     */
+    public int setString(long pos, String str, int offset, int len)
+            throws SQLException;
+
+    /**
+     * Truncates this Clob to have a specified length of characters.
+     * 
+     * @param len
+     *            the length in characters to truncate this Clob
+     * @throws SQLException
+     *             if an error occurs accessing the Clob
+     */
+    public void truncate(long len) throws SQLException;
+}

Modified: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Connection.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Connection.java?rev=413642&r1=413641&r2=413642&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Connection.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Connection.java Mon Jun 12 05:13:42 2006
@@ -11,744 +11,747 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-
-package java.sql;
-
+ */
+
+package java.sql;
+
 import java.util.Map;
-
-/**
- * A Connection represents a link from a Java application to a database.  All SQL statements and
- * results are returned within the context of a connection.
- * 
- */
-public interface Connection {
-	
-	/**
-	 * A constant indicating that transactions are not supported.
-	 */
-	public static final int TRANSACTION_NONE = 0;
-
-	/**
-	 * No dirty reads are permitted. Transactions may not read a row containing
-	 * changes that have not yet been committed.
-	 */
-	public static final int TRANSACTION_READ_COMMITTED = 2;
-
-	/**
-	 * Dirty reads (reading from table rows containing changes that have not yet
-	 * been committed), non-repeatable reads (reading table rows more than once
-	 * in a transaction but getting back different data because other
-	 * transactions may have altered rows between reads), and phantom reads
-	 * (retrieving additional "phantom" rows in the course of repeated table
-	 * reads because other transactions may have inserted additional rows that
-	 * satisfy an SQL <code>WHERE</code> clause) are <b>all permitted</b>.
-	 */
-	public static final int TRANSACTION_READ_UNCOMMITTED = 1;
-
-	/**
-	 * A constant indicating that dirty reads and non-repeatable reads are
-	 * prevented; phantom reads can occur.
-	 */
-	public static final int TRANSACTION_REPEATABLE_READ = 4;
-
-	/**
-	 * Dirty reads (reading from table rows containing changes that have not yet
-	 * been committed), non-repeatable reads (reading table rows more than once
-	 * in a transaction but getting back different data because other
-	 * transactions may have altered rows between reads), and phantom reads
-	 * (retrieving additional "phantom" rows in the course of repeated table
-	 * reads because other transactions may have inserted additional rows that
-	 * satisfy an SQL <code>WHERE</code> clause) are <b>all prevented</b>.
-	 */
-	public static final int TRANSACTION_SERIALIZABLE = 8;
-    
-	/**
-	 * Throws away any warnings that may have arisen for this connection.
-	 * Subsequent calls to {@link #getWarnings()} will return <code>null</code>
-	 * up until a brand new warning condition occurs.
-	 * 
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public void clearWarnings() throws SQLException;
-    
-	/**
-	 * Causes the instant release of all database and driver connection
-	 * resources associated with this object. Any subsequent invocations of this
-	 * method will have no effect.
-	 * <p>
-	 * It is strongly recommended that all Connections are closed before they
-	 * are dereferenced by the application ready for garbage collection. While
-	 * the finalize method of the Connection will close the Connection before
-	 * garbage collection takes place, it is not advisable to leave the close
-	 * operation to take place in this way. Unpredictable performance may result
-	 * from closing Connections in the finalizer.
-	 * 
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public void close() throws SQLException;
-	
-	/**
-	 * Commits all of the changes made subsequent to the last commit or rollback
-	 * of the associated transaction. All locks in the database held by this
-	 * connection are also relinquished. Calling this operation on connection
-	 * objects in auto-commit mode is an error.
-	 * 
-	 * @throws SQLException
-	 *             if there is a problem accessing the database or if the target
-	 *             connection instance is in auto-commit mode.
-	 */
-	public void commit() throws SQLException;
-    
-    /**
-	 * Returns a new instance of <code>Statement</code> for issuing SQL
-	 * commands to the remote database.
-	 * <p>
-	 * ResultSets generated by the returned Statement will default to type
-	 * <code>TYPE_FORWARD_ONLY</code> and concurrency level
-	 * <code>CONCUR_READ_ONLY</code>.
-	 * 
-	 * @return a <code>Statement</code> object with default settings.
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public Statement createStatement() throws SQLException;
-    
-	/**
-	 * Returns a new instance of <code>Statement</code> whose associated
-	 * <code>ResultSet</code>s will have the characteristics specified in the
-	 * type, concurrency and holdability arguments.
-	 * 
-	 * @param resultSetType
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}
-	 *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}
-	 *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}
-	 *            </ul>
-	 * @param resultSetConcurrency
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#CONCUR_UPDATABLE}
-	 *            <li>{@link ResultSet#CCONCUR_READ_ONLY}
-	 *            </ul>
-	 * @return a new instance of <code>Statement</code> capable of
-	 *         manufacturing <code>ResultSet</code>s that satisfy the
-	 *         specified <code>resultSetType</code> and
-	 *         <code>resultSetConcurrency</code> values.
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public Statement 	createStatement(int resultSetType, int resultSetConcurrency) throws SQLException;
-    
-	/**
-	 * Returns a new instance of <code>Statement</code> whose associated 
-	 * <code>ResultSet</code>s will have the characteristics specified in the 
-	 * type, concurrency and holdability arguments.
-	 * 
-	 * @param resultSetType
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}
-	 *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}
-	 *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}
-	 *            </ul>
-	 * @param resultSetConcurrency
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#CONCUR_UPDATABLE}
-	 *            <li>{@link ResultSet#CONCUR_READ_ONLY}
-	 *            </ul>
-	 * @param resultSetHoldability
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT}
-	 *            <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT}
-	 *            </ul>
-	 * @return a new instance of <code>Statement</code> capable of
-	 *         manufacturing <code>ResultSet</code>s that satisfy the
-	 *         specified <code>resultSetType</code>,
-	 *         <code>resultSetConcurrency</code> and
-	 *         <code>resultSetHoldability</code> values.
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public Statement createStatement(int resultSetType,
-			int resultSetConcurrency, int resultSetHoldability)
-			throws SQLException;
-    
-	/**
-	 * Returns a boolean indication of whether or not this connection is in the
-	 * auto-commit operating mode.
-	 * 
-	 * @return <code>true</code> if auto-commit is on, otherwise
-	 *         <code>false</code>
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public boolean getAutoCommit() throws SQLException;
-    
-	/**
-	 * Gets this Connection object's current catalog name.
-	 * 
-	 * @return the catalog name. <code>null</code> if there is no catalog name.
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public String getCatalog() throws SQLException;
-    
-	/**
-	 * Returns the kind of holdability that any <code>ResultSet</code>s made
-	 * from this instance will have.
-	 * 
-	 * @return one of :
-	 *         <ul>
-	 *         <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT}
-	 *         <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT}
-	 *         </ul>
-	 * @throws SQLException
-	 *             if there is a problem accessing the a database
-	 */
-	public int getHoldability() throws SQLException;
-    
-	/**
-	 * Gets the metadata about the database referenced by this connection. The
-	 * returned <code>DatabaseMetaData</code> describes the database
-	 * topography, available stored procedures, SQL syntax and so on.
-	 * 
-	 * @return a <code>DatabaseMetaData</code> object containing the database
-	 *         description
-	 * @throws SQLException
-	 *             if there is a problem accessing the a database
-	 */
-	public DatabaseMetaData getMetaData() throws SQLException;
-    
-	/**
-	 * Returns the present value of transaction isolation for this
-	 * Connection instance.
-	 * 
-	 * @return the transaction isolation value
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 * @see #TRANSACTION_NONE
-	 * @see #TRANSACTION_READ_COMMITTED
-	 * @see #TRANSACTION_READ_UNCOMMITTED
-	 * @see #TRANSACTION_REPEATABLE_READ
-	 * @see #TRANSACTION_SERIALIZABLE
-	 */
-	public int 	getTransactionIsolation() throws SQLException;
-    
-	/**
-	 * Returns the Type Map associated with this Connection object. The type map
-	 * will be empty unless the application has added at least one entry.
-	 * 
-	 * @return the Type Map as a <code>java.util.Map</code>
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public Map<String, Class<?>> getTypeMap() throws SQLException;
-    
-	/**
-	 * Gets the first instance of any <code>SQLWarning</code> objects that may
-	 * have been created in the use of this connection. If at least one warning
-	 * has occurred then this operation returns the first one reported. A
-	 * <code>null</code> indicates that no warnings have occurred.
-	 * <p>
-	 * By invoking the {@link SQLWarning#getNextWarning()} method of the
-	 * returned <code>SQLWarning</code> object it is possible to obtain all
-	 * warning objects.
-	 * 
-	 * @return the first warning as an SQLWarning object (may be
-	 *         <code>null</code>)
-	 * @throws SQLException
-	 *             if there is a problem accessing the database or if the call
-	 *             has been made on a connection which has been previously
-	 *             closed.
-	 */
-	public SQLWarning getWarnings() throws SQLException;
-    
-	/**
-	 * Returns a boolean indication of whether or not this connection is in the
-	 * closed state. The closed state may be entered into as a consequence of a
-	 * successful invocation of the {@link #close()} method or else if an error
-	 * has occurred that prevents the connection from functioning normally.
-	 * 
-	 * @return <code>true</code> if closed, otherwise <code>false</code>
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public boolean isClosed() throws SQLException;
-    
-	/**
-	 * Returns a boolean indication of whether or not this connection is
-	 * currently in read-only state.
-	 * 
-	 * @return <code>true</code> if in read-only state, otherwise
-	 *         <code>false</code>.
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public boolean isReadOnly() throws SQLException;
-    
-	/**
-	 * Returns a string representation of the input SQL statement
-	 * <code>sql</code> expressed in the underlying system's native SQL
-	 * syntax.
-	 * 
-	 * @param sql
-	 *            the JDBC form of an SQL statement.
-	 * @return the SQL statement in native database format.
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public String nativeSQL(String sql) throws SQLException;
-    
-	/**
-	 * Returns a new instance of <code>CallableStatement</code> that may be
-	 * used for making stored procedure calls to the database.
-	 * 
-	 * @param sql
-	 *            the SQL statement that calls the stored function
-	 * @return a new instance of <code>CallableStatement</code> representing
-	 *         the SQL statement. <code>ResultSet</code>s emitted from this
-	 *         <code>CallableStatement</code> will default to type
-	 *         {@link ResultSet#TYPE_FORWARD_ONLY} and concurrency
-	 *         {@link ResultSet#CONCUR_READ_ONLY}.
-	 * @throws SQLException
-	 *             if a problem occurs accessing the database
-	 */
-	public CallableStatement prepareCall(String sql) throws SQLException;
-    
-	/**
-	 * Returns a new instance of <code>CallableStatement</code> that may be
-	 * used for making stored procedure calls to the database.
-	 * <code>ResultSet</code>s emitted from this
-	 * <code>CallableStatement</code> will satisfy the specified
-	 * <code>resultSetType</code> and <code>resultSetConcurrency</code>
-	 * values.
-	 * 
-	 * @param sql
-	 *            the SQL statement
-	 * @param resultSetType
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}
-	 *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}
-	 *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}
-	 *            </ul>
-	 * @param resultSetConcurrency
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#CONCUR_READ_ONLY}
-	 *            <li>{@link ResultSet#CONCUR_UPDATABLE}
-	 *            </ul>
-	 * @return a new instance of <code>CallableStatement</code> representing
-	 *         the precompiled SQL statement. <code>ResultSet</code>s emitted
-	 *         from this <code>CallableStatement</code> will satisfy the
-	 *         specified <code>resultSetType</code> and
-	 *         <code>resultSetConcurrency</code> values.
-	 * @throws SQLException
-	 *             if a problem occurs accessing the database
-	 */
-	public CallableStatement prepareCall(String sql, int resultSetType,
-			int resultSetConcurrency) throws SQLException;
-    
-	/**
-	 * Returns a new instance of <code>CallableStatement</code> that may be
-	 * used for making stored procedure calls to the database. ResultSets
-	 * created from this <code>CallableStatement</code> will have
-	 * characteristics determined by the specified type, concurrency and
-	 * holdability arguments.
-	 * 
-	 * @param sql
-	 *            the SQL statement
-	 * @param resultSetType
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}
-	 *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}
-	 *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}
-	 *            </ul>
-	 * @param resultSetConcurrency
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#CONCUR_READ_ONLY}
-	 *            <li>{@link ResultSet#CONCUR_UPDATABLE}
-	 *            </ul>
-	 * @param resultSetHoldability
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT}
-	 *            <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT}
-	 *            </ul>
-	 * @return a new instance of <code>CallableStatement</code> representing
-	 *         the precompiled SQL statement. <code>ResultSet</code>s emitted
-	 *         from this <code>CallableStatement</code> will satisfy the
-	 *         specified <code>resultSetType</code>,
-	 *         <code>resultSetConcurrency</code> and
-	 *         <code>resultSetHoldability</code> values.
-	 * @throws SQLException
-	 *             if a problem occurs accessing the database
-	 */
-	public CallableStatement prepareCall(String sql, int resultSetType,
-			int resultSetConcurrency, int resultSetHoldability)
-			throws SQLException;
-    
-	/**
-	 * Returns a new instance of <code>PreparedStatement</code> that may 
-	 * be used any number of times to execute parameterized requests on the 
-	 * database server. 
-	 * <p>
-	 * Subject to JDBC driver support, this operation will attempt to send the
-	 * precompiled version of the statement to the database. Alternatively, if
-	 * the driver is not capable of flowing precompiled statements, the
-	 * statement will not reach the database server until it is executed. This
-	 * will have a bearing on precisely when <code>SQLException</code>
-	 * instances get raised.
-	 * <p>
-	 * By default, ResultSets from the returned object will be
-	 * {@link ResultSet#TYPE_FORWARD_ONLY} type with a
-	 * {@link ResultSet#CONCUR_READ_ONLY} mode of concurrency.
-	 * 
-	 * @param sql
-	 *            the SQL statement.
-	 * @return the PreparedStatement containing the supplied SQL statement
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public PreparedStatement prepareStatement(String sql) throws SQLException;
-    
-	/**
-	 * Creates a default PreparedStatement that can retrieve automatically
-	 * generated keys. Parameter <code>autoGeneratedKeys</code> may be used to
-	 * specify to the driver if such keys should be made accessible. This is
-	 * only the case when <code>sql</code> is an insert statement.
-	 * <p>
-	 * An SQL statement which may have IN parameters can be stored and
-	 * precompiled in a PreparedStatement. The PreparedStatement can then be
-	 * used to execute the statement multiple times in an efficient way.
-	 * <p>
-	 * Subject to JDBC driver support, this operation will attempt to send the
-	 * precompiled version of the statement to the database. Alternatively, if
-	 * the driver is not capable of flowing precompiled statements, the
-	 * statement will not reach the database server until it is executed. This
-	 * will have a bearing on precisely when <code>SQLException</code>
-	 * instances get raised.
-	 * <p>
-	 * By default, ResultSets from the returned object will be
-	 * {@link ResultSet#TYPE_FORWARD_ONLY} type with a
-	 * {@link ResultSet#CONCUR_READ_ONLY} mode of concurrency.
-	 * 
-	 * @param sql
-	 *            the SQL statement.
-	 * @param autoGeneratedKeys
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link Statement#RETURN_GENERATED_KEYS}
-	 *            <li>{@link Statement#NO_GENERATED_KEYS}
-	 *            </ul>
-	 * @return a new <code>PreparedStatement</code> instance representing the
-	 *         input SQL statement.
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
-			throws SQLException;
-    
-	/**
-	 * Creates a default PreparedStatement that can retrieve the auto-generated
-	 * keys designated by a supplied array. If <code>sql</code> is an SQL
-	 * <code>INSERT</code> statement, parameter <code>columnIndexes</code>
-	 * is expected to hold the index values for each column in the statement's
-	 * intended database table containing the autogenerated-keys of interest.
-	 * Otherwise <code>columnIndexes</code> is ignored.
-	 * <p>
-	 * Subject to JDBC driver support, this operation will attempt to send the
-	 * precompiled version of the statement to the database. Alternatively, if
-	 * the driver is not capable of flowing precompiled statements, the
-	 * statement will not reach the database server until it is executed. This
-	 * will have a bearing on precisely when <code>SQLException</code>
-	 * instances get raised.
-	 * <p>
-	 * By default, ResultSets from the returned object will be
-	 * {@link ResultSet#TYPE_FORWARD_ONLY} type with a
-	 * {@link ResultSet#CONCUR_READ_ONLY} mode of concurrency.
-	 * 
-	 * @param sql
-	 *            the SQL statement.
-	 * @param columnIndexes
-	 *            the indexes of the columns for which auto-generated keys
-	 *            should be made available.
-	 * @return the PreparedStatement containing the supplied SQL statement
-	 * @throws SQLException
-	 *             if a problem occurs accessing the database
-	 */
-	public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
-			throws SQLException;
-    
-	/**
-	 * Creates a PreparedStatement that generates ResultSets with the specified
-	 * values of <code>resultSetType</code> and
-	 * <code>resultSetConcurrency</code>.
-	 * 
-	 * @param sql
-	 *            the SQL statement. It can contain one or more '?' IN parameter
-	 *            placeholders
-	 * @param resultSetType
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}
-	 *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}
-	 *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}
-	 *            </ul>
-	 * @param resultSetConcurrency
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#CONCUR_READ_ONLY}
-	 *            <li>{@link ResultSet#CONCUR_UPDATABLE}
-	 *            </ul>
-	 * @return a new instance of <code>PreparedStatement</code> containing the
-	 *         SQL statement <code>sql</code>. <code>ResultSet</code>s
-	 *         emitted from this <code>PreparedStatement</code> will satisfy
-	 *         the specified <code>resultSetType</code> and
-	 *         <code>resultSetConcurrency</code> values.
-	 * @throws SQLException
-	 *             if a problem occurs accessing the database
- 	 */
-	public PreparedStatement prepareStatement(String sql, int resultSetType,
-			int resultSetConcurrency) throws SQLException;
-    
-	/**
-	 * Creates a PreparedStatement that generates ResultSets with the specified
-	 * type, concurrency and holdability
-	 * 
-	 * @param sql
-	 *            the SQL statement. It can contain one or more '?' IN parameter
-	 *            placeholders
-	 * @param resultSetType
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}
-	 *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}
-	 *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}
-	 *            </ul>
-	 * @param resultSetConcurrency
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#CONCUR_READ_ONLY}
-	 *            <li>{@link ResultSet#CONCUR_UPDATABLE}
-	 *            </ul>
-	 * @param resultSetHoldability
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT}
-	 *            <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT}
-	 *            </ul>
-	 * 
-	 * @return a new instance of <code>PreparedStatement</code> containing the
-	 *         SQL statement <code>sql</code>. <code>ResultSet</code>s
-	 *         emitted from this <code>PreparedStatement</code> will satisfy
-	 *         the specified <code>resultSetType</code>,
-	 *         <code>resultSetConcurrency</code> and
-	 *         <code>resultSetHoldability</code> values.
-	 * @throws SQLException
-	 *             if a problem occurs accessing the database
-	 */
-	public PreparedStatement prepareStatement(String sql, int resultSetType,
-			int resultSetConcurrency, int resultSetHoldability)
-			throws SQLException;
-    
-	/**
-	 * Creates a default PreparedStatement that can retrieve the auto-generated
-	 * keys designated by a supplied array. If <code>sql</code> is an SQL
-	 * <code>INSERT</code> statement, <code>columnNames</code> is expected
-	 * to hold the names of each column in the statement's associated database
-	 * table containing the autogenerated-keys of interest. Otherwise
-	 * <code>columnNames</code> is ignored.
-	 * <p>
-	 * Subject to JDBC driver support, this operation will attempt to send the
-	 * precompiled version of the statement to the database. Alternatively, if
-	 * the driver is not capable of flowing precompiled statements, the
-	 * statement will not reach the database server until it is executed. This
-	 * will have a bearing on precisely when <code>SQLException</code>
-	 * instances get raised.
-	 * <p>
-	 * By default, ResultSets from the returned object will be
-	 * {@link ResultSet#TYPE_FORWARD_ONLY} type with a
-	 * {@link ResultSet#CONCUR_READ_ONLY} mode of concurrency.
-	 * 
-	 * @param sql
-	 *            the SQL statement.
-	 * @param columnNames
-	 *            the names of the columns for which auto-generated keys should
-	 *            be made available.
-	 * @return the PreparedStatement containing the supplied SQL statement
-	 * @throws SQLException
-	 *             if a problem occurs accessing the database
-	 */
-	public PreparedStatement prepareStatement(String sql, String[] columnNames)
-			throws SQLException;
-    
-	/**
-	 * Releases <code>savepoint</code> from the present transaction. Once
-	 * removed, the <code>Savepoint</code> is considered invalid and should
-	 * not be referenced further.
-	 * 
-	 * @param savepoint
-	 *            the object targeted for removal
-	 * @throws SQLException
-	 *             if there is a problem with accessing the database or if
-	 *             <code>savepoint</code> is considered not valid in this
-	 *             transaction.
-	 */
-	public void releaseSavepoint(Savepoint savepoint) throws SQLException;
-    
-	/**
-	 * Rolls back all updates made so far in this transaction as well as
-	 * relinquishing all acquired database locks. It is an error to invoke this
-	 * operation when in auto-commit mode.
-	 * 
-	 * @throws SQLException
-	 *             if there is a problem with the database or if the method is
-	 *             called while in auto-commit mode of operation.
-	 */
-	public void rollback() throws SQLException;
-    
-	/**
-	 * Undoes all changes made after the supplied Savepoint object was set. This
-	 * method should only be used when auto-commit mode is disabled.
-	 * 
-	 * @param savepoint 
-	 *            the Savepoint to roll back to
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public void rollback(Savepoint savepoint) throws SQLException;
-    
-	/**
-	 * Sets this connection's auto-commit mode on or off.
-	 * <p>
-	 * Putting a Connection into auto-commit mode means that all associated SQL
-	 * statements will be run and committed in their own separate transactions.
-	 * Alternatively, auto-commit set to off means that associated SQL
-	 * statements get grouped into transactions that need to be completed by
-	 * explicit calls to either the {@link #commit()} or {@link #rollback()}
-	 * methods.
-	 * <p>
-	 * Auto-commit is the default mode for new connection instances.
-	 * <p>
-	 * When in this mode, commits will automatically occur upon successful SQL
-	 * statement completion or upon successful completion of an execute.
-	 * Statements are not considered successfully complete until all associated
-	 * <code>ResultSet</code>s and output parameters have been obtained or
-	 * closed.
-	 * <p>
-	 * Calling this operation during an uncommitted transaction will result in
-	 * it being committed.
-	 * 
-	 * @param autoCommit
-	 *            boolean indication of whether to put the target connection
-	 *            into auto-commit mode (<code>true</code>) or not (<code>false</code>)
-	 * 
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public void setAutoCommit(boolean autoCommit) throws SQLException;
-    
-	/**
-	 * Sets the catalog name for this connection. This is used to select a
-	 * subspace of the database for future work. If the driver does not support
-	 * catalog names, this method is ignored.
-	 * 
-	 * @param catalog
-	 *            the catalog name to use.
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public void setCatalog(String catalog) throws SQLException;
-    
-	/**
-	 * Sets the holdability of ResultSets created by this Connection.
-	 * 
-	 * @param holdability
-	 *            one of :
-	 *            <ul>
-	 *            <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT}
-	 *            <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT}
-	 *            <li>
-	 *            </ul>
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public void setHoldability(int holdability) throws SQLException;
-    
-	/**
-	 * Sets this connection to read-only mode.
-	 * <p>
-	 * This serves as a hint to the driver, which can enable database
-	 * optimizations.
-	 * 
-	 * @param readOnly
-	 *            true to set the Connection to read only mode. false disables
-	 *            read-only mode
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public void setReadOnly(boolean readOnly) throws SQLException;
-    
-	/**
-	 * Creates an unnamed Savepoint in the current transaction.
-	 * 
-	 * @return a Savepoint object for this savepoint.
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public Savepoint setSavepoint() throws SQLException;
-    
-	/**
-	 * Creates a named Savepoint in the current transaction.
-	 * 
-	 * @param name
-	 *            the name to use for the new Savepoint.
-	 * @return a Savepoint object for this savepoint.
-	 * @throws SQLException
-	 *             if there is a problem accessing the database
-	 */
-	public Savepoint setSavepoint(String name) throws SQLException;
-    
-	/**
-	 * Sets the transaction isolation level for this Connection.
-	 * <p>
-	 * If this method is called during a transaction, the results are implementation defined. 
-	 * @param level the new transaction isolation level to use from the following
-	 * list of possible values :
-	 * <ul>
-	 * <li>{@link #TRANSACTION_READ_COMMITTED}
-	 * <li>{@link #TRANSACTION_READ_UNCOMMITTED}
-	 * <li>{@link #TRANSACTION_REPEATABLE_READ}
-	 * <li>{@link #TRANSACTION_SERIALIZABLE}
-	 * </ul>
-	 * @throws SQLException if there is a problem with the database or if the 
-	 * value of <code>level</code> is not one of the expected constant values. 
-	 */
-	public void 	setTransactionIsolation(int level) throws SQLException;
-   
-	/**
-	 * Sets the <code>TypeMap</code> for this connection. The input
-	 * <code>map</code> should contain mappings between complex Java and SQL
-	 * types.
-	 * 
-	 * @param map
-	 *            the new type map
-	 * @throws SQLException
-	 *             if there is a problem accessing the database or if
-	 *             <code>map</code> is not an instance of {@link Map}.
-	 */
-	public void setTypeMap(Map<String, Class<?>> map) throws SQLException;
-    
-} // end interface Connection
-
-
+
+/**
+ * A Connection represents a link from a Java application to a database. All SQL
+ * statements and results are returned within the context of a connection.
+ * 
+ */
+public interface Connection {
+
+    /**
+     * A constant indicating that transactions are not supported.
+     */
+    public static final int TRANSACTION_NONE = 0;
+
+    /**
+     * No dirty reads are permitted. Transactions may not read a row containing
+     * changes that have not yet been committed.
+     */
+    public static final int TRANSACTION_READ_COMMITTED = 2;
+
+    /**
+     * Dirty reads (reading from table rows containing changes that have not yet
+     * been committed), non-repeatable reads (reading table rows more than once
+     * in a transaction but getting back different data because other
+     * transactions may have altered rows between reads), and phantom reads
+     * (retrieving additional "phantom" rows in the course of repeated table
+     * reads because other transactions may have inserted additional rows that
+     * satisfy an SQL <code>WHERE</code> clause) are <b>all permitted</b>.
+     */
+    public static final int TRANSACTION_READ_UNCOMMITTED = 1;
+
+    /**
+     * A constant indicating that dirty reads and non-repeatable reads are
+     * prevented; phantom reads can occur.
+     */
+    public static final int TRANSACTION_REPEATABLE_READ = 4;
+
+    /**
+     * Dirty reads (reading from table rows containing changes that have not yet
+     * been committed), non-repeatable reads (reading table rows more than once
+     * in a transaction but getting back different data because other
+     * transactions may have altered rows between reads), and phantom reads
+     * (retrieving additional "phantom" rows in the course of repeated table
+     * reads because other transactions may have inserted additional rows that
+     * satisfy an SQL <code>WHERE</code> clause) are <b>all prevented</b>.
+     */
+    public static final int TRANSACTION_SERIALIZABLE = 8;
+
+    /**
+     * Throws away any warnings that may have arisen for this connection.
+     * Subsequent calls to {@link #getWarnings()} will return <code>null</code>
+     * up until a brand new warning condition occurs.
+     * 
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public void clearWarnings() throws SQLException;
+
+    /**
+     * Causes the instant release of all database and driver connection
+     * resources associated with this object. Any subsequent invocations of this
+     * method will have no effect.
+     * <p>
+     * It is strongly recommended that all Connections are closed before they
+     * are dereferenced by the application ready for garbage collection. While
+     * the finalize method of the Connection will close the Connection before
+     * garbage collection takes place, it is not advisable to leave the close
+     * operation to take place in this way. Unpredictable performance may result
+     * from closing Connections in the finalizer.
+     * 
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public void close() throws SQLException;
+
+    /**
+     * Commits all of the changes made subsequent to the last commit or rollback
+     * of the associated transaction. All locks in the database held by this
+     * connection are also relinquished. Calling this operation on connection
+     * objects in auto-commit mode is an error.
+     * 
+     * @throws SQLException
+     *             if there is a problem accessing the database or if the target
+     *             connection instance is in auto-commit mode.
+     */
+    public void commit() throws SQLException;
+
+    /**
+     * Returns a new instance of <code>Statement</code> for issuing SQL
+     * commands to the remote database.
+     * <p>
+     * ResultSets generated by the returned Statement will default to type
+     * <code>TYPE_FORWARD_ONLY</code> and concurrency level
+     * <code>CONCUR_READ_ONLY</code>.
+     * 
+     * @return a <code>Statement</code> object with default settings.
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public Statement createStatement() throws SQLException;
+
+    /**
+     * Returns a new instance of <code>Statement</code> whose associated
+     * <code>ResultSet</code>s will have the characteristics specified in the
+     * type, concurrency and holdability arguments.
+     * 
+     * @param resultSetType
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}
+     *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}
+     *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}
+     *            </ul>
+     * @param resultSetConcurrency
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#CONCUR_UPDATABLE}
+     *            <li>{@link ResultSet#CCONCUR_READ_ONLY}
+     *            </ul>
+     * @return a new instance of <code>Statement</code> capable of
+     *         manufacturing <code>ResultSet</code>s that satisfy the
+     *         specified <code>resultSetType</code> and
+     *         <code>resultSetConcurrency</code> values.
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public Statement createStatement(int resultSetType, int resultSetConcurrency)
+            throws SQLException;
+
+    /**
+     * Returns a new instance of <code>Statement</code> whose associated
+     * <code>ResultSet</code>s will have the characteristics specified in the
+     * type, concurrency and holdability arguments.
+     * 
+     * @param resultSetType
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}
+     *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}
+     *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}
+     *            </ul>
+     * @param resultSetConcurrency
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#CONCUR_UPDATABLE}
+     *            <li>{@link ResultSet#CONCUR_READ_ONLY}
+     *            </ul>
+     * @param resultSetHoldability
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT}
+     *            <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT}
+     *            </ul>
+     * @return a new instance of <code>Statement</code> capable of
+     *         manufacturing <code>ResultSet</code>s that satisfy the
+     *         specified <code>resultSetType</code>,
+     *         <code>resultSetConcurrency</code> and
+     *         <code>resultSetHoldability</code> values.
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public Statement createStatement(int resultSetType,
+            int resultSetConcurrency, int resultSetHoldability)
+            throws SQLException;
+
+    /**
+     * Returns a boolean indication of whether or not this connection is in the
+     * auto-commit operating mode.
+     * 
+     * @return <code>true</code> if auto-commit is on, otherwise
+     *         <code>false</code>
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public boolean getAutoCommit() throws SQLException;
+
+    /**
+     * Gets this Connection object's current catalog name.
+     * 
+     * @return the catalog name. <code>null</code> if there is no catalog
+     *         name.
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public String getCatalog() throws SQLException;
+
+    /**
+     * Returns the kind of holdability that any <code>ResultSet</code>s made
+     * from this instance will have.
+     * 
+     * @return one of :
+     *         <ul>
+     *         <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT}
+     *         <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT}
+     *         </ul>
+     * @throws SQLException
+     *             if there is a problem accessing the a database
+     */
+    public int getHoldability() throws SQLException;
+
+    /**
+     * Gets the metadata about the database referenced by this connection. The
+     * returned <code>DatabaseMetaData</code> describes the database
+     * topography, available stored procedures, SQL syntax and so on.
+     * 
+     * @return a <code>DatabaseMetaData</code> object containing the database
+     *         description
+     * @throws SQLException
+     *             if there is a problem accessing the a database
+     */
+    public DatabaseMetaData getMetaData() throws SQLException;
+
+    /**
+     * Returns the present value of transaction isolation for this Connection
+     * instance.
+     * 
+     * @return the transaction isolation value
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     * @see #TRANSACTION_NONE
+     * @see #TRANSACTION_READ_COMMITTED
+     * @see #TRANSACTION_READ_UNCOMMITTED
+     * @see #TRANSACTION_REPEATABLE_READ
+     * @see #TRANSACTION_SERIALIZABLE
+     */
+    public int getTransactionIsolation() throws SQLException;
+
+    /**
+     * Returns the Type Map associated with this Connection object. The type map
+     * will be empty unless the application has added at least one entry.
+     * 
+     * @return the Type Map as a <code>java.util.Map</code>
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public Map<String, Class<?>> getTypeMap() throws SQLException;
+
+    /**
+     * Gets the first instance of any <code>SQLWarning</code> objects that may
+     * have been created in the use of this connection. If at least one warning
+     * has occurred then this operation returns the first one reported. A
+     * <code>null</code> indicates that no warnings have occurred.
+     * <p>
+     * By invoking the {@link SQLWarning#getNextWarning()} method of the
+     * returned <code>SQLWarning</code> object it is possible to obtain all
+     * warning objects.
+     * 
+     * @return the first warning as an SQLWarning object (may be
+     *         <code>null</code>)
+     * @throws SQLException
+     *             if there is a problem accessing the database or if the call
+     *             has been made on a connection which has been previously
+     *             closed.
+     */
+    public SQLWarning getWarnings() throws SQLException;
+
+    /**
+     * Returns a boolean indication of whether or not this connection is in the
+     * closed state. The closed state may be entered into as a consequence of a
+     * successful invocation of the {@link #close()} method or else if an error
+     * has occurred that prevents the connection from functioning normally.
+     * 
+     * @return <code>true</code> if closed, otherwise <code>false</code>
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public boolean isClosed() throws SQLException;
+
+    /**
+     * Returns a boolean indication of whether or not this connection is
+     * currently in read-only state.
+     * 
+     * @return <code>true</code> if in read-only state, otherwise
+     *         <code>false</code>.
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public boolean isReadOnly() throws SQLException;
+
+    /**
+     * Returns a string representation of the input SQL statement
+     * <code>sql</code> expressed in the underlying system's native SQL
+     * syntax.
+     * 
+     * @param sql
+     *            the JDBC form of an SQL statement.
+     * @return the SQL statement in native database format.
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public String nativeSQL(String sql) throws SQLException;
+
+    /**
+     * Returns a new instance of <code>CallableStatement</code> that may be
+     * used for making stored procedure calls to the database.
+     * 
+     * @param sql
+     *            the SQL statement that calls the stored function
+     * @return a new instance of <code>CallableStatement</code> representing
+     *         the SQL statement. <code>ResultSet</code>s emitted from this
+     *         <code>CallableStatement</code> will default to type
+     *         {@link ResultSet#TYPE_FORWARD_ONLY} and concurrency
+     *         {@link ResultSet#CONCUR_READ_ONLY}.
+     * @throws SQLException
+     *             if a problem occurs accessing the database
+     */
+    public CallableStatement prepareCall(String sql) throws SQLException;
+
+    /**
+     * Returns a new instance of <code>CallableStatement</code> that may be
+     * used for making stored procedure calls to the database.
+     * <code>ResultSet</code>s emitted from this
+     * <code>CallableStatement</code> will satisfy the specified
+     * <code>resultSetType</code> and <code>resultSetConcurrency</code>
+     * values.
+     * 
+     * @param sql
+     *            the SQL statement
+     * @param resultSetType
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}
+     *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}
+     *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}
+     *            </ul>
+     * @param resultSetConcurrency
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#CONCUR_READ_ONLY}
+     *            <li>{@link ResultSet#CONCUR_UPDATABLE}
+     *            </ul>
+     * @return a new instance of <code>CallableStatement</code> representing
+     *         the precompiled SQL statement. <code>ResultSet</code>s emitted
+     *         from this <code>CallableStatement</code> will satisfy the
+     *         specified <code>resultSetType</code> and
+     *         <code>resultSetConcurrency</code> values.
+     * @throws SQLException
+     *             if a problem occurs accessing the database
+     */
+    public CallableStatement prepareCall(String sql, int resultSetType,
+            int resultSetConcurrency) throws SQLException;
+
+    /**
+     * Returns a new instance of <code>CallableStatement</code> that may be
+     * used for making stored procedure calls to the database. ResultSets
+     * created from this <code>CallableStatement</code> will have
+     * characteristics determined by the specified type, concurrency and
+     * holdability arguments.
+     * 
+     * @param sql
+     *            the SQL statement
+     * @param resultSetType
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}
+     *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}
+     *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}
+     *            </ul>
+     * @param resultSetConcurrency
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#CONCUR_READ_ONLY}
+     *            <li>{@link ResultSet#CONCUR_UPDATABLE}
+     *            </ul>
+     * @param resultSetHoldability
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT}
+     *            <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT}
+     *            </ul>
+     * @return a new instance of <code>CallableStatement</code> representing
+     *         the precompiled SQL statement. <code>ResultSet</code>s emitted
+     *         from this <code>CallableStatement</code> will satisfy the
+     *         specified <code>resultSetType</code>,
+     *         <code>resultSetConcurrency</code> and
+     *         <code>resultSetHoldability</code> values.
+     * @throws SQLException
+     *             if a problem occurs accessing the database
+     */
+    public CallableStatement prepareCall(String sql, int resultSetType,
+            int resultSetConcurrency, int resultSetHoldability)
+            throws SQLException;
+
+    /**
+     * Returns a new instance of <code>PreparedStatement</code> that may be
+     * used any number of times to execute parameterized requests on the
+     * database server.
+     * <p>
+     * Subject to JDBC driver support, this operation will attempt to send the
+     * precompiled version of the statement to the database. Alternatively, if
+     * the driver is not capable of flowing precompiled statements, the
+     * statement will not reach the database server until it is executed. This
+     * will have a bearing on precisely when <code>SQLException</code>
+     * instances get raised.
+     * <p>
+     * By default, ResultSets from the returned object will be
+     * {@link ResultSet#TYPE_FORWARD_ONLY} type with a
+     * {@link ResultSet#CONCUR_READ_ONLY} mode of concurrency.
+     * 
+     * @param sql
+     *            the SQL statement.
+     * @return the PreparedStatement containing the supplied SQL statement
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public PreparedStatement prepareStatement(String sql) throws SQLException;
+
+    /**
+     * Creates a default PreparedStatement that can retrieve automatically
+     * generated keys. Parameter <code>autoGeneratedKeys</code> may be used to
+     * specify to the driver if such keys should be made accessible. This is
+     * only the case when <code>sql</code> is an insert statement.
+     * <p>
+     * An SQL statement which may have IN parameters can be stored and
+     * precompiled in a PreparedStatement. The PreparedStatement can then be
+     * used to execute the statement multiple times in an efficient way.
+     * <p>
+     * Subject to JDBC driver support, this operation will attempt to send the
+     * precompiled version of the statement to the database. Alternatively, if
+     * the driver is not capable of flowing precompiled statements, the
+     * statement will not reach the database server until it is executed. This
+     * will have a bearing on precisely when <code>SQLException</code>
+     * instances get raised.
+     * <p>
+     * By default, ResultSets from the returned object will be
+     * {@link ResultSet#TYPE_FORWARD_ONLY} type with a
+     * {@link ResultSet#CONCUR_READ_ONLY} mode of concurrency.
+     * 
+     * @param sql
+     *            the SQL statement.
+     * @param autoGeneratedKeys
+     *            one of :
+     *            <ul>
+     *            <li>{@link Statement#RETURN_GENERATED_KEYS}
+     *            <li>{@link Statement#NO_GENERATED_KEYS}
+     *            </ul>
+     * @return a new <code>PreparedStatement</code> instance representing the
+     *         input SQL statement.
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
+            throws SQLException;
+
+    /**
+     * Creates a default PreparedStatement that can retrieve the auto-generated
+     * keys designated by a supplied array. If <code>sql</code> is an SQL
+     * <code>INSERT</code> statement, parameter <code>columnIndexes</code>
+     * is expected to hold the index values for each column in the statement's
+     * intended database table containing the autogenerated-keys of interest.
+     * Otherwise <code>columnIndexes</code> is ignored.
+     * <p>
+     * Subject to JDBC driver support, this operation will attempt to send the
+     * precompiled version of the statement to the database. Alternatively, if
+     * the driver is not capable of flowing precompiled statements, the
+     * statement will not reach the database server until it is executed. This
+     * will have a bearing on precisely when <code>SQLException</code>
+     * instances get raised.
+     * <p>
+     * By default, ResultSets from the returned object will be
+     * {@link ResultSet#TYPE_FORWARD_ONLY} type with a
+     * {@link ResultSet#CONCUR_READ_ONLY} mode of concurrency.
+     * 
+     * @param sql
+     *            the SQL statement.
+     * @param columnIndexes
+     *            the indexes of the columns for which auto-generated keys
+     *            should be made available.
+     * @return the PreparedStatement containing the supplied SQL statement
+     * @throws SQLException
+     *             if a problem occurs accessing the database
+     */
+    public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
+            throws SQLException;
+
+    /**
+     * Creates a PreparedStatement that generates ResultSets with the specified
+     * values of <code>resultSetType</code> and
+     * <code>resultSetConcurrency</code>.
+     * 
+     * @param sql
+     *            the SQL statement. It can contain one or more '?' IN parameter
+     *            placeholders
+     * @param resultSetType
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}
+     *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}
+     *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}
+     *            </ul>
+     * @param resultSetConcurrency
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#CONCUR_READ_ONLY}
+     *            <li>{@link ResultSet#CONCUR_UPDATABLE}
+     *            </ul>
+     * @return a new instance of <code>PreparedStatement</code> containing the
+     *         SQL statement <code>sql</code>. <code>ResultSet</code>s
+     *         emitted from this <code>PreparedStatement</code> will satisfy
+     *         the specified <code>resultSetType</code> and
+     *         <code>resultSetConcurrency</code> values.
+     * @throws SQLException
+     *             if a problem occurs accessing the database
+     */
+    public PreparedStatement prepareStatement(String sql, int resultSetType,
+            int resultSetConcurrency) throws SQLException;
+
+    /**
+     * Creates a PreparedStatement that generates ResultSets with the specified
+     * type, concurrency and holdability
+     * 
+     * @param sql
+     *            the SQL statement. It can contain one or more '?' IN parameter
+     *            placeholders
+     * @param resultSetType
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}
+     *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}
+     *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}
+     *            </ul>
+     * @param resultSetConcurrency
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#CONCUR_READ_ONLY}
+     *            <li>{@link ResultSet#CONCUR_UPDATABLE}
+     *            </ul>
+     * @param resultSetHoldability
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT}
+     *            <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT}
+     *            </ul>
+     * 
+     * @return a new instance of <code>PreparedStatement</code> containing the
+     *         SQL statement <code>sql</code>. <code>ResultSet</code>s
+     *         emitted from this <code>PreparedStatement</code> will satisfy
+     *         the specified <code>resultSetType</code>,
+     *         <code>resultSetConcurrency</code> and
+     *         <code>resultSetHoldability</code> values.
+     * @throws SQLException
+     *             if a problem occurs accessing the database
+     */
+    public PreparedStatement prepareStatement(String sql, int resultSetType,
+            int resultSetConcurrency, int resultSetHoldability)
+            throws SQLException;
+
+    /**
+     * Creates a default PreparedStatement that can retrieve the auto-generated
+     * keys designated by a supplied array. If <code>sql</code> is an SQL
+     * <code>INSERT</code> statement, <code>columnNames</code> is expected
+     * to hold the names of each column in the statement's associated database
+     * table containing the autogenerated-keys of interest. Otherwise
+     * <code>columnNames</code> is ignored.
+     * <p>
+     * Subject to JDBC driver support, this operation will attempt to send the
+     * precompiled version of the statement to the database. Alternatively, if
+     * the driver is not capable of flowing precompiled statements, the
+     * statement will not reach the database server until it is executed. This
+     * will have a bearing on precisely when <code>SQLException</code>
+     * instances get raised.
+     * <p>
+     * By default, ResultSets from the returned object will be
+     * {@link ResultSet#TYPE_FORWARD_ONLY} type with a
+     * {@link ResultSet#CONCUR_READ_ONLY} mode of concurrency.
+     * 
+     * @param sql
+     *            the SQL statement.
+     * @param columnNames
+     *            the names of the columns for which auto-generated keys should
+     *            be made available.
+     * @return the PreparedStatement containing the supplied SQL statement
+     * @throws SQLException
+     *             if a problem occurs accessing the database
+     */
+    public PreparedStatement prepareStatement(String sql, String[] columnNames)
+            throws SQLException;
+
+    /**
+     * Releases <code>savepoint</code> from the present transaction. Once
+     * removed, the <code>Savepoint</code> is considered invalid and should
+     * not be referenced further.
+     * 
+     * @param savepoint
+     *            the object targeted for removal
+     * @throws SQLException
+     *             if there is a problem with accessing the database or if
+     *             <code>savepoint</code> is considered not valid in this
+     *             transaction.
+     */
+    public void releaseSavepoint(Savepoint savepoint) throws SQLException;
+
+    /**
+     * Rolls back all updates made so far in this transaction as well as
+     * relinquishing all acquired database locks. It is an error to invoke this
+     * operation when in auto-commit mode.
+     * 
+     * @throws SQLException
+     *             if there is a problem with the database or if the method is
+     *             called while in auto-commit mode of operation.
+     */
+    public void rollback() throws SQLException;
+
+    /**
+     * Undoes all changes made after the supplied Savepoint object was set. This
+     * method should only be used when auto-commit mode is disabled.
+     * 
+     * @param savepoint
+     *            the Savepoint to roll back to
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public void rollback(Savepoint savepoint) throws SQLException;
+
+    /**
+     * Sets this connection's auto-commit mode on or off.
+     * <p>
+     * Putting a Connection into auto-commit mode means that all associated SQL
+     * statements will be run and committed in their own separate transactions.
+     * Alternatively, auto-commit set to off means that associated SQL
+     * statements get grouped into transactions that need to be completed by
+     * explicit calls to either the {@link #commit()} or {@link #rollback()}
+     * methods.
+     * <p>
+     * Auto-commit is the default mode for new connection instances.
+     * <p>
+     * When in this mode, commits will automatically occur upon successful SQL
+     * statement completion or upon successful completion of an execute.
+     * Statements are not considered successfully complete until all associated
+     * <code>ResultSet</code>s and output parameters have been obtained or
+     * closed.
+     * <p>
+     * Calling this operation during an uncommitted transaction will result in
+     * it being committed.
+     * 
+     * @param autoCommit
+     *            boolean indication of whether to put the target connection
+     *            into auto-commit mode (<code>true</code>) or not (<code>false</code>)
+     * 
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public void setAutoCommit(boolean autoCommit) throws SQLException;
+
+    /**
+     * Sets the catalog name for this connection. This is used to select a
+     * subspace of the database for future work. If the driver does not support
+     * catalog names, this method is ignored.
+     * 
+     * @param catalog
+     *            the catalog name to use.
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public void setCatalog(String catalog) throws SQLException;
+
+    /**
+     * Sets the holdability of ResultSets created by this Connection.
+     * 
+     * @param holdability
+     *            one of :
+     *            <ul>
+     *            <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT}
+     *            <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT}
+     *            <li>
+     *            </ul>
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public void setHoldability(int holdability) throws SQLException;
+
+    /**
+     * Sets this connection to read-only mode.
+     * <p>
+     * This serves as a hint to the driver, which can enable database
+     * optimizations.
+     * 
+     * @param readOnly
+     *            true to set the Connection to read only mode. false disables
+     *            read-only mode
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public void setReadOnly(boolean readOnly) throws SQLException;
+
+    /**
+     * Creates an unnamed Savepoint in the current transaction.
+     * 
+     * @return a Savepoint object for this savepoint.
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public Savepoint setSavepoint() throws SQLException;
+
+    /**
+     * Creates a named Savepoint in the current transaction.
+     * 
+     * @param name
+     *            the name to use for the new Savepoint.
+     * @return a Savepoint object for this savepoint.
+     * @throws SQLException
+     *             if there is a problem accessing the database
+     */
+    public Savepoint setSavepoint(String name) throws SQLException;
+
+    /**
+     * Sets the transaction isolation level for this Connection.
+     * <p>
+     * If this method is called during a transaction, the results are
+     * implementation defined.
+     * 
+     * @param level
+     *            the new transaction isolation level to use from the following
+     *            list of possible values :
+     *            <ul>
+     *            <li>{@link #TRANSACTION_READ_COMMITTED}
+     *            <li>{@link #TRANSACTION_READ_UNCOMMITTED}
+     *            <li>{@link #TRANSACTION_REPEATABLE_READ}
+     *            <li>{@link #TRANSACTION_SERIALIZABLE}
+     *            </ul>
+     * @throws SQLException
+     *             if there is a problem with the database or if the value of
+     *             <code>level</code> is not one of the expected constant
+     *             values.
+     */
+    public void setTransactionIsolation(int level) throws SQLException;
+
+    /**
+     * Sets the <code>TypeMap</code> for this connection. The input
+     * <code>map</code> should contain mappings between complex Java and SQL
+     * types.
+     * 
+     * @param map
+     *            the new type map
+     * @throws SQLException
+     *             if there is a problem accessing the database or if
+     *             <code>map</code> is not an instance of {@link Map}.
+     */
+    public void setTypeMap(Map<String, Class<?>> map) throws SQLException;
+}

Modified: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/DataTruncation.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/DataTruncation.java?rev=413642&r1=413641&r2=413642&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/DataTruncation.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/DataTruncation.java Mon Jun 12 05:13:42 2006
@@ -11,94 +11,114 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-
-package java.sql;
-
-import java.io.Serializable;
-
-/**
- * An exception which is thrown when a JDBC driver unexpectedly truncates a data value either when
- * reading or when writing data.
- * 
- * The SQLState value for a <code>DataTruncation</code> is <code>01004</code>.
- * 
- */
-public class DataTruncation extends SQLWarning implements Serializable{
-	
-	private static final long serialVersionUID = 6464298989504059473L;
-
-	private int 	theIndex 		= 0;
-	private boolean	parameterFlag	= false;
-	private boolean readFlag		= false;
-	private int		dataSize		= 0;
-	private int		transferSize	= 0;
-
-	private static final String THE_REASON		= "Data truncation"; //$NON-NLS-1$
-	private static final String THE_SQLSTATE 	= "01004"; //$NON-NLS-1$
-	private static final int 	THE_ERROR_CODE	= 0;
-	/**
-	 * Creates a DataTruncation.  The Reason is set to "Data truncation", the ErrorCode is set
-	 * to the SQLException default value and other fields are set to the values supplied on this
-	 * method.
-	 * @param index the Index value of the column value or parameter that was truncated
-	 * @param parameter true if it was a Parameter value that was truncated, false otherwise
-	 * @param read true if the truncation occurred on a read operation, false otherwise
-	 * @param dataSize the original size of the truncated data
-	 * @param transferSize the size of the data after truncation
-	 */
-	public DataTruncation(int index, boolean parameter, boolean read, int dataSize, int transferSize) {
-		super( THE_REASON, THE_SQLSTATE, THE_ERROR_CODE );
-		this.theIndex 		= index;
-		this.parameterFlag 	= parameter;
-		this.readFlag		= read;
-		this.dataSize		= dataSize;
-		this.transferSize	= transferSize;
-	} // end method DataTruncation( int, boolean, int, int )
-	
-	/**
-	 * Gets the number of bytes of data that should have been read/written.
-	 * @return the number of bytes that should have been read or written.  The value may be set
-	 * to -1 if the size is unknown.
-	 */
-	public int 	getDataSize() {
-		return dataSize;	
-	} // end method getDataSize()
-    
-	/**
-	 * Gets the index of the column or of the parameter that was truncated.
-	 * @return the index number of the column or of the parameter.
-	 */
-	public int 	getIndex() {
-		return theIndex;
-	} // end method getIndex()
-    
-	/**
-	 * Gets whether the value truncated was a parameter value or a column value.
-	 * @return true if the value truncated was a Parameter value, false if it was a column value
-	 */
-	public boolean 	getParameter() {
-		return parameterFlag;
-	} // end method getParameter()
-    
-	/**
-	 * Gets whether the value was truncated on a read operation or a write operation
-	 * @return true if the value was truncated on a read operation, false otherwise.
-	 */
-	public boolean 	getRead() {
-		return readFlag;
-	} // end method getRead()
-    
-	/**
-	 * Gets the number of bytes of data that was actually read or written
-	 * @return the number of bytes actually read/written.  The value may be set to -1 if the size 
-	 * is unknown.
-	 */
-	public int 	getTransferSize() {
-		return transferSize;
-	} // end method getTransferSize()
-
-} // end class DataTruncation
-
-
+ */
+
+package java.sql;
+
+import java.io.Serializable;
+
+/**
+ * An exception which is thrown when a JDBC driver unexpectedly truncates a data
+ * value either when reading or when writing data.
+ * 
+ * The SQLState value for a <code>DataTruncation</code> is <code>01004</code>.
+ */
+public class DataTruncation extends SQLWarning implements Serializable {
+
+    private static final long serialVersionUID = 6464298989504059473L;
+
+    private int theIndex = 0;
+
+    private boolean parameterFlag = false;
+
+    private boolean readFlag = false;
+
+    private int dataSize = 0;
+
+    private int transferSize = 0;
+
+    private static final String THE_REASON = "Data truncation"; //$NON-NLS-1$
+
+    private static final String THE_SQLSTATE = "01004"; //$NON-NLS-1$
+
+    private static final int THE_ERROR_CODE = 0;
+
+    /**
+     * Creates a DataTruncation. The Reason is set to "Data truncation", the
+     * ErrorCode is set to the SQLException default value and other fields are
+     * set to the values supplied on this method.
+     * 
+     * @param index
+     *            the Index value of the column value or parameter that was
+     *            truncated
+     * @param parameter
+     *            true if it was a Parameter value that was truncated, false
+     *            otherwise
+     * @param read
+     *            true if the truncation occurred on a read operation, false
+     *            otherwise
+     * @param dataSize
+     *            the original size of the truncated data
+     * @param transferSize
+     *            the size of the data after truncation
+     */
+    public DataTruncation(int index, boolean parameter, boolean read,
+            int dataSize, int transferSize) {
+        super(THE_REASON, THE_SQLSTATE, THE_ERROR_CODE);
+        this.theIndex = index;
+        this.parameterFlag = parameter;
+        this.readFlag = read;
+        this.dataSize = dataSize;
+        this.transferSize = transferSize;
+    }
+
+    /**
+     * Gets the number of bytes of data that should have been read/written.
+     * 
+     * @return the number of bytes that should have been read or written. The
+     *         value may be set to -1 if the size is unknown.
+     */
+    public int getDataSize() {
+        return dataSize;
+    }
+
+    /**
+     * Gets the index of the column or of the parameter that was truncated.
+     * 
+     * @return the index number of the column or of the parameter.
+     */
+    public int getIndex() {
+        return theIndex;
+    }
+
+    /**
+     * Gets whether the value truncated was a parameter value or a column value.
+     * 
+     * @return true if the value truncated was a Parameter value, false if it
+     *         was a column value
+     */
+    public boolean getParameter() {
+        return parameterFlag;
+    }
+
+    /**
+     * Gets whether the value was truncated on a read operation or a write
+     * operation
+     * 
+     * @return true if the value was truncated on a read operation, false
+     *         otherwise.
+     */
+    public boolean getRead() {
+        return readFlag;
+    }
+
+    /**
+     * Gets the number of bytes of data that was actually read or written
+     * 
+     * @return the number of bytes actually read/written. The value may be set
+     *         to -1 if the size is unknown.
+     */
+    public int getTransferSize() {
+        return transferSize;
+    }
+}



Mime
View raw message