harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r386087 [39/45] - in /incubator/harmony/enhanced/classlib/trunk: make/ make/patternsets/ modules/jndi/ modules/jndi/META-INF/ modules/jndi/make/ modules/jndi/make/common/ modules/jndi/src/ modules/jndi/src/main/ modules/jndi/src/main/java/ ...
Date Wed, 15 Mar 2006 14:57:17 GMT
Added: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLInput.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLInput.java?rev=386087&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLInput.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLInput.java Wed Mar 15 06:55:38 2006
@@ -0,0 +1,281 @@
+/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * 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.math.BigDecimal;
+import java.io.Reader;
+import java.io.InputStream;
+import java.net.URL;
+
+/**
+ * The SQLInput interface defines operations which apply to a type of input
+ * stream which carries a series of values which represent an instance of an SQL
+ * structured type or SQL distinct type.
+ * <p>
+ * SQLInput interface is used for custom mapping of SQL User Defined Types
+ * (UDTs)to Java classes. It is used by JDBC drivers below the level of the
+ * public interfaces and application programs do not normally use the SQLInput
+ * methods directly. Reader methods such as readLong and readBytes provide means
+ * to read values from an SQLInput stream.
+ * <p>
+ * When the getObject method is called with an object which implements the
+ * SQLData interface, the JDBC driver determines the SQL type of the UDT being
+ * mapped by caling the SQLData.getSQLType method. The driver creates an
+ * instance of an SQLInput stream, filling the stream with the attributes of the
+ * UDT. The SQLInput stream is passed to the SQLData.readSQL method which then
+ * calls the SQLInput reader methods to read the attributes.
+ * 
+ */
+public interface SQLInput {
+
+	/**
+	 * Returns the next attribute in the stream in the form of a String.
+	 * 
+	 * @return the next attribute as a String. null if the value is SQL NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public String readString() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a boolean.
+	 * 
+	 * @return the next attribute as a boolean. false if the value is SQL NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public boolean readBoolean() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a byte.
+	 * 
+	 * @return the next attribute as a byte. 0 if the value is SQL NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public byte readByte() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a short.
+	 * 
+	 * @return the next attribute as a short. 0 if the value is SQL NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public short readShort() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of an int.
+	 * 
+	 * @return the next attribute as an int. 0 if the value is SQL NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public int readInt() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a long.
+	 * 
+	 * @return the next attribute as a long. 0 if the value is SQL NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public long readLong() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a float.
+	 * 
+	 * @return the next attribute as a float. 0 if the value is SQL NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public float readFloat() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a double.
+	 * 
+	 * @return the next attribute as a double. 0 if the value is SQL NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public double readDouble() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a
+	 * java.math.BigDecimal.
+	 * 
+	 * @return the attribute as a java.math.BigDecimal. null if the read returns
+	 *         SQL NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public BigDecimal readBigDecimal() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a byte array.
+	 * 
+	 * @return the attribute as a byte array. null if the read returns SQL NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public byte[] readBytes() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a java.sql.Date.
+	 * 
+	 * @return the next attribute as a java.sql.Date. null if the value is SQL
+	 *         NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public Date readDate() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a java.sql.Time.
+	 * 
+	 * @return the attribute as a java.sql.Time. null if the read returns SQL
+	 *         NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public Time readTime() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a
+	 * java.sql.Timestamp.
+	 * 
+	 * @return the attribute as a java.sql.Timestamp. null if the read returns
+	 *         SQL NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public Timestamp readTimestamp() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a Unicode
+	 * character stream embodied as a java.io.Reader.
+	 * 
+	 * @return the next attribute as a java.io.Reader. null if the value is SQL
+	 *         NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public Reader readCharacterStream() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of an ASCII
+	 * character stream embodied as a java.io.InputStream.
+	 * 
+	 * @return the next attribute as a java.io.InputStream. null if the value is
+	 *         SQL NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public InputStream readAsciiStream() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a stream of bytes
+	 * embodied as a java.io.InputStream.
+	 * 
+	 * @return the next attribute as a java.io.InputStream. null if the value is
+	 *         SQL NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public InputStream readBinaryStream() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a
+	 * java.lang.Object.
+	 * <p>
+	 * The type of the Object returned is determined by the type mapping for
+	 * this JDBC driver, including any customized mappings in force. A type map
+	 * is given to the SQLInput by the JDBC driver before the SQLInput is given
+	 * to the application.
+	 * <p>
+	 * If the attribute is an SQL structured or distinct type, its SQL type is
+	 * determined. If the streams type map contains an element for that SQL
+	 * type, the driver creates an object of relevant type and invokes the
+	 * method SQLData.readSQL on it, which reads supplementary data from the
+	 * stream using whichever protocol is defined for that method.
+	 * 
+	 * @return the next attribute as an Object. null if the value is SQL NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public Object readObject() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a java.sql.Ref.
+	 * 
+	 * @return the next attribute as a java.sql.Ref. null if the value is SQL
+	 *         NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public Ref readRef() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a java.sql.Blob.
+	 * 
+	 * @return the next attribute as a java.sql.Blob. null if the value is SQL
+	 *         NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public Blob readBlob() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a java.sql.Clob.
+	 * 
+	 * @return the next attribute as a java.sql.Clob. null if the value is SQL
+	 *         NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public Clob readClob() throws SQLException;
+
+	/**
+	 * Returns the next attribute in the stream in the form of a java.sql.Array.
+	 * 
+	 * @return the next attribute as an Array. null if the value is SQL NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public Array readArray() throws SQLException;
+
+	/**
+	 * Reports whether the last value read was SQL NULL.
+	 * 
+	 * @return true if the last value read was SQL NULL, false otherwise.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public boolean wasNull() throws SQLException;
+
+	/**
+	 * Reads the next attribute in the stream (SQL DATALINK value) and returns
+	 * it as a java.net.URL object.
+	 * 
+	 * @return the next attribute as a java.net.URL. null if the value is SQL
+	 *         NULL.
+	 * @throws SQLException
+	 *             if there is a database error
+	 */
+	public URL readURL() throws SQLException;
+
+} // end interface SQLInput
+

Added: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLOutput.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLOutput.java?rev=386087&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLOutput.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLOutput.java Wed Mar 15 06:55:38 2006
@@ -0,0 +1,208 @@
+/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * 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.math.BigDecimal;
+import java.io.Reader;
+import java.io.InputStream;
+import java.net.URL;
+
+/**
+ * The interface for an output stream used to write attributes of an SQL User Defined Type to
+ * the database.  This interface is used for custom mapping of types and is called by the JDBC
+ * driver.  It is not expected that this interface is used by applications.
+ * <p>
+ * When an object which implements the SQLData interface is used as an argument to an SQL statement,
+ * the JDBC driver calls the method <code>SQLData.getSQLType</code> to establish the type of the
+ * SQL UDT that is being passed.  The driver then creates an SQLOutput stream and passes it to the
+ * <code>SQLData.writeSQL</code> method, which in turn uses the appropriate SQLOutput writer methods
+ * to write the data from the SQLData object into the stream according to the defined mapping. 
+ * 
+ */
+public interface SQLOutput {
+	
+	/**
+	 * Write a String value into the output stream.
+	 * @param theString the String to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeString(String theString) throws SQLException;
+	
+	/**
+	 * Write a boolean value into the output stream.
+	 * @param theFlag the boolean value to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeBoolean(boolean theFlag) throws SQLException;
+	
+	/**
+	 * Write a byte value into the output stream.
+	 * @param theByte the byte value to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeByte(byte theByte) throws SQLException;
+	
+	/**
+	 * Write a short value into the output stream.
+	 * @param theShort the short value to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeShort(short theShort) throws SQLException;
+	
+	/**
+	 * Write an int value into the output stream.
+	 * @param theInt the int value to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeInt(int theInt) throws SQLException;
+	
+	/**
+	 * Write a long value into the output stream.
+	 * @param theLong the long value to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeLong(long theLong) throws SQLException;
+	
+	/**
+	 * Write a float value into the output stream.
+	 * @param theFloat the float value to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeFloat(float theFloat) throws SQLException;
+	
+	/**
+	 * Write a double value into the output stream.
+	 * @param theDouble the double value to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeDouble(double theDouble) throws SQLException;
+	
+	/**
+	 * Write a java.math.BigDecimal value into the output stream.
+	 * @param theBigDecimal the BigDecimal value to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeBigDecimal(BigDecimal theBigDecimal) throws SQLException;
+	
+	/**
+	 * Write an array of bytes into the output stream.
+	 * @param theBytes the array of bytes to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeBytes(byte[] theBytes) throws SQLException;
+	
+	/**
+	 * Write a java.sql.Date value into the output stream.
+	 * @param theDate the Date value to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeDate(Date theDate) throws SQLException;
+	
+	/**
+	 * Write a java.sql.Time value into the output stream.
+	 * @param theTime the Time value to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeTime(Time theTime) throws SQLException;
+	
+	/**
+	 * Write a java.sql.Timestamp value into the output stream.
+	 * @param theTimestamp the Timestamp value to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeTimestamp(Timestamp theTimestamp) throws SQLException;
+	
+	/**
+	 * Write a stream of Unicode characters into the output stream.
+	 * @param theStream the stream of Unicode characters to write, as a java.io.Reader object
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeCharacterStream(Reader theStream) throws SQLException;
+	
+	/**
+	 * Write a stream of ASCII characters into the output stream.
+	 * @param theStream the stream of ASCII characters to write, as a java.io.InputStream object
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeAsciiStream(InputStream theStream) throws SQLException;
+	
+	/**
+	 * Write a stream of uninterpreted bytes into the output stream.
+	 * @param theStream the stream of bytes to write, as a java.io.InputStream object
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeBinaryStream(InputStream theStream) throws SQLException;
+	
+	/**
+	 * Write an SQLData object into the output stream.
+	 * <p>
+	 * If the SQLData object is null, writes SQL NULL to the stream.
+	 * <p>
+	 * Otherwise, calls the <code>SQLData.writeSQL</code> method of the object, which
+	 * writes the object's attributes to the stream by calling the appropriate SQLOutput writer
+	 * methods for each attribute, in order.  The order of the attributes is the order they are
+	 * listed in the SQL definition of the User Defined Type.
+	 * @param theObject the SQLData object to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeObject(SQLData theObject) throws SQLException;
+	
+	/**
+	 * Write an SQL Ref value into the output stream.
+	 * @param theRef the java.sql.Ref object to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeRef(Ref theRef) throws SQLException;
+	
+	/**
+	 * Write an SQL Blob value into the output stream.
+	 * @param theBlob the java.sql.Blob object to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeBlob(Blob theBlob) throws SQLException;
+	
+	/**
+	 * Write an SQL Clob value into the output stream.
+	 * @param theClob the java.sql.Clob object to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeClob(Clob theClob) throws SQLException;
+	
+	/**
+	 * Write an SQL Struct value into the output stream.
+	 * @param theStruct the java.sql.Struct object to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeStruct(Struct theStruct) throws SQLException;
+	
+	/**
+	 * Write an SQL Array value into the output stream.
+	 * @param theArray the java.sql.Array object to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeArray(Array theArray) throws SQLException;
+	
+	/**
+	 * Write an SQL DATALINK value into the output stream.
+	 * @param theURL the Datalink value as a java.net.URL to write
+	 * @throws SQLException if a database error occurs
+	 */
+	public void writeURL(URL theURL) throws SQLException;
+	
+} // end interface SQLOutput
+
+

Added: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLPermission.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLPermission.java?rev=386087&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLPermission.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLPermission.java Wed Mar 15 06:55:38 2006
@@ -0,0 +1,56 @@
+/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * 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.security.BasicPermission;
+import java.security.Guard;
+import java.io.Serializable;
+
+/**
+ * Permission relating to security access control in the java.sql package.
+ * <p>
+ * Currently, the only permission supported has the name "setLog".  The setLog permission
+ * controls whether a Java application or applet can open a logging stream using the 
+ * DriverManager.setLogWriter method or the DriverManager.setLogStream method.  This is a
+ * potentially dangerous operation since the logging stream can contain usernames, passwords 
+ */
+public final class SQLPermission extends BasicPermission implements Guard, Serializable {
+	
+	private static final long serialVersionUID = -1439323187199563495L;
+
+	/**
+	 * Creates a new SQLPermission object with the specified name.
+	 * @param name the name to use for this SQLPermission
+	 */
+	public SQLPermission(String name) {
+		super( name );
+		//if (name != "setLog") throw new IllegalArgumentException();	
+	} // end method SQLPermissions( String )
+    
+	/**
+	 * Creates a new SQLPermission object with the specified name.
+	 * @param name is the name of the SQLPermission.  Currently only "setLog" is allowed.
+	 * @param actions is currently unused and should be set to null
+	 */
+	public SQLPermission(String name, String actions) {
+    	super( name, null );
+    	//if (name != "setLog") throw new IllegalArgumentException(); 
+    } // end method SQLPermissions( String, String )
+    
+} // end class SQLPermission
+
+

Added: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLWarning.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLWarning.java?rev=386087&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLWarning.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/SQLWarning.java Wed Mar 15 06:55:38 2006
@@ -0,0 +1,93 @@
+/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * 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 class that holds information about Database access warnings.
+ * 
+ */
+public class SQLWarning extends SQLException implements Serializable {
+	
+	private static final long serialVersionUID = 3917336774604784856L;
+	
+	private SQLWarning chainedWarning = null;
+
+	/** 
+	 * Creates an SQLWarning object.
+	 * The Reason string is set to null, the SQLState string is set to null and the Error Code is set
+	 * to 0.
+	 */
+	public SQLWarning() {
+		super();
+	} // end method SQLWarning()
+
+	/**
+	 * Creates an SQLWarning object.
+	 * The Reason string is set to the given reason string, the SQLState string is set to null and the
+	 * Error Code is set to 0.
+	 * @param theReason
+	 */
+	public SQLWarning(String theReason) {
+		super(theReason);
+	} // end method SQLWarning( String )
+
+	/**
+	 * Creates an SQLWarning object.
+	 * The Reason string is set to the given reason string, the SQLState string is set to the given
+	 * SQLState string and the Error Code is set to 0.
+	 * @param theReason the string to use as the Reason string
+	 * @param theSQLState the string to use as the SQLState string
+	 */
+	public SQLWarning(String theReason, String theSQLState) {
+		super(theReason, theSQLState);
+	} // end method SQLWarning( String, String )
+
+	/**
+	 * Creates an SQLWarning object.
+	 * The Reason string is set to the given reason string, the SQLState string is set to the given
+	 * SQLState string and the Error Code is set to the given ErrorCode value.
+	 * @param theReason
+	 * @param theSQLState
+	 * @param theErrorCode
+	 */
+	public SQLWarning(String theReason, String theSQLState, int theErrorCode) {
+		super(theReason, theSQLState, theErrorCode);
+	} // end method SQLWarning( String, String, int )
+	
+	/**
+	 * Gets the SQLWarning chained to this SQLWarning object.
+	 * @return the SQLWarning chained to this SQLWarning.  null if no SQLWarning is
+	 * chained to this SQLWarning.
+	 */
+	public SQLWarning 	getNextWarning() {
+		return chainedWarning;
+	} // end method getNextWarning()
+	
+    /**
+     * Chains a supplied SQLWarning to this SQLWarning.
+     * @param w the SQLWarning to chain to this SQLWarning.
+     */ 
+	public void setNextWarning(SQLWarning w) {
+		chainedWarning = w;
+		return;
+	} // end method setNextWarning( SQLWarning )
+  
+} // end class SQLWarning
+
+

Added: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Savepoint.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Savepoint.java?rev=386087&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Savepoint.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Savepoint.java Wed Mar 15 06:55:38 2006
@@ -0,0 +1,44 @@
+/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * 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;
+
+/**
+ * A Savepoint is an instant during the current transaction that can be utilised by a 
+ * Rollback from the Connection.rollback method. Rolling back to a particular Savepoint means
+ * that all changes that occurred after that Savepoint are removed.
+ * 
+ */
+public interface Savepoint {
+
+	/**
+	 * Returns the constructed ID for this Savepoint.
+	 * @return the ID for this Savepoint.
+	 * @throws SQLException
+	 */
+	public int getSavepointId() throws SQLException;
+
+	/**
+	 * Returns the name for this Savepoint.
+	 * 
+	 * @return the name of this Savepoint.
+	 * @throws SQLException
+	 */
+	public String 	getSavepointName() throws SQLException;
+    	
+} // end interface Savepoint
+
+

Added: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Statement.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Statement.java?rev=386087&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Statement.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Statement.java Wed Mar 15 06:55:38 2006
@@ -0,0 +1,621 @@
+/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * 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;
+
+/**
+ * Interface used for executing static SQL statements and returning their
+ * results.
+ * 
+ * By default, an object implementing the Statement interface can returns
+ * results as ResultSets. For any given Statement object, only one ResultSet can
+ * be open at one time. A call to any of the execution methods of Statement will
+ * cause any previously created ResultSet object for that Statement to be closed
+ * implicitly.
+ * <p>
+ * To have multiple ResultSet objects open concurrently, multiple Statement
+ * objects must be used.
+ * 
+ */
+public interface Statement {
+
+	/**
+	 * Passing this constant to getMoreResults implies that all ResultSet
+	 * objects previously kept open should be closed.
+	 */
+	public static final int CLOSE_ALL_RESULTS = 3;
+
+	/**
+	 * Passing this constant to getMoreResults implies that the current
+	 * ResultSet object should be closed
+	 */
+	public static final int CLOSE_CURRENT_RESULT = 1;
+
+	/**
+	 * Indicates that an error was encountered during execution of a batch
+	 * statement.
+	 */
+	public static final int EXECUTE_FAILED = -3;
+
+	/**
+	 * Passing this constant to getMoreResults implies that the current
+	 * ResultSet object should not be closed.
+	 */
+	public static final int KEEP_CURRENT_RESULT = 2;
+
+	/**
+	 * Indicates that generated keys should not be accessible for retrieval.
+	 */
+	public static final int NO_GENERATED_KEYS = 2;
+
+	/**
+	 * Indicates that generated keys should be accessible for retrieval.
+	 */
+	public static final int RETURN_GENERATED_KEYS = 1;
+
+	/**
+	 * Indicates that a batch statement was executed with a successful result,
+	 * but a count of the number of rows it affected is unavailable.
+	 */
+	public static final int SUCCESS_NO_INFO = -2;
+
+	/**
+	 * Adds a specified SQL commands to the list of commands for this Statement.
+	 * <p>
+	 * The list of commands is executed by invoking the
+	 * <code>executeBatch</code> method.
+	 * 
+	 * @param sql
+	 *            the SQL command as a String. Typically an INSERT or UPDATE
+	 *            statement.
+	 * @throws SQLException
+	 *             if an error occurs accessing the database or the database
+	 *             does not support batch updates
+	 */
+	public void addBatch(String sql) throws SQLException;
+
+	/**
+	 * Cancels this Statement execution if both the database and the JDBC driver
+	 * support aborting an SQL statement in flight. This method can be used by
+	 * one thread to stop a Statement that is being executed on another thread.
+	 * 
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public void cancel() throws SQLException;
+
+	/**
+	 * Clears the current list of SQL commands for this Statement.
+	 * 
+	 * @throws SQLException
+	 *             if an error occurs accessing the database or the database
+	 *             does not support batch updates
+	 */
+	public void clearBatch() throws SQLException;
+
+	/**
+	 * Clears all SQLWarnings from this Statement.
+	 * 
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public void clearWarnings() throws SQLException;
+
+	/**
+	 * Releases this Statement's database and JDBC driver resources.
+	 * <p>
+	 * Using this method to release these resources as soon as possible is
+	 * strongly recommended. It is not a good idea to rely on these resources
+	 * being released when the Statement object is finalized during garbage
+	 * collection. Doing so can result in unpredictable performance
+	 * characteristics for the application.
+	 * 
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public void close() throws SQLException;
+
+	/**
+	 * Executes a supplied SQL statement. This may return multiple ResultSets.
+	 * <p>
+	 * Use the <code>getResultSet</code> or <code>getUpdateCount</code>
+	 * methods to get the first result and <code>getMoreResults</code> to get
+	 * any subsequent results.
+	 * 
+	 * @param sql
+	 *            the SQL statement to execute
+	 * @return true if the first result is a ResultSet, false if the first
+	 *         result is an update count or if there is no result
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public boolean execute(String sql) throws SQLException;
+
+	/**
+	 * Executes a supplied SQL statement. This may return multiple ResultSets.
+	 * This method allows control of whether auto-generated Keys should be made
+	 * available for retrieval, if the SQL statement is an INSERT statement.
+	 * <p>
+	 * Use the <code>getResultSet</code> or <code>getUpdateCount</code>
+	 * methods to get the first result and <code>getMoreResults</code> to get
+	 * any subsequent results.
+	 * 
+	 * @param sql
+	 *            the SQL statement to execute
+	 * @param autoGeneratedKeys
+	 *            a flag indicating whether to make auto generated keys
+	 *            available for retrieval. This parameter must be one of
+	 *            Statement.NO_GENERATED_KEYS or Statement.RETURN_GENERATED_KEYS
+	 * @return true if results exists and the first result is a ResultSet, false
+	 *         if the first result is an update count or if there is no result
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public boolean execute(String sql, int autoGeneratedKeys)
+			throws SQLException;
+
+	/**
+	 * Executes the supplied SQL statement. This may return multiple ResultSets.
+	 * This method allows retrieval of auto generated keys specified by the
+	 * supplied array of column indexes, if the SQL statement is an INSERT
+	 * statement.
+	 * <p>
+	 * Use the <code>getResultSet</code> or <code>getUpdateCount</code>
+	 * methods to get the first result and <code>getMoreResults</code> to get
+	 * any subsequent results.
+	 * 
+	 * @param sql
+	 *            the SQL statement to execute
+	 * @param columnIndexes
+	 *            an array of indexes of the columns in the inserted row which
+	 *            should be made available for retrieval via the
+	 *            <code>getGeneratedKeys</code> method.
+	 * @return true if the first result is a ResultSet, false if the first
+	 *         result is an update count or if there is no result
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public boolean execute(String sql, int[] columnIndexes) throws SQLException;
+
+	/**
+	 * Executes the supplied SQL statement. This may return multiple ResultSets.
+	 * This method allows retrieval of auto generated keys specified by the
+	 * supplied array of column indexes, if the SQL statement is an INSERT
+	 * statement.
+	 * <p>
+	 * Use the <code>getResultSet</code> or <code>getUpdateCount</code>
+	 * methods to get the first result and <code>getMoreResults</code> to get
+	 * any subsequent results.
+	 * 
+	 * @param sql
+	 *            the SQL statement to execute
+	 * @param columnNames
+	 *            an array of column names in the inserted row which should be
+	 *            made available for retrieval via the
+	 *            <code>getGeneratedKeys</code> method.
+	 * @return true if the first result is a ResultSet, false if the first
+	 *         result is an update count or if there is no result
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public boolean execute(String sql, String[] columnNames)
+			throws SQLException;
+
+	/**
+	 * Submits a batch of SQL commands to the database. Returns an array of
+	 * update counts, if all the commands execute successfully.
+	 * <p>
+	 * If one of the commands in the batch fails, this method can throw a
+	 * BatchUpdateException and the JDBC driver may or may not process the
+	 * remaining commands. The JDBC driver must behave consistently with the
+	 * underlying database, either always continuing or never continuing. If the
+	 * driver continues processing, the array of results returned contains the
+	 * same number of elements as there are commands in the batch, with a
+	 * minimum of one of the elements having the EXECUTE_FAILED value.
+	 * 
+	 * @return an array of update counts, with one entry for each command in the
+	 *         batch. The elements are ordered according to the order in which
+	 *         the commands were added to the batch.
+	 *         <p>
+	 *         <ol>
+	 *         <li> If the value of an element is >=0, the corresponding command
+	 *         completed successfully and the value is the update count for that
+	 *         command, which is the number of rows in the database affected by
+	 *         the command.</li>
+	 *         <li> If the value is SUCCESS_NO_INFO, the command completed
+	 *         successfully but the number of rows affected is unknown.
+	 *         <li>
+	 *         <li> If the value is EXECUTE_FAILED, the command failed.
+	 *         </ol>
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public int[] executeBatch() throws SQLException;
+
+	/**
+	 * Executes a supplied SQL statement. Returns a single ResultSet.
+	 * 
+	 * @param sql
+	 *            an SQL statement to execute. Typically a SELECT statement
+	 * @return a ResultSet containing the data produced by the SQL statement.
+	 *         Never null.
+	 * @throws SQLException
+	 *             if an error occurs accessing the database or if the statement
+	 *             produces anything other than a single ResultSet
+	 */
+	public ResultSet executeQuery(String sql) throws SQLException;
+
+	/**
+	 * Executes the supplied SQL statement. The statement may be an INSERT,
+	 * UPDATE or DELETE statement or a statement which returns nothing.
+	 * 
+	 * @param sql
+	 *            an SQL statement to execute - an SQL INSERT, UPDATE, DELETE or
+	 *            a statement which returns nothing
+	 * @return the count of updated rows, or 0 for a statement that returns
+	 *         nothing.
+	 * @throws SQLException
+	 *             if an error occurs accessing the database or if the statement
+	 *             produces a ResultSet
+	 */
+	public int executeUpdate(String sql) throws SQLException;
+
+	/**
+	 * Executes the supplied SQL statement. This method allows control of
+	 * whether auto-generated Keys should be made available for retrieval.
+	 * 
+	 * @param sql
+	 *            an SQL statement to execute - an SQL INSERT, UPDATE, DELETE or
+	 *            a statement which does not return anything.
+	 * @param autoGeneratedKeys
+	 *            a flag that indicates whether to allow retrieval of auto
+	 *            generated keys. Parameter must be one of
+	 *            Statement.RETURN_GENERATED_KEYS or Statement.NO_GENERATED_KEYS
+	 * @return the number of updated rows, or 0 if the statement returns
+	 *         nothing.
+	 * @throws SQLException
+	 *             if an error occurs accessing the database or if the statement
+	 *             produces a ResultSet
+	 */
+	public int executeUpdate(String sql, int autoGeneratedKeys)
+			throws SQLException;
+
+	/**
+	 * Executes the supplied SQL statement. This method allows retrieval of auto
+	 * generated keys specified by the supplied array of column indexes.
+	 * 
+	 * @param sql
+	 *            an SQL statement to execute - an SQL INSERT, UPDATE, DELETE or
+	 *            a statement which returns nothing
+	 * @param columnIndexes
+	 *            an array of indexes of the columns in the inserted row which
+	 *            should be made available for retrieval via the
+	 *            <code>getGeneratedKeys</code> method.
+	 * @return the count of updated rows, or 0 for a statement that returns
+	 *         nothing.
+	 * @throws SQLException
+	 *             if an error occurs accessing the database or if the statement
+	 *             produces a ResultSet
+	 */
+	public int executeUpdate(String sql, int[] columnIndexes)
+			throws SQLException;
+
+	/**
+	 * Executes the supplied SQL statement. This method allows retrieval of auto
+	 * generated keys specified by the supplied array of column names.
+	 * 
+	 * @param sql
+	 *            an SQL statement to execute - an SQL INSERT, UPDATE, DELETE or
+	 *            a statement which returns nothing
+	 * @param columnNames
+	 *            an array of column names in the inserted row which should be
+	 *            made available for retrieval via the
+	 *            <code>getGeneratedKeys</code> method.
+	 * @return the count of updated rows, or 0 for a statement that returns
+	 *         nothing.
+	 * @throws SQLException
+	 *             if an error occurs accessing the database or if the statement
+	 *             produces a ResultSet
+	 */
+	public int executeUpdate(String sql, String[] columnNames)
+			throws SQLException;
+
+	/**
+	 * Gets the Connection that produced this Statement.
+	 * 
+	 * @return the Connection
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public Connection getConnection() throws SQLException;
+
+	/**
+	 * Gets the default direction for fetching rows for ResultSets generated
+	 * from this Statement.
+	 * 
+	 * @return an integer describing the default fetch direction, one of:
+	 *         ResultSet.FETCH_FORWARD, ResultSet.FETCH_REVERSE,
+	 *         ResultSet.FETCH_UNKNOWN
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public int getFetchDirection() throws SQLException;
+
+	/**
+	 * Gets the default number of rows for a fetch for the ResultSet objects
+	 * returned from this Statement.
+	 * 
+	 * @return the default fetch size for ResultSets produced by this Statement
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public int getFetchSize() throws SQLException;
+
+	/**
+	 * Returns auto generated keys created by executing this Statement.
+	 * 
+	 * @return a ResultSet containing the auto generated keys - empty if no keys
+	 *         were generated by the Statement
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public ResultSet getGeneratedKeys() throws SQLException;
+
+	/**
+	 * Gets the maximum number of bytes which can be returned for values from
+	 * Character and Binary values in a ResultSet derived from this Statement.
+	 * This limit applies to BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR,
+	 * and LONGVARCHAR types. Any data exceeding the maximum size is abandoned
+	 * without announcement.
+	 * 
+	 * @return the current size limit, where 0 means that there is no limit
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public int getMaxFieldSize() throws SQLException;
+
+	/**
+	 * Gets the maximum number of rows that a ResultSet can contain when
+	 * produced from this Statement. If the limit is exceeded, the excess rows
+	 * are discarded silently.
+	 * 
+	 * @return the current row limit, where 0 means that there is no limit.
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public int getMaxRows() throws SQLException;
+
+	/**
+	 * Moves to this Statement's next result. Returns true if it is a ResultSet.
+	 * Any current ResultSet objects previously obtained with
+	 * <code>getResultSet()</code> are closed implicitly.
+	 * 
+	 * @return true if the next result is a ResultSet, false if the next result
+	 *         is not a ResultSet or if there are no more results. Note that if
+	 *         there is no more data, this method will return false and
+	 *         <code>getUpdateCount</code> will return -1.
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public boolean getMoreResults() throws SQLException;
+
+	/**
+	 * Moves to this Statement's next result. Returns true if the next result is
+	 * a ResultSet. Any current ResultSet objects previously obtained with
+	 * <code>getResultSet()</code> are handled as indicated by a supplied Flag
+	 * parameter.
+	 * 
+	 * @param current
+	 *            a flag indicating what to do with existing ResultSets. This
+	 *            parameter must be one of Statement.CLOSE_ALL_RESULTS,
+	 *            Statement.CLOSE_CURRENT_RESULT or
+	 *            Statement.KEEP_CURRENT_RESULT.
+	 * @return true if the next result exists and is a ResultSet, false if the
+	 *         next result is not a ResultSet or if there are no more results.
+	 *         Note that if there is no more data, this method will return false
+	 *         and <code>getUpdateCount</code> will return -1.
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public boolean getMoreResults(int current) throws SQLException;
+
+	/**
+	 * Gets the timeout value for Statement execution. The JDBC driver will wait
+	 * up to this value for the execution to complete - after the limit is
+	 * exceeded an SQL Exception is thrown.
+	 * 
+	 * @return the current Query Timeout value, where 0 indicates that there is
+	 *         no current timeout.
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public int getQueryTimeout() throws SQLException;
+
+	/**
+	 * Gets the current result. Should only be called once per result.
+	 * 
+	 * @return the ResultSet for the current result. null if the result is an
+	 *         update count or if there are no more results.
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public ResultSet getResultSet() throws SQLException;
+
+	/**
+	 * Gets the concurrency setting for ResultSet objects generated by this
+	 * Statement.
+	 * 
+	 * @return ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public int getResultSetConcurrency() throws SQLException;
+
+	/**
+	 * Gets the cursor hold setting for ResultSet objects generated by this
+	 * Statement.
+	 * 
+	 * @return ResultSet.HOLD_CURSORS_OVER_COMMIT or
+	 *         ResultSet.CLOSE_CURSORS_AT_COMMIT
+	 * @throws SQLException
+	 *             if there is an error while accessing the database
+	 */
+	public int getResultSetHoldability() throws SQLException;
+
+	/**
+	 * Gets the ResultSet type setting for ResultSets derived from this
+	 * Statement.
+	 * 
+	 * @return ResultSet.TYPE_FORWARD_ONLY for a ResultSet where the cursor can
+	 *         only move forward, ResultSet.TYPE_SCROLL_INSENSITIVE for a
+	 *         ResultSet which is Scrollable but is not sensitive to changes
+	 *         made by others, ResultSet.TYPE_SCROLL_SENSITIVE for a ResultSet
+	 *         which is Scrollable but is sensitive to changes made by others
+	 * @throws SQLException
+	 *             if there is an error accessing the database
+	 */
+	public int getResultSetType() throws SQLException;
+
+	/**
+	 * Gets an update count for the current result if it is not a ResultSet.
+	 * 
+	 * @return the current result as an update count. -1 if the current result
+	 *         is a ResultSet or if there are no more results
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public int getUpdateCount() throws SQLException;
+
+	/**
+	 * Retrieves the first SQLWarning reported by calls on this Statement.
+	 * <p>
+	 * If there are multiple warnings, subsequent warnings are chained to the
+	 * first one.
+	 * <p>
+	 * The chain or warnings is cleared each time the Statement is executed.
+	 * <p>
+	 * Warnings associated with reads from the ResultSet returned from executing
+	 * a Statement will be attached to the ResultSet, not the Statement object.
+	 * 
+	 * @return an SQLWarning, null if there are no warnings
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public SQLWarning getWarnings() throws SQLException;
+
+	/**
+	 * Sets the SQL cursor name. This name is used by subsequent Statement
+	 * execute methods.
+	 * <p>
+	 * Cursor names must be unique within one Connection.
+	 * <p>
+	 * With the Cursor name set, it can then be utilised in SQL positioned
+	 * update or delete statements to determine the current row in a ResultSet
+	 * generated from this Statement. The positioned update or delete must be
+	 * done with a different Statement than this one.
+	 * 
+	 * @param name
+	 *            the Cursor name as a String,
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public void setCursorName(String name) throws SQLException;
+
+	/**
+	 * Sets Escape Processing mode.
+	 * <p>
+	 * If Escape Processing is on, the JDBC driver will do escape substitution
+	 * on an SQL statement before sending it for execution. This does not apply
+	 * to PreparedStatements since they are processed when created, before this
+	 * method can be called.
+	 * 
+	 * @param enable
+	 *            true to set escape processing mode on, false to turn it off.
+	 * @throws SQLException
+	 *             if an error occurs accessing the database
+	 */
+	public void setEscapeProcessing(boolean enable) throws SQLException;
+
+	/**
+	 * Sets the fetch direction - a hint to the JDBC driver about the direction
+	 * of processing of rows in ResultSets created by this Statement. The
+	 * default fetch direction is FETCH_FORWARD.
+	 * 
+	 * @param direction
+	 *            which fetch direction to use. This parameter should be one of
+	 *            ResultSet.FETCH_UNKNOWN, ResultSet.FETCH_FORWARD or
+	 *            ResultSet.FETCH_REVERSE
+	 * @throws SQLException
+	 *             if there is an error while accessing the database or if the
+	 *             fetch direction is unrecognised
+	 */
+	public void setFetchDirection(int direction) throws SQLException;
+
+	/**
+	 * Sets the fetch size. This is a hint to the JDBC driver about how many
+	 * rows should be fetched from the database when more are required by
+	 * application processing.
+	 * 
+	 * @param rows
+	 *            the number of rows that should be fetched. 0 tells the driver
+	 *            to ignore the hint. Should be less than
+	 *            <code>getMaxRows</code> for this statement. Should not be
+	 *            negative.
+	 * @throws SQLException
+	 *             if an error occurs accessing the database, or if the rows
+	 *             parameter is out of range.
+	 */
+	public void setFetchSize(int rows) throws SQLException;
+
+	/**
+	 * Sets the maximum number of bytes for ResultSet columns that contain
+	 * character or binary values. This applies to BINARY, VARBINARY,
+	 * LONGVARBINARY, CHAR, VARCHAR, and LONGVARCHAR fields. Any data exceeding
+	 * the maximum size is abandoned without announcement.
+	 * 
+	 * @param max
+	 *            the maximum field size in bytes. O means "no limit".
+	 * @throws SQLException
+	 *             if an error occurs accessing the database or the max value is
+	 *             <0.
+	 */
+	public void setMaxFieldSize(int max) throws SQLException;
+
+	/**
+	 * Sets the maximum number of rows that any ResultSet can contain. If the
+	 * number of rows exceeds this value, the additional rows are silently
+	 * discarded.
+	 * 
+	 * @param max
+	 *            the maximum number of rows. 0 means "no limit".
+	 * @throws SQLException
+	 *             if an error occurs accessing the database or if max <0.
+	 */
+	public void setMaxRows(int max) throws SQLException;
+
+	/**
+	 * Sets the timeout, in seconds, for queries - how long the driver will
+	 * allow for completion of a Statement execution. If the timeout is
+	 * exceeded, the query will throw an SQLException.
+	 * 
+	 * @param seconds
+	 *            timeout in seconds. 0 means no timeout ("wait forever")
+	 * @throws SQLException
+	 *             if an error occurs accessing the database or if seconds <0.
+	 */
+	public void setQueryTimeout(int seconds) throws SQLException;
+
+} // end interface Statement
+

Added: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Struct.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Struct.java?rev=386087&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Struct.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Struct.java Wed Mar 15 06:55:38 2006
@@ -0,0 +1,66 @@
+/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * 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.util.Map;
+
+/**
+ * An interface which provides facilities for mapping an SQL structured type to
+ * Java. The Struct object has a value for each attribute of the SQL structured
+ * type
+ * 
+ */
+public interface Struct {
+
+	/**
+	 * Gets the SQL Type name of the SQL structured type that this Struct
+	 * represents
+	 * 
+	 * @return the fully qualified name of SQL structured type
+	 * @throws SQLException
+	 *             if a database error occurs
+	 */
+	public String getSQLTypeName() throws SQLException;
+
+	/**
+	 * Gets the values of the attributes of this SQL structured type. This
+	 * method uses the type map associated with the Connection for customized
+	 * type mappings. Where there is no entry in the Type Map which matches the
+	 * this structured type, the JDBC driver uses the standard mapping.
+	 * 
+	 * @return an Object array containing the attributes, in order
+	 * @throws SQLException
+	 *             if a database error occurs
+	 */
+	public Object[] getAttributes() throws SQLException;
+
+	/**
+	 * Gets the values of the attributes of this SQL structured type. This
+	 * method uses the supplied type map for customized type mappings. Where
+	 * there is no entry in the Type Map which matches the this structured type,
+	 * the JDBC driver uses the default mapping. The Connection type map is
+	 * never utilised by this method.
+	 * 
+	 * @param theMap
+	 *            a Map describing how SQL Type names are mapped to classes.
+	 * @return an Object array containing the attributes, in order
+	 * @throws SQLException
+	 *             if a database error occurs
+	 */
+	public Object[] getAttributes(Map theMap) throws SQLException;
+
+} // end interface Struct
+

Added: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Time.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Time.java?rev=386087&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Time.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Time.java Wed Mar 15 06:55:38 2006
@@ -0,0 +1,199 @@
+/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * 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;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * Java representation of an SQL TIME value.  Provides functions to aid generation and
+ * interpretation of JDBC escape format for time values.
+ * 
+ */
+public class Time extends Date implements Serializable, Cloneable, Comparable {
+	
+	private static final long serialVersionUID = 8397324403548013681L;
+
+	/**
+	 * @deprecated Please use the constructor Time( long )
+	 * Constructs a Time object using the supplied values for Hour, Minute and Second.
+	 * The Year, Month and Day elements of the Time object are set to 1970, January, 1
+	 * reflecting the Epoch (Time in milliseconds = 0).
+	 * <p>
+	 * Any attempt to access the Year, Month or Day elements of a Time object will result in
+	 * an IllegalArgumentException.
+	 * <p>
+	 * Result is undefined if any argument is out of bounds.
+	 * @param theHour a value from 0 - 23
+	 * @param theMinute a value from 0 - 59
+	 * @param theSecond a value from 0 - 59
+	 */
+	public Time( int theHour, int theMinute, int theSecond ) {
+		super( 70, 0, 1, theHour, theMinute, theSecond );
+	} // end method Time(int, int, int)
+	
+	/**
+	 * Constructs a Time object using a supplied time specified in milliseconds
+	 * @param theTime a Time specified in milliseconds since the Epoch (January 1st 1970, 00:00:00.000)
+	 */
+	public Time( long theTime ) {
+		super( theTime );
+		// System.out.println("Clear version of java.sql.Time");
+	} // end method Time( long )
+	
+	/**
+	 * @deprecated
+	 * This method is deprecated and must not be used.  An SQL Time object does not have a
+	 * Date component.	 
+	 * @return 0
+	 * @throws IllegalArgumentException if this method is called
+	 */
+	public int getDate() {
+		if( true ) {
+			throw new IllegalArgumentException();
+		} // end if
+		return 0;
+	} // end method getDate()
+    
+	/**
+	 * @deprecated
+	 * This method is deprecated and must not be used.  An SQL Time object does not have a
+	 * Day component.
+	 * @return 0
+	 * @throws IllegalArgumentException if this method is called
+	 */
+	public int getDay() {
+		if( true ) {
+			throw new IllegalArgumentException();
+		} // end if
+		return 0;
+	} // end method getDay()
+    
+	/**
+	 * @deprecated
+	 * This method is deprecated and must not be used.  An SQL Time object does not have a
+	 * Month component.	 
+	 * @return 0
+	 * @throws IllegalArgumentException if this method is called
+	 */
+	public int getMonth() {
+		if( true ) {
+			throw new IllegalArgumentException();
+		} // end if
+		return 0;
+	} // end method getMonth()
+    
+	/**
+	 * @deprecated	 
+	 * This method is deprecated and must not be used.  An SQL Time object does not have a
+	 * Year component.	 
+	 * @return 0
+	 * @throws IllegalArgumentException if this method is called
+	 */
+	public int getYear() {
+		if( true ) {
+			throw new IllegalArgumentException();
+		} // end if
+		return 0;
+	} // end method getYear()
+	
+    /**
+     * @deprecated
+     * This method is deprecated and must not be used.  An SQL Time object does not have a
+	 * Date component.	 
+	 * @throws IllegalArgumentException if this method is called
+     */
+	public void setDate(int i) {
+		if( true ) {
+			throw new IllegalArgumentException();
+		} // end if
+	} // end method setDate( int )
+	
+    /**
+     * @deprecated     
+     * This method is deprecated and must not be used.  An SQL Time object does not have a
+	 * Month component.	 
+	 * @throws IllegalArgumentException if this method is called
+     */
+	public void setMonth(int i) {
+		if( true ) {
+			throw new IllegalArgumentException();
+		} // end if
+	} // end method setMonth( int )
+	
+	/**
+	 * @deprecated     
+	 * This method is deprecated and must not be used.  An SQL Time object does not have a
+	 * Year component.	 
+	 * @throws IllegalArgumentException if this method is called
+	 */
+    public void setYear(int i) {
+		if( true ) {
+			throw new IllegalArgumentException();
+		} // end if
+    } // end method setYear( int )
+    
+	/**
+	 * Sets the time for this Time object to the supplied milliseconds value.
+	 * @param time A time value expressed as milliseconds since the Epoch.  Negative values are milliseconds 
+	 * before the Epoch.  The Epoch is January 1 1970, 00:00:00.000
+	 */
+    public void setTime(long time) {
+    	super.setTime( time );
+    } // end method setTime( long )
+    
+    /**
+     * Formats the Time as a String in JDBC escape format: hh:mm:ss
+     * @return A String representing the Time value in JDBC escape format: HH:mm:ss
+     */
+    public String toString() {
+		SimpleDateFormat dateFormat = new SimpleDateFormat( "HH:mm:ss" );
+		
+		return dateFormat.format( this );
+    } // end method toString()
+    
+    /**
+     * Creates a Time object from a String holding a time represented in JDBC escape
+     * format:  hh:mm:ss.
+     * <p>
+     * An exception occurs if the input string is not in the form of a time in JDBC escape
+     * format.
+     * @param theTime A String representing the time value in JDBC escape format:  hh:mm:ss
+     * @return The Time object set to a time corresponding to the given time
+     * @throws IllegalArgumentException is the supplied time string is not in JDBC escape
+     * format.
+     */
+    public static Time valueOf( String theTime ) {
+		java.util.Date aDate;
+		
+		if( theTime == null ) throw new IllegalArgumentException();
+		
+		SimpleDateFormat dateFormat = new SimpleDateFormat( "HH:mm:ss" );
+		try {
+			aDate = dateFormat.parse( theTime );
+		} catch( ParseException pe ) {
+			throw new IllegalArgumentException();
+		} // end try
+		
+		return new Time( aDate.getTime() );
+    } // end method valueOf( String )
+
+} // end class Time
+
+

Added: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Timestamp.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Timestamp.java?rev=386087&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Timestamp.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Timestamp.java Wed Mar 15 06:55:38 2006
@@ -0,0 +1,354 @@
+/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * 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.text.SimpleDateFormat;
+import java.util.Date;
+import java.io.Serializable;
+import java.lang.IllegalArgumentException;
+import java.text.DecimalFormat;
+import java.text.ParsePosition;
+
+/**
+ * A Java representation of the SQL TIMESTAMP type.  It provides the capability to represent
+ * the SQL TIMESTAMP nanosecond value, in addition to the regular date/time value which has
+ * millisecond resolution.
+ * <p>
+ * The Timestamp class consists of a regular Date/Time value, where only the integral seconds
+ * value is stored, plus a nanoseconds value where the fractional seconds are stored.
+ * <p>
+ * The addition of the nanosecond value field to the Timestamp object makes it significantly
+ * different from the java.util.Date object which it extends.  Users should be cautious in 
+ * their use of Timestamp objects and should not assume that they are interchangeable with
+ * java.util.Date objects when used outside the confines of the java.sql package.  
+ * 
+ */
+public class Timestamp extends Date implements Serializable, Cloneable, Comparable {
+	
+	private static final long serialVersionUID = 2745179027874758501L;
+	
+	// The nanoseconds time value of the Timestamp
+	private int nanoseconds;
+
+	/**
+	 * @deprecated Please use the constructor Timestamp( long )
+	 * Returns a Timestamp corresponding to the time specified by the supplied values for Year, Month,
+	 * Date, Hour, Minutes, Seconds and Nanoseconds 
+	 * @param theYear specified as the year minus 1900
+	 * @param theMonth specified as an integer in the range 0 - 11
+	 * @param theDate specified as an integer in the range 1 - 31
+	 * @param theHour specified as an integer in the range 0 - 23
+	 * @param theMinute specified as an integer in the range 0 - 59
+	 * @param theSecond specified as an integer in the range 0 - 59
+	 * @param theNano which defines the nanosecond value of the timestamp specified as an integer
+	 * in the range 0 - 999,999,999
+	 * @throws IllegalArgumentException if any of the parameters is out of range
+	 */
+	public Timestamp( int theYear, int theMonth, int theDate, int theHour, 
+					  int theMinute, int theSecond, int theNano ) 
+					  throws IllegalArgumentException {
+ 		super( theYear, theMonth, theDate, theHour, theMinute, theSecond );
+ 		if( theNano < 0 || theNano > 999999999 ) throw new IllegalArgumentException();		
+		nanoseconds = theNano;
+	} // end method Timestamp( int, int, int, int, int, int )
+	
+	/**
+	 * Returns a Timestamp object corresponding to the time represented by a supplied time value.
+	 * 
+	 * @param theTime a time value in the format of milliseconds since the Epoch 
+	 * (January 1 1970 00:00:00.000 GMT)
+	 */
+	public Timestamp(long theTime) {
+		super( theTime );
+		// Now set the time for this Timestamp object - which deals with the nanosecond value
+		// as well as the base time
+		this.setTime( theTime );
+		// System.out.println("Clear version of java.sql.Timestamp");
+	} // end method Timestamp( long )
+	
+	/**
+	 * Returns true if this timestamp object is later than the supplied timestamp,
+	 * otherwise returns false.
+	 * @param theTimestamp the timestamp to compare with this timestamp object
+	 * @return true if this timestamp object is later than the supplied timestamp, false
+	 * otherwise
+	 */
+	public boolean after( Timestamp theTimestamp ) {
+		long thisTime = this.getTime();
+		long compareTime = theTimestamp.getTime();
+		
+		// If the time value is later, the timestamp is later
+		if ( thisTime > compareTime ) { return true; }
+		// If the time value is earlier, the timestamp is not later
+		else if ( thisTime < compareTime ) { return false; }
+		// Otherwise the time values are equal in which case the nanoseconds value
+		// determines whether this timestamp is later...
+		else if ( this.getNanos() > theTimestamp.getNanos() ) { return true; }
+		else { return false; } // end if
+		
+	} // end method after( Timestamp )
+    
+	/**
+	 * Returns true if this timestamp object is earlier than the supplied timestamp,
+	 * otherwise returns false.
+	 * @param theTimestamp the timestamp to compare with this timestamp object
+	 * @return true if this timestamp object is earlier than the supplied timestamp, false
+	 * otherwise
+	 */
+	public boolean before( Timestamp theTimestamp ) {
+		long thisTime = this.getTime();
+		long compareTime = theTimestamp.getTime();
+		
+		// If the time value is later, the timestamp is later
+		if ( thisTime < compareTime ) { return true; }
+		// If the time value is earlier, the timestamp is not later
+		else if ( thisTime > compareTime ) { return false; }
+		// Otherwise the time values are equal in which case the nanoseconds value
+		// determines whether this timestamp is later...
+		else if ( this.getNanos() < theTimestamp.getNanos() ) { return true; }
+		else { return false; } // end if
+		
+	} // end method before( Timestamp )
+    
+	/**
+	 * Compares this Timestamp object with a supplied Timestamp object
+	 * @param theObject the timestamp to compare with this timestamp object, passed in as an Object
+	 * @return 0 if the two Timestamp objects are equal in time, a value <0 if this Timestamp object is
+	 * before the supplied Timestamp and a value >0 if this Timestamp object is after the supplied
+	 * Timestamp
+	 * @throws ClassCastException if the supplied object is not a Timestamp object
+	 */
+	public int	compareTo( Object theObject ) throws ClassCastException {
+		return this.compareTo( (Timestamp) theObject );
+	} // end method compareTo( Object )
+    
+	/**
+	 * Compares this Timestamp object with a supplied Timestamp object
+	 * @param theTimestamp the timestamp to compare with this timestamp object, passed in as a Timestamp
+	 * @return 0 if the two Timestamp objects are equal in time, a value <0 if this Timestamp object is
+	 * before the supplied Timestamp and a value >0 if this Timestamp object is after the supplied
+	 * Timestamp
+	 */
+	public int compareTo( Timestamp theTimestamp ) {
+		if ( this.before( theTimestamp ) ) { return -1; }
+		else if ( this.after( theTimestamp ) ) { return +1; }
+		else return 0;
+	} // end method compareTo( Timestamp )
+	
+	/**
+	 * Tests to see if this timestamp is equal to a supplied object.
+	 * @param theObject 
+	 * @return true if this Timestamp object is equal to the supplied Timestamp object
+	 * false if the object is not a Timestamp object or if the object is a Timestamp but
+	 * represents a different instant in time
+	 */
+    public boolean equals( Object theObject ) {
+    	Timestamp theTimestamp;
+    	try {
+    		theTimestamp = (Timestamp) theObject;
+    	} catch (ClassCastException e) {
+    		return false;
+    	} // end 
+    	return this.equals( (Timestamp) theTimestamp );
+    } // end method equals( Object )
+    
+	/**
+	 * Tests to see if this timestamp is equal to a supplied timestamp.
+	 * @param theTimestamp the timestamp to compare with this timestamp object, passed in as an Object
+	 * @return true if this Timestamp object is equal to the supplied Timestamp object
+	 */
+    public boolean equals( Timestamp theTimestamp ) {
+    	if( (this.getTime() == theTimestamp.getTime()) && (this.getNanos() == theTimestamp.getNanos()) ) {
+    		return true;
+    	} else {
+    		return false;
+    	}
+    } // end method equals( Timestamp )
+    
+    /**
+     * Gets this Timestamp's nanosecond value
+     * @return The timestamp's nanosecond value, an integer between 0 and 999,999,999
+     */
+    public int getNanos() {
+    	return nanoseconds;
+    } // end method getNanos()
+    
+    /**
+     * Returns the time represented by this Timestamp object, as a long value containing the number of
+     * milliseconds since the Epoch (January 1 1970, 00:00:00.000 GMT)
+     */
+    public long getTime() {
+    	long theTime = super.getTime();
+    	theTime = theTime + (long)(nanoseconds / 1000000 );
+    	return theTime;
+    } // end method getTime()
+    
+    /**
+     * Sets the nanosecond value for this timestamp
+     */
+    public void setNanos(int n) throws IllegalArgumentException {
+    	if ( (n < 0) || (n > 999999999 ) ) throw new IllegalArgumentException("Nanos value out of range.");
+    	nanoseconds = n;
+    } // end method setNanos( int )
+    
+    /**
+     * Sets the time represented by this Timestamp object to the supplied time, defined as the number
+     * of milliseconds since the Epoch (January 1 1970, 00:00:00.000 GMT)
+     */
+    public void setTime(long theTime) {
+		// Deal with the nanoseconds value.  The supplied time is in milliseconds - so we must
+		// extract the milliseconds value and multiply by 1000000 to get nanoseconds.
+		// Things are more complex if theTime value is negative, since then the time
+		// value is the time before the Epoch but the nanoseconds value of the Timestamp must
+		// be positive - so we must take the "raw" milliseconds value and subtract it from
+		// 1000 to get to the true nanoseconds value
+		// Simultaneously, recalculate the time value to the exact nearest second and reset 
+		// the Date time value
+		int milliseconds = (int)(theTime % 1000);
+		theTime = theTime - milliseconds;
+		if ( milliseconds < 0 ) {
+			theTime = theTime - 1000;
+			milliseconds = 1000 + milliseconds;	
+		} // end if
+		super.setTime( theTime );
+		setNanos( milliseconds * 1000000 );
+    } // end method setTime( long )
+    
+    /**
+     * Returns the timestamp formatted as a String in the JDBC Timestamp Escape format, which is of the
+     * form "yyyy-mm-dd hh:mm:ss.nnnnnnnnn"
+     * @return A string representing the instant defined by the Timestamp, in JDBC Timestamp 
+     * escape format
+     */
+    public String toString() {
+    	// A SimpleDateFormat will lay out everything except the nanosecond value
+		SimpleDateFormat dateFormat = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );
+		
+		// Use a DecimalFormat to lay out the nanosecond value as a simple string of
+		// 9 integers, with leading Zeros
+		DecimalFormat decimalFormat = new DecimalFormat("0");
+		decimalFormat.setMinimumIntegerDigits( 9 );
+		decimalFormat.setMaximumIntegerDigits( 9 );
+		String theNanos = decimalFormat.format( (long) nanoseconds ); 
+		theNanos = stripTrailingZeros( theNanos );
+		// Concatenate the nanosecond value with a dot - and return
+		return (dateFormat.format( this ) + '.' + theNanos);
+    } // end method toString()
+    
+    /*
+     * Private method to strip trailing '0' characters from a string.
+     * @param inputString the starting string
+     * @return a string with the trailing zeros stripped - will leave
+     * a single 0 at the beginning of the string 
+     */
+    private String stripTrailingZeros( String inputString ) {
+    	String finalString;
+    	
+    	int i;
+    	for( i = inputString.length(); i > 0 ; i-- ) {
+    		if( inputString.charAt(i-1) != '0' ) break;
+    		// If the string has a 0 as its first character, return
+    		// a string with a single '0'
+    		if ( i == 1 ) return "0";
+    	} // end for
+    	
+    	finalString = inputString.substring(0, i);
+    	return finalString;
+    } // end stripTrailingZeros( String )
+    
+    private static String	valueOfExceptionMessage = 
+    	"Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff";
+    /**
+     * Creates a Timestamp object with a time value equal to the time specified by a supplied String
+     * holding the time in JDBC timestamp escape format, which is of the form
+     * "yyyy-mm-dd hh:mm:ss.nnnnnnnnn"
+     * @param s the String containing a time in JDBC timestamp escape format
+     * @return A timestamp object with time value as defined by the supplied String
+     */
+    public static Timestamp valueOf( String s ) throws IllegalArgumentException {
+    	if( s == null ) throw new IllegalArgumentException("null string");
+    	
+    	SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+    	ParsePosition pp = new ParsePosition( 0 );
+    	
+    	// First parse out the yyyy-MM-dd HH:mm:ss component of the String into a Date object
+    	// using the SimpleDateFormat.  This should stop after the seconds value, according to
+    	// the definition of SimpleDateFormat.parse, with the ParsePosition indicating the
+    	// index of the "." which should precede the nanoseconds value
+    	Date theDate;
+    	try {
+    		theDate = df.parse( s, pp );
+    	} catch (Exception e) {
+    		throw new IllegalArgumentException(valueOfExceptionMessage);
+    	} // end try
+    	
+    	if( theDate == null ) throw new IllegalArgumentException(valueOfExceptionMessage);
+    	
+    	/* If we get here, the Date part of the string was OK - now for the nanoseconds
+    	 * value.  Strictly, this requires the remaining part of the String to look like
+    	 * ".nnnnnnnnn".  However, we accept anything with a '.' followed by 1 to 9
+    	 * digits - we also accept nothing (no fractions of a second).
+    	 * Anything else is interpreted as incorrect format which will
+    	 * generate an IllegalArgumentException
+    	 */
+    	int position = pp.getIndex();
+    	int remaining = s.length() - position;
+    	int theNanos;
+    	
+    	if( remaining == 0 ) {
+    	    // First, allow for the case where no fraction of a second is given:
+    	    theNanos = 0;
+    	} else {
+    	    // Case where fraction of a second is specified:
+	    	// Require 1 character plus the "." in the remaining part of the string...
+	    	if( (s.length() - position) < ".n".length() ) throw new IllegalArgumentException(valueOfExceptionMessage);
+	    	
+	    	// If we're strict, we should not allow any EXTRA characters after the 9 digits
+	    	if( (s.length() - position) > ".nnnnnnnnn".length() ) throw new IllegalArgumentException(valueOfExceptionMessage);
+	    	
+	    	// Require the next character to be a "."
+	    	if( s.charAt(position) != '.' ) throw new NumberFormatException("Bad input string format - '" + s.charAt(position) + "' instead of '.'");
+	    	// Get the length of the number string - need to account for the '.'
+	    	int nanoLength = s.length() - position - 1 ;
+	    	    	
+	    	// Get the 9 characters following the "." as an integer
+	    	String theNanoString = s.substring( position+1, position+1+nanoLength );
+	    	// We must adjust for the cases where the nanos String was not 9 characters long
+	    	// by padding out with zeros
+	    	theNanoString = theNanoString + "000000000";
+	    	theNanoString = theNanoString.substring(0, 9);
+	    	
+	    	try {
+	    		theNanos = Integer.parseInt( theNanoString );
+	    	} catch (Exception e) {
+	    		// If we get here, the string was not a number
+	    		throw new IllegalArgumentException(valueOfExceptionMessage);
+	    	} // end try
+    	} // end if
+    	
+    	if ( theNanos < 0 || theNanos > 999999999 ) throw new IllegalArgumentException(valueOfExceptionMessage);
+    	
+    	Timestamp theTimestamp = new Timestamp( theDate.getTime() );
+    	theTimestamp.setNanos( theNanos );
+    	
+    	return theTimestamp;
+    } // end method valueOf( String )
+    
+	
+}
+
+

Added: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Types.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Types.java?rev=386087&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Types.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Types.java Wed Mar 15 06:55:38 2006
@@ -0,0 +1,190 @@
+/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * 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;
+
+/**
+ * A class which defines constants used to identify generic SQL types, also called JDBC
+ * types. The type constant values are equivalent to those in XOPEN.
+ * 
+ */
+public class Types {
+
+	// Uncomment the following to validate that this version of java.sql.Types is
+	// loaded:
+	// static { System.out.println("Clear version of java.sql.Types loaded!"); }; 
+	
+	/*
+	 * Private constructor to prevent instantiation.
+	 */
+	private Types() {
+		
+	} // end constructor Types()
+	
+	/**
+	 * The type code that identifies the SQL type ARRAY.
+	 */
+	public static final int 	ARRAY 		= 2003 ;
+	
+	/**
+	 * The type code that identifies the SQL type BIGINT.
+	 */
+	public static final int 	BIGINT		= -5 ;
+	
+	/**
+	 * The type code that identifies the SQL type BINARY.
+	 */
+	public static final int 	BINARY		= -2 ;
+	
+	/**
+	 * The type code that identifies the SQL type BIT.
+	 */
+	public static final int 	BIT			= -7 ;
+
+	/**
+	 * The type code that identifies the SQL type BLOB.
+	 */
+	public static final int 	BLOB		= 2004 ;
+    
+	/**
+	 * The type code that identifies the SQL type BOOLEAN.
+	 */
+	public static final int 	BOOLEAN		= 16 ;
+    
+	/**
+	 * The type code that identifies the SQL type CHAR.
+	 */
+	public static final int 	CHAR		= 1 ;
+    
+	/**
+	 * The type code that identifies the SQL type CLOB.
+	 */
+	public static final int 	CLOB		= 2005 ;
+	
+	/**
+	 * The type code that identifies the SQL type DATALINK.
+	 */
+    public static final int 	DATALINK	= 70 ;
+    
+	/**
+	 * The type code that identifies the SQL type DATE.
+	 */
+    public static final int 	DATE		= 91 ;
+    
+	/**
+	 * The type code that identifies the SQL type DECIMAL.
+	 */
+    public static final int 	DECIMAL		= 3 ;
+    
+	/**
+	 * The type code that identifies the SQL type DISTINCT.
+	 */
+    public static final int 	DISTINCT	= 2001 ;
+    
+	/**
+	 * The type code that identifies the SQL type DOUBLE.
+	 */
+    public static final int 	DOUBLE		= 8 ;
+    
+	/**
+	 * The type code that identifies the SQL type FLOAT.
+	 */
+    public static final int 	FLOAT		= 6 ;
+    
+	/**
+	 * The type code that identifies the SQL type INTEGER.
+	 */
+    public static final int 	INTEGER		= 4 ;
+    
+	/**
+	 * The type code that identifies the SQL type JAVA_OBJECT.
+	 */
+    public static final int 	JAVA_OBJECT	= 2000 ;
+    
+	/**
+	 * The type code that identifies the SQL type LONGVARBINARY.
+	 */
+    public static final int 	LONGVARBINARY = -4 ;
+    
+	/**
+	 * The type code that identifies the SQL type LONGVARCHAR.
+	 */
+	public static final int 	LONGVARCHAR	= -1 ;
+	
+	/**
+	 * The type code that identifies the SQL type NULL.
+	 */
+    public static final int 	NULL		= 0 ;
+    
+	/**
+	  * The type code that identifies the SQL type NUMERIC.
+	  */
+	public static final int 	NUMERIC		= 2 ;
+	
+	/**
+ 	 * The type code that identifies that the SQL type is database specific and is mapped to
+	 * a Java object, accessed via the methods <code>getObject</code> and <code>setObject</code>.
+	 */
+	public static final int 	OTHER		= 1111 ;
+    
+	/**
+	 * The type code that identifies the SQL type REAL.
+	 */
+	public static final int 	REAL		= 7 ;
+    
+	/**
+	 * The type code that identifies the SQL type REF.
+	 */
+   	public static final int 	REF			= 2006 ;
+    
+	/**
+	 * The type code that identifies the SQL type SMALLINT.
+	 */
+	public static final int 	SMALLINT	= 5 ;
+    
+	/**
+	 * The type code that identifies the SQL type STRUCT.
+	 */
+    public static final int 	STRUCT		= 2002 ;
+    
+	/**
+	 * The type code that identifies the SQL type TIME.
+	 */
+	public static final int 	TIME		= 92 ;
+    
+	/**
+	 * The type code that identifies the SQL type TIMESTAMP.
+	 */
+	public static final int 	TIMESTAMP	= 93 ;
+    
+	/**
+	 * The type code that identifies the SQL type TINYINT.
+	 */
+	public static final int 	TINYINT		= -6 ;
+
+	/**
+	 * The type code that identifies the SQL type VARBINARY.
+	 */
+	public static final int 	VARBINARY	= -3 ;
+    
+	/**
+	 * The type code that identifies the SQL type VARCHAR.
+	 */
+	public static final int 	VARCHAR		= 12 ;
+	
+} // end class Types
+
+

Added: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionEvent.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionEvent.java?rev=386087&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionEvent.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionEvent.java Wed Mar 15 06:55:38 2006
@@ -0,0 +1,69 @@
+/* Copyright 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * 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 javax.sql;
+
+import java.util.EventObject;
+import java.sql.SQLException;
+import java.io.Serializable;
+
+/**
+ * An Event object which is sent when specific events happen on a PooledConnection object.
+ * The events involved are when the application closing the PooledConnection and when an error
+ * occurs in the PooledConnection.
+ * 
+ */
+public class ConnectionEvent extends EventObject implements Serializable {
+	
+	private static final long serialVersionUID = -4843217645290030002L;
+	
+	private SQLException theSQLException;
+
+	/**
+	 * Creates a connection event initialized with a supplied PooledConnection.
+	 * @param theConnection the PooledConnection 
+	 */
+	public ConnectionEvent(PooledConnection theConnection ) {
+		super( theConnection );
+		// System.out.println("Clear Connection Event constructor");
+		theSQLException = null;
+	} // end method ConnectionEvent( PooledConnection )
+	
+	/**
+	 * Creates a ConnectionEvent initialized with a supplied PooledConnection and with
+	 * a supplied SQLException indicating that an error has occurred within the PooledConnection.
+	 * @param theConnection the PooledConnection
+	 * @param theException the SQLException holding information about the error that has occurred,
+	 * which is about to be returned to the application.
+	 */
+	public ConnectionEvent(PooledConnection theConnection, SQLException theException ) {
+		super( theConnection );
+		theSQLException = theException;
+	} // end method ConnectionEvent( PooledConnection, SQLException )
+	
+	/**
+	 * Gets the SQLException which holds information about the error which occurred in the
+	 * PooledConnection.
+	 * @return an SQLException containing information about the error. May be null if no error
+	 * has occurred.
+	 */
+	public SQLException getSQLException() {
+		return theSQLException;
+	} // end method getSQLException()
+	
+} // end class ConnectionEvent
+
+



Mime
View raw message