procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Major merge with Classpath.

Browse source 
Removed many duplicate files.
	* HACKING: Updated.x
	* classpath: Imported new directory.
	* standard.omit: New file.
	* Makefile.in, aclocal.m4, configure: Rebuilt.
	* sources.am: New file.
	* configure.ac: Run Classpath configure script.  Moved code around
	to support.  Disable xlib AWT peers (temporarily).
	* Makefile.am (SUBDIRS): Added 'classpath'
	(JAVAC): Removed.
	(AM_CPPFLAGS): Added more -I options.
	(BOOTCLASSPATH): Simplified.
	Completely redid how sources are built.
	Include sources.am.
	* include/Makefile.am (tool_include__HEADERS): Removed jni.h.
	* include/jni.h: Removed (in Classpath).
	* scripts/classes.pl: Updated to look at built classes.
	* scripts/makemake.tcl: New file.
	* testsuite/libjava.jni/jni.exp (gcj_jni_compile_c_to_so): Added
	-I options.
	(gcj_jni_invocation_compile_c_to_binary): Likewise.

From-SVN: r102082
This commit is contained in:
Tom Tromey 2005-07-16 01:27:14 +00:00 • committed by Tom Tromey
parent ea54b29342
commit b0fa81eea9
2817 changed files with 11656 additions and 643398 deletions
Download patch file Download diff file Expand all files Collapse all files

185
libjava/java/sql/Array.java
View file

@ -1,185 +0,0 @@
/* Array.java -- Interface for accessing SQL array object
Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.util.Map;
/**
* This interface provides methods for accessing SQL array types.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface Array
{
/**
* Returns the name of the SQL type of the elements in this
* array. This name is database specific.
*
* @param The name of the SQL type of the elements in this array.
* @exception SQLException If an error occurs.
*/
String getBaseTypeName() throws SQLException;
/**
* Returns the JDBC type identifier of the elements in this
* array. This will be one of the values defined in the
* <code>Types</code> class.
*
* @return The JDBC type of the elements in this array.
* @exception SQLException If an error occurs.
* @see Types
*/
int getBaseType() throws SQLException;
/**
* Returns the contents of this array. This object returned
* will be an array of Java objects of the appropriate types.
*
* @return The contents of the array as an array of Java objects.
* @exception SQLException If an error occurs.
*/
Object getArray() throws SQLException;
/**
* Returns the contents of this array. The specified
* <code>Map</code> will be used to override selected mappings
* between SQL types and Java classes.
*
* @param map A mapping of SQL types to Java classes.
* @return The contents of the array as an array of Java objects.
* @exception SQLException If an error occurs.
*/
Object getArray(Map map) throws SQLException;
/**
* Returns a portion of this array starting at <code>index</code>
* into the array and continuing for <code>count</code>
* elements. Fewer than the requested number of elements will be
* returned if the array does not contain the requested number of elements.
* The object returned will be an array of Java objects of
* the appropriate types.
*
* @param offset The offset into this array to start returning elements from.
* @param count The requested number of elements to return.
* @return The requested portion of the array.
* @exception SQLException If an error occurs.
*/
Object getArray(long index, int count) throws SQLException;
/**
* This method returns a portion of this array starting at <code>index</code>
* into the array and continuing for <code>count</code>
* elements. Fewer than the requested number of elements will be
* returned if the array does not contain the requested number of elements.
* The object returned will be an array of Java objects. The specified
* <code>Map</code> will be used for overriding selected SQL type to
* Java class mappings.
*
* @param offset The offset into this array to start returning elements from.
* @param count The requested number of elements to return.
* @param map A mapping of SQL types to Java classes.
* @return The requested portion of the array.
* @exception SQLException If an error occurs.
*/
Object getArray(long index, int count, Map map) throws SQLException;
/**
* Returns the elements in the array as a <code>ResultSet</code>.
* Each row of the result set will have two columns. The first will be
* the index into the array of that row's contents. The second will be
* the actual value of that array element.
*
* @return The elements of this array as a <code>ResultSet</code>.
* @exception SQLException If an error occurs.
* @see ResultSet
*/
ResultSet getResultSet() throws SQLException;
/**
* This method returns the elements in the array as a <code>ResultSet</code>.
* Each row of the result set will have two columns. The first will be
* the index into the array of that row's contents. The second will be
* the actual value of that array element. The specified <code>Map</code>
* will be used to override selected default mappings of SQL types to
* Java classes.
*
* @param map A mapping of SQL types to Java classes.
* @return The elements of this array as a <code>ResultSet</code>.
* @exception SQLException If an error occurs.
* @see ResultSet
*/
ResultSet getResultSet(Map map) throws SQLException;
/**
* This method returns a portion of the array as a <code>ResultSet</code>.
* The returned portion will start at <code>index</code> into the
* array and up to <code>count</code> elements will be returned.
* <p>
* Each row of the result set will have two columns. The first will be
* the index into the array of that row's contents. The second will be
* the actual value of that array element.
*
* @param offset The index into the array to start returning elements from.
* @param length The requested number of elements to return.
* @return The requested elements of this array as a <code>ResultSet</code>.
* @exception SQLException If an error occurs.
* @see ResultSet
*/
ResultSet getResultSet(long index, int count) throws SQLException;
/**
* This method returns a portion of the array as a <code>ResultSet</code>.
* The returned portion will start at <code>index</code> into the
* array and up to <code>count</code> elements will be returned.
*
* <p> Each row of the result set will have two columns. The first will be
* the index into the array of that row's contents. The second will be
* the actual value of that array element. The specified <code>Map</code>
* will be used to override selected default mappings of SQL types to
* Java classes.</p>
*
* @param offset The index into the array to start returning elements from.
* @param length The requested number of elements to return.
* @param map A mapping of SQL types to Java classes.
* @return The requested elements of this array as a <code>ResultSet</code>.
* @exception SQLException If an error occurs.
* @see ResultSet
*/
ResultSet getResultSet(long index, int count, Map map)
throws SQLException;
}

141
libjava/java/sql/BatchUpdateException.java
View file

@ -1,141 +0,0 @@
/* BatchUpdateException.java -- Exception for batch oriented SQL errors
Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
/**
* This class extends <code>SQLException</code> to count the successful
* updates in each statement in a batch that was successfully updated prior
* to the error.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class BatchUpdateException extends SQLException
{
static final long serialVersionUID = 5977529877145521757L;
/**
* This is the array of update counts for the commands which completed
* successfully prior to the error.
*/
private int[] updateCounts;
/**
* This method initializes a new instance of <code>BatchUpdateException</code>
* with the specified descriptive error message, SQL state, and update count
* information. The vendor specific error code will be initialized to 0.
*
* @param message The descriptive error message.
* @param SQLState The SQL state information for this error.
* @param vendorCode
* @param updateCounts The update count information for this error.
*/
public BatchUpdateException(String message, String SQLState, int vendorCode,
int[] updateCounts)
{
super(message, SQLState, vendorCode);
this.updateCounts = updateCounts;
}
/**
* This method initializes a new instance of <code>BatchUpdateException</code>
* with the specified descriptive error message, SQL state, and update count
* information. The vendor specific error code will be initialized to 0.
*
* @param message The descriptive error message.
* @param SQLState The SQL state information for this error.
* @param updateCounts The update count information for this error.
*/
public BatchUpdateException(String message, String SQLState,
int[] updateCounts)
{
super(message, SQLState);
this.updateCounts = updateCounts;
}
/**
* This method initializes a new instance of <code>BatchUpdateException</code>
* with the specified descriptive error message and update count information.
* The SQL state will be initialized to <code>null</code> and the vendor
* specific error code will be initialized to 0.
*
* @param message The descriptive error message.
* @param updateCounts The update count information for this error.
*/
public BatchUpdateException(String message, int[] updateCounts)
{
super(message);
this.updateCounts = updateCounts;
}
/**
* Initializes a new instance of <code>BatchUpdateException</code>
* with the specified update count information and no descriptive error
* message. This SQL state will be initialized to <code>null</code> and
* the vendor specific error code will be initialized to 0.
*
* @param updateCounts The update count array.
*/
public BatchUpdateException(int[] updateCounts)
{
this.updateCounts = updateCounts;
}
/**
* Initializes a new instance of <code>BatchUpdateException</code>
* with no descriptive error message. The SQL state and update count will
* be initialized to <code>null</code> and the vendor specific error code will
* initialized to 0.
*/
public BatchUpdateException()
{
super();
}
/**
* This method returns the update count information for this error. If
* not <code>null</code> this is an array of <code>int</code>'s that are
* the update accounts for each command that was successfully executed.
* The array elements are in the order that the commands were executed.
*
* @return The update count information, which may be <code>null</code>.
*/
public int[] getUpdateCounts()
{
return updateCounts;
}
}

131
libjava/java/sql/Blob.java
View file

@ -1,131 +0,0 @@
/* Blob.java -- Access a SQL Binary Large OBject.
Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.io.InputStream;
import java.io.OutputStream;
/**
* This interface specified methods for accessing a SQL BLOB (Binary
* Large OBject) type.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
* @since 1.2
*/
public interface Blob
{
/**
* This method returns the number of bytes in the BLOB.
*
* @return The number of bytes in the BLOB.
* @exception SQLException If an error occurs.
*/
long length() throws SQLException;
/**
* This method returns up to the requested bytes of this BLOB as a
* <code>byte</code> array.
*
* @param pos The index into the BLOB to start returning bytes from.
* @param length The requested number of bytes to return.
* @return The requested bytes from the BLOB.
* @exception SQLException If an error occurs.
*/
byte[] getBytes(long pos, int length) throws SQLException;
/**
* This method returns a stream that will read the bytes of the BLOB.
*
* @return A stream that will read the bytes of the BLOB.
* @exception SQLException If an error occurs.
*/
InputStream getBinaryStream() throws SQLException;
/**
* This method returns the index into the BLOB at which the first instance
* of the specified bytes occur. The searching starts at the specified
* index into the BLOB.
*
* @param pattern The byte pattern to search for.
* @param offset The index into the BLOB to starting searching for the pattern.
* @return The offset at which the pattern is first found, or -1 if the
* pattern is not found.
* @exception SQLException If an error occurs.
*/
long position(byte[] pattern, long start) throws SQLException;
/**
* This method returns the index into the BLOB at which the first instance
* of the specified pattern occurs. The searching starts at the specified
* index into this BLOB. The bytes in the specified <code>Blob</code> are
* used as the search pattern.
*
* @param pattern The <code>Blob</code> containing the byte pattern to
* search for.
* @param offset The index into the BLOB to starting searching for the pattern.
* @return The offset at which the pattern is first found, or -1 if the
* pattern is not found.
* @exception SQLException If an error occurs.
*/
long position(Blob pattern, long start) throws SQLException;
/**
* @exception SQLException If an error occurs.
* @since 1.4
*/
int setBytes(long pos, byte[] bytes) throws SQLException;
/**
* @exception SQLException If an error occurs.
* @since 1.4
*/
int setBytes(long pos, byte[] bytes, int offset, int len)
throws SQLException;
/**
* @exception SQLException If an error occurs.
* @since 1.4
*/
OutputStream setBinaryStream(long pos) throws SQLException;
/**
* @exception SQLException If an error occurs.
* @since 1.4
*/
void truncate(long len) throws SQLException;
}

651
libjava/java/sql/CallableStatement.java
View file

@ -1,651 +0,0 @@
/* CallableStatement.java -- A statement for calling stored procedures.
Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.util.Calendar;
import java.util.Map;
/**
* This interface provides a mechanism for calling stored procedures.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface CallableStatement extends PreparedStatement
{
/**
* This method registers the specified parameter as an output parameter
* of the specified SQL type.
*
* @param index The index of the parameter to register as output.
* @param type The SQL type value from <code>Types</code>.
* @exception SQLException If an error occurs.
*/
void registerOutParameter(int parameterIndex, int sqlType)
throws SQLException;
/**
* This method registers the specified parameter as an output parameter
* of the specified SQL type and scale.
*
* @param index The index of the parameter to register as output.
* @param type The SQL type value from <code>Types</code>.
* @param scale The scale of the value that will be returned.
* @exception SQLException If an error occurs.
*/
void registerOutParameter(int parameterIndex, int sqlType, int scale)
throws SQLException;
/**
* This method tests whether the value of the last parameter that was fetched
* was actually a SQL NULL value.
*
* @return <code>true</code> if the last parameter fetched was a NULL,
* <code>false</code> otherwise.
* @exception SQLException If an error occurs.
*/
boolean wasNull() throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>String</code>.
*
* @param index The index of the parameter to return.
* @return The parameter value as a <code>String</code>.
* @exception SQLException If an error occurs.
*/
String getString(int parameterIndex) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>boolean</code>.
*
* @param index The index of the parameter to return.
* @return The parameter value as a <code>boolean</code>.
* @exception SQLException If an error occurs.
*/
boolean getBoolean(int parameterIndex) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>byte</code>.
*
* @param index The index of the parameter to return.
* @return The parameter value as a <code>byte</code>.
* @exception SQLException If an error occurs.
*/
byte getByte(int parameterIndex) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>short</code>.
*
* @param index The index of the parameter to return.
* @return The parameter value as a <code>short</code>.
* @exception SQLException If an error occurs.
*/
short getShort(int parameterIndex) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>int</code>.
*
* @param index The index of the parameter to return.
* @return The parameter value as a <code>int</code>.
* @exception SQLException If an error occurs.
*/
int getInt(int parameterIndex) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>long</code>.
*
* @param index The index of the parameter to return.
* @return The parameter value as a <code>long</code>.
* @exception SQLException If an error occurs.
*/
long getLong(int parameterIndex) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>float</code>.
*
* @param index The index of the parameter to return.
* @return The parameter value as a <code>float</code>.
* @exception SQLException If an error occurs.
*/
float getFloat(int parameterIndex) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>double</code>.
*
* @param index The index of the parameter to return.
* @return The parameter value as a <code>double</code>.
* @exception SQLException If an error occurs.
*/
double getDouble(int parameterIndex) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>BigDecimal</code>.
*
* @param parameterIndex The index of the parameter to return.
* @param scale The number of digits to the right of the decimal to return.
* @return The parameter value as a <code>BigDecimal</code>.
* @exception SQLException If an error occurs.
* @deprecated Use getBigDecimal(int parameterIndex)
* or getBigDecimal(String parameterName) instead.
*/
BigDecimal getBigDecimal(int parameterIndex, int scale)
throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* byte array.
*
* @param parameterIndex The index of the parameter to return.
* @return The parameter value as a byte array
* @exception SQLException If an error occurs.
*/
byte[] getBytes(int parameterIndex) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>java.sql.Date</code>.
*
* @param index The index of the parameter to return.
* @return The parameter value as a <code>java.sql.Date</code>.
* @exception SQLException If an error occurs.
*/
Date getDate(int parameterIndex) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>java.sql.Time</code>.
*
* @param index The index of the parameter to return.
* @return The parameter value as a <code>java.sql.Time</code>.
* @exception SQLException If an error occurs.
*/
Time getTime(int parameterIndex) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>java.sql.Timestamp</code>.
*
* @param index The index of the parameter to return.
* @return The parameter value as a <code>java.sql.Timestamp</code>.
* @exception SQLException If an error occurs.
*/
Timestamp getTimestamp(int parameterIndex) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>Object</code>.
*
* @param parameterIndex The index of the parameter to return.
* @return The parameter value as an <code>Object</code>.
* @exception SQLException If an error occurs.
* @since 1.2
*/
Object getObject(int parameterIndex) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>BigDecimal</code>.
*
* @param parameterIndex The index of the parameter to return.
* @return The parameter value as a <code>BigDecimal</code>.
* @exception SQLException If an error occurs.
* @since 1.2
*/
BigDecimal getBigDecimal(int parameterIndex) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>Object</code>.
*
* @param index The index of the parameter to return.
* @param map The mapping to use for conversion from SQL to Java types.
* @return The parameter value as an <code>Object</code>.
* @exception SQLException If an error occurs.
* @since 1.2
*/
Object getObject(int index, Map map) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>Ref</code>.
*
* @param index The index of the parameter to return.
* @return The parameter value as a <code>Ref</code>.
* @exception SQLException If an error occurs.
* @since 1.2
*/
Ref getRef(int index) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>Blob</code>.
*
* @param index The index of the parameter to return.
* @return The parameter value as a <code>Blob</code>.
* @exception SQLException If an error occurs.
* @since 1.2
*/
Blob getBlob(int index) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>Clob</code>.
*
* @param index The index of the parameter to return.
* @return The parameter value as a <code>Clob</code>.
* @exception SQLException If an error occurs.
* @since 1.2
*/
Clob getClob(int index) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>Array</code>.
*
* @param parameterIndex The index of the parameter to return.
* @return The parameter value as a <code>Array</code>.
* @exception SQLException If an error occurs.
* @since 1.2
*/
Array getArray(int index) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>java.sql.Date</code>.
*
* @param parameterIndex The index of the parameter to return.
* @param cal The <code>Calendar</code> to use for timezone and locale.
* @return The parameter value as a <code>java.sql.Date</code>.
* @exception SQLException If an error occurs.
* @since 1.2
*/
Date getDate(int parameterIndex, Calendar cal) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>java.sql.Time</code>.
*
* @param parameterIndex The index of the parameter to return.
* @param cal The <code>Calendar</code> to use for timezone and locale.
* @return The parameter value as a <code>java.sql.Time</code>.
* @exception SQLException If an error occurs.
* @since 1.2
*/
Time getTime(int parameterIndex, Calendar cal) throws SQLException;
/**
* This method returns the value of the specified parameter as a Java
* <code>java.sql.Timestamp</code>.
*
* @param index The index of the parameter to return.
* @return The parameter value as a <code>java.sql.Timestamp</code>.
* @exception SQLException If an error occurs.
* @since 1.2
*/
Timestamp getTimestamp(int parameterIndex, Calendar cal)
throws SQLException;
/**
* This method registers the specified parameter as an output parameter
* of the specified SQL type.
*
* @param index The index of the parameter to register as output.
* @param type The SQL type value from <code>Types</code>.
* @param name The user defined data type name.
* @exception SQLException If an error occurs.
* @since 1.2
*/
void registerOutParameter(int paramIndex, int sqlType,
String typeName)
throws SQLException;
/**
* This method registers the specified parameter as an output parameter
* of the specified SQL type.
*
* @param parameterName The name of the parameter to register as output.
* @param sqlType The SQL type value from <code>Types</code>.
* @exception SQLException If an error occurs.
* @since 1.4
*/
void registerOutParameter(String parameterName, int sqlType)
throws SQLException;
/**
* This method registers the specified parameter as an output parameter
* of the specified SQL type. This version of registerOutParameter is used
* for NUMERIC or DECIMAL types.
*
* @param parameterName The name of the parameter to register as output.
* @param sqlType The SQL type value from <code>Types</code>.
* @param scale Number of digits to the right of the decimal point.
* @exception SQLException If an error occurs.
* @since 1.4
*/
void registerOutParameter(String parameterName, int sqlType,
int scale)
throws SQLException;
/**
* This method registers the specified parameter as an output parameter
* of the specified SQL type. This version of registerOutParameter is used
* for user-named or REF types. If the type of the output parameter does
* not have such a type, the typeName argument is ignored.
*
* @param parameterName The name of the parameter to register as output.
* @param sqlType The SQL type value from <code>Types</code>.
* @param typeName The SQL structured type name.
* @exception SQLException If an error occurs.
* @since 1.4
*/
void registerOutParameter(String parameterName, int sqlType,
String typeName)
throws SQLException;
/**
* @since 1.4
*/
URL getURL(int parameterIndex) throws SQLException;
/**
* @since 1.4
*/
void setURL(String parameterName, URL val) throws SQLException;
/**
* @since 1.4
*/
void setNull(String parameterName, int sqlType) throws SQLException;
/**
* @since 1.4
*/
void setBoolean(String parameterName, boolean x) throws SQLException;
/**
* @since 1.4
*/
void setByte(String parameterName, byte x) throws SQLException;
/**
* @since 1.4
*/
void setShort(String parameterName, short x) throws SQLException;
/**
* @since 1.4
*/
void setInt(String parameterName, int x) throws SQLException;
/**
* @since 1.4
*/
void setLong(String parameterName, long x) throws SQLException;
/**
* @since 1.4
*/
void setFloat(String parameterName, float x) throws SQLException;
/**
* @since 1.4
*/
void setDouble(String parameterName, double x) throws SQLException;
/**
* @since 1.4
*/
void setBigDecimal(String parameterName, BigDecimal x)
throws SQLException;
/**
* @since 1.4
*/
void setString(String parameterName, String x) throws SQLException;
/**
* @since 1.4
*/
void setBytes(String parameterName, byte[] x) throws SQLException;
/**
* @since 1.4
*/
void setDate(String parameterName, Date x) throws SQLException;
/**
* @since 1.4
*/
void setTime(String parameterName, Time x) throws SQLException;
/**
* @since 1.4
*/
void setTimestamp(String parameterName, Timestamp x)
throws SQLException;
/**
* @since 1.4
*/
void setAsciiStream(String parameterName, InputStream x, int length)
throws SQLException;
/**
* @since 1.4
*/
void setBinaryStream(String parameterName, InputStream x, int length)
throws SQLException;
/**
* @since 1.4
*/
void setObject(String parameterName, Object x, int targetSqlType,
int scale)
throws SQLException;
/**
* @since 1.4
*/
void setObject(String parameterName, Object x, int targetSqlType)
throws SQLException;
/**
* @since 1.4
*/
void setObject(String parameterName, Object x) throws SQLException;
/**
* @since 1.4
*/
void setCharacterStream(String parameterName, Reader reader,
int length)
throws SQLException;
/**
* @since 1.4
*/
void setDate(String parameterName, Date x, Calendar cal)
throws SQLException;
/**
* @since 1.4
*/
void setTime(String parameterName, Time x, Calendar cal)
throws SQLException;
/**
* @since 1.4
*/
void setTimestamp(String parameterName, Timestamp x, Calendar cal)
throws SQLException;
/**
* @since 1.4
*/
void setNull(String parameterName, int sqlType, String typeName)
throws SQLException;
/**
* @since 1.4
*/
String getString(String parameterName) throws SQLException;
/**
* @since 1.4
*/
boolean getBoolean(String parameterName) throws SQLException;
/**
* @since 1.4
*/
byte getByte(String parameterName) throws SQLException;
/**
* @since 1.4
*/
short getShort(String parameterName) throws SQLException;
/**
* @since 1.4
*/
int getInt(String parameterName) throws SQLException;
/**
* @since 1.4
*/
long getLong(String parameterName) throws SQLException;
/**
* @since 1.4
*/
float getFloat(String parameterName) throws SQLException;
/**
* @since 1.4
*/
double getDouble(String parameterName) throws SQLException;
/**
* @since 1.4
*/
byte[] getBytes(String parameterName) throws SQLException;
/**
* @since 1.4
*/
Date getDate(String parameterName) throws SQLException;
/**
* @since 1.4
*/
Time getTime(String parameterName) throws SQLException;
/**
* @since 1.4
*/
Timestamp getTimestamp(String parameterName) throws SQLException;
/**
* @since 1.4
*/
Object getObject(String parameterName) throws SQLException;
/**
* @since 1.4
*/
BigDecimal getBigDecimal(String parameterName) throws SQLException;
/**
* @since 1.4
*/
Object getObject(String parameterName, Map map) throws SQLException;
/**
* @since 1.4
*/
Ref getRef(String parameterName) throws SQLException;
/**
* @since 1.4
*/
Blob getBlob(String parameterName) throws SQLException;
/**
* @since 1.4
*/
Clob getClob(String parameterName) throws SQLException;
/**
* @since 1.4
*/
Array getArray(String parameterName) throws SQLException;
/**
* @since 1.4
*/
Date getDate(String parameterName, Calendar cal) throws SQLException;
/**
* @since 1.4
*/
Time getTime(String parameterName, Calendar cal) throws SQLException;
/**
* @since 1.4
*/
Timestamp getTimestamp(String parameterName, Calendar cal)
throws SQLException;
/**
* @since 1.4
*/
URL getURL(String parameterName) throws SQLException;
}

152
libjava/java/sql/Clob.java
View file

@ -1,152 +0,0 @@
/* Clob.java -- Access Character Large OBjects
Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
/**
* This interface contains methods for accessing a SQL CLOB (Character
* Large OBject) type.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface Clob
{
/**
* This method returns the number of characters in the CLOB.
*
* @return The number of characters in the CLOB.
* @exception SQLException If an error occurs.
* @since 1.2
*/
long length() throws SQLException;
/**
* This method returns the specified portion of the CLOB as a
* <code>String</code>.
*
* @param offset The index into the CLOB (index values start at 1) to
* start returning characters from.
* @param length The requested number of characters to return.
* @return The requested CLOB section, as a <code>String</code>.
* @exception SQLException If an error occurs.
* @since 1.2
*/
String getSubString(long pos, int length) throws SQLException;
/**
* This method returns a character stream that reads the contents of the
* CLOB.
*
* @return A character stream to read the CLOB's contents.
* @exception SQLException If an error occurs.
* @since 1.2
*/
Reader getCharacterStream() throws SQLException;
/**
* This method returns a byte stream that reads the contents of the
* CLOB as a series of ASCII bytes.
*
* @return A stream to read the CLOB's contents.
* @exception SQLException If an error occurs.
* @since 1.2
*/
InputStream getAsciiStream() throws SQLException;
/**
* This method returns the index into the CLOB of the first occurrence of
* the specified character pattern (supplied by the caller as a
* <code>String</code>). The search begins at the specified index.
*
* @param searchstr The character pattern to search for, passed as a
* <code>String</code>.
* @param start. The index into the CLOB to start search (indexes start
* at 1).
* @return The index at which the pattern was found (indexes start at 1),
* or -1 if the pattern was not found.
* @exception SQLException If an error occurs.
* @since 1.2
*/
long position(String searchstr, long start) throws SQLException;
/**
* This method returns the index into the CLOB of the first occurrence of
* the specified character pattern (supplied by the caller as a
* <code>Clob</code>). The search begins at the specified index.
*
* @param searchstr The character pattern to search for, passed as a
* <code>Clob</code>.
* @param start. The index into the CLOB to start search (indexes start
* at 1).
* @return The index at which the pattern was found (indexes start at 1),
* or -1 if the pattern was not found.
* @exception SQLException If an error occurs.
* @since 1.2
*/
long position(Clob searchstr, long start) throws SQLException;
/**
* @since 1.4
*/
int setString(long pos, String str) throws SQLException;
/**
* @since 1.4
*/
int setString(long pos, String str, int offset, int len)
throws SQLException;
/**
* @since 1.4
*/
OutputStream setAsciiStream(long pos) throws SQLException;
/**
* @since 1.4
*/
Writer setCharacterStream(long pos) throws SQLException;
/**
* @since 1.4
*/
void truncate(long len) throws SQLException;
}

420
libjava/java/sql/Connection.java
View file

@ -1,420 +0,0 @@
/* Connection.java -- Manage a database connection.
Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.util.Map;
/**
* This interface provides methods for managing a connection to a database.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface Connection
{
/**
* This transaction isolation level indicates that transactions are not
* supported.
*/
int TRANSACTION_NONE = 0;
/**
* This transaction isolation level indicates that one transaction can
* read modifications by other transactions before the other transactions
* have committed their changes. This could result in invalid reads.
*/
int TRANSACTION_READ_UNCOMMITTED = 1;
/**
* This transaction isolation leve indicates that only committed data from
* other transactions will be read. If a transaction reads a row, then
* another transaction commits a change to that row, the first transaction
* would retrieve the changed row on subsequent reads of the same row.
*/
int TRANSACTION_READ_COMMITTED = 2;
/**
* This transaction isolation level indicates that only committed data from
* other transactions will be read. It also ensures that data read from
* a row will not be different on a subsequent read even if another
* transaction commits a change.
*/
int TRANSACTION_REPEATABLE_READ = 4;
/**
* This transaction isolation level indicates that only committed data from
* other transactions will be read. It also ensures that data read from
* a row will not be different on a subsequent read even if another
* transaction commits a change. Additionally, rows modified by other
* transactions will not affect the result set returned during subsequent
* executions of the same WHERE clause in this transaction.
*/
int TRANSACTION_SERIALIZABLE = 8;
/**
* This method creates a new SQL statement. The default result set type
* and concurrency will be used.
*
* @return A new <code>Statement</code> object.
* @exception SQLException If an error occurs.
* @see Statement
*/
Statement createStatement() throws SQLException;
/**
* This method creates a new <code>PreparedStatement</code> for the specified
* SQL string. This method is designed for use with parameterized
* statements. The default result set type and concurrency will be used.
*
* @param The SQL statement to use in creating this
* <code>PreparedStatement</code>.
* @return A new <code>PreparedStatement</code>.
* @exception SQLException If an error occurs.
* @see PreparedStatement
*/
PreparedStatement prepareStatement(String sql) throws SQLException;
/**
* This method creates a new <code>CallableStatement</code> for the
* specified SQL string. Thie method is designed to be used with
* stored procedures. The default result set type and concurrency
* will be used.
*
* @param The SQL statement to use in creating this
* <code>CallableStatement</code>.
* @return A new <code>CallableStatement</code>.
* @exception SQLException If an error occurs.
* @see CallableStatement
*/
CallableStatement prepareCall(String sql) throws SQLException;
/**
* This method converts the specified generic SQL statement into the
* native grammer of the database this object is connected to.
*
* @param The JDBC generic SQL statement.
* @return The native SQL statement.
* @exception SQLException If an error occurs.
*/
String nativeSQL(String sql) throws SQLException;
/**
* This method turns auto commit mode on or off. In auto commit mode,
* every SQL statement is committed its own transaction. Otherwise a
* transaction must be explicitly committed or rolled back.
*
* @param autoCommit <code>true</code> to enable auto commit mode,
* <code>false</code> to disable it.
* @exception SQLException If an error occurs.
* @see commit
* @see rollback
*/
void setAutoCommit(boolean autoCommit) throws SQLException;
/**
* This method tests whether or not auto commit mode is currently enabled.
* In auto commit mode, every SQL statement is committed its own transaction.
* Otherwise a transaction must be explicitly committed or rolled back.
*
* @return <code>true</code> if auto commit mode is enabled,
* <code>false</code> otherwise.
*
* @exception SQLException If an error occurs.
*
* @see commit
* @see rollback
*/
boolean getAutoCommit() throws SQLException;
/**
* This method commits any SQL statements executed on this connection since
* the last commit or rollback.
*
* @exception SQLException If an error occurs.
*/
void commit() throws SQLException;
/**
* This method rolls back any SQL statements executed on this connection
* since the last commit or rollback.
*
* @exception SQLException If an error occurs.
*/
void rollback() throws SQLException;
/**
* This method immediately closes this database connection.
*
* @exception SQLException If an error occurs.
*/
void close() throws SQLException;
/**
* This method tests whether or not this connection has been closed.
*
* @return <code>true</code> if the connection is closed, <code>false</code>
* otherwise.
* @exception SQLException If an error occurs.
*/
boolean isClosed() throws SQLException;
/**
* This method returns the meta data for this database connection.
*
* @return The meta data for this database.
* @exception SQLException If an error occurs.
* @see DatabaseMetaData
*/
DatabaseMetaData getMetaData() throws SQLException;
/**
* This method turns read only mode on or off. It may not be called while
* a transaction is in progress.
*
* @param readOnly <code>true</code> if this connection is read only,
* <code>false</code> otherwise.
* @exception SQLException If an error occurs.
*/
void setReadOnly(boolean readOnly) throws SQLException;
/**
* This method tests whether or not this connection is in read only mode.
*
* @return <code>true</code> if the connection is read only <code>false</code>
* otherwise.
* @exception SQLException If an error occurs.
*/
boolean isReadOnly() throws SQLException;
/**
* This method sets the name of the catalog in use by this connection.
* Note that this method does nothing if catalogs are not supported by
* this database.
*
* @param catalog The name of the catalog to use for this connection.
* @exception SQLException If an error occurs.
*/
void setCatalog(String catalog) throws SQLException;
/**
* This method returns the name of the catalog in use by this connection,
* if any.
*
* @return The name of the catalog, or <code>null</code> if one does not
* exist or catalogs are not supported by this database.
* @exception SQLException If an error occurs.
*/
String getCatalog() throws SQLException;
/**
* This method sets the current transaction isolation mode. This must
* be one of the constants defined in this interface.
*
* @param level The transaction isolation level.
* @exception SQLException If an error occurs.
*/
void setTransactionIsolation(int level) throws SQLException;
/**
* This method returns the current transaction isolation mode. This will
* be one of the constants defined in this interface.
*
* @return The transaction isolation level.
* @exception SQLException If an error occurs.
*/
int getTransactionIsolation() throws SQLException;
/**
* This method returns the first warning that occurred on this connection,
* if any. If there were any subsequence warnings, they will be chained
* to the first one.
*
* @return The first <code>SQLWarning</code> that occurred, or
* <code>null</code> if there have been no warnings.
* @exception SQLException If an error occurs.
*/
SQLWarning getWarnings() throws SQLException;
/**
* This method clears all warnings that have occurred on this connection.
*
* @exception SQLException If an error occurs.
*/
void clearWarnings() throws SQLException;
/**
* This method creates a new SQL statement with the specified type and
* concurrency. Valid values for these parameters are specified in the
* <code>ResultSet</code> class.
*
* @param resultSetType The type of result set to use for this statement.
* @param resultSetConcurrency. The type of concurrency to be used in
* the result set for this statement.
* @return A new <code>Statement</code> object.
* @exception SQLException If an error occurs.
* @see Statement
* @see ResultSet
*/
Statement createStatement(int resultSetType, int resultSetConcurrency)
throws SQLException;
/**
* This method creates a new <code>PreparedStatement</code> for the specified
* SQL string. This method is designed for use with parameterized
* statements. The specified result set type and concurrency will be used.
* Valid values for these parameters are specified in the
* <code>ResultSet</code> class.
*
* @param The SQL statement to use in creating this
* <code>PreparedStatement</code>.
* @param resultSetType The type of result set to use for this statement.
* @param resultSetConcurrency. The type of concurrency to be used in
* the result set for this statement.
* @return A new <code>PreparedStatement</code>.
* @exception SQLException If an error occurs.
* @see PreparedStatement
* @see ResultSet
*/
PreparedStatement prepareStatement(String sql, int resultSetType,
int resultSetConcurrency) throws SQLException;
/**
* This method creates a new <code>CallableStatement</code> for the
* specified SQL string. Thie method is designed to be used with
* stored procedures. The specified result set type and concurrency
* will be used. Valid values for these parameters are specified in the
* <code>ResultSet</code> class.
*
* @param The SQL statement to use in creating this
* <code>PreparedStatement</code>.
* @param resultSetType The type of result set to use for this statement.
* @param resultSetConcurrency. The type of concurrency to be used in
* the result set for this statement.
* @return A new <code>CallableStatement</code>.
* @exception SQLException If an error occurs.
* @see CallableStatement
* @see ResultSet
*/
CallableStatement prepareCall(String sql, int resultSetType, int
resultSetConcurrency) throws SQLException;
/**
* This method returns the mapping of SQL types to Java classes
* currently in use by this connection. This mapping will have no
* entries unless they have been manually added.
*
* @return The SQL type to Java class mapping.
* @exception SQLException If an error occurs.
*/
Map getTypeMap() throws SQLException;
/**
* This method sets the mapping table for SQL types to Java classes.
* Any entries in this map override the defaults.
*
* @param map The new SQL mapping table.
* @exception SQLException If an error occurs.
*/
void setTypeMap(Map map) throws SQLException;
/**
* @since 1.4
*/
void setHoldability(int holdability) throws SQLException;
/**
* @since 1.4
*/
int getHoldability() throws SQLException;
/**
* @since 1.4
*/
Savepoint setSavepoint() throws SQLException;
/**
* @since 1.4
*/
Savepoint setSavepoint(String name) throws SQLException;
/**
* @since 1.4
*/
void rollback(Savepoint savepoint) throws SQLException;
/**
* @since 1.4
*/
void releaseSavepoint(Savepoint savepoint) throws SQLException;
/**
* @since 1.4
*/
Statement createStatement(int resultSetType, int
resultSetConcurrency, int resultSetHoldability) throws SQLException;
/**
* @since 1.4
*/
PreparedStatement prepareStatement(String sql, int resultSetType, int
resultSetConcurrency, int resultSetHoldability) throws SQLException;
/**
* @since 1.4
*/
CallableStatement prepareCall(String sql, int resultSetType, int
resultSetConcurrency, int resultSetHoldability) throws SQLException;
/**
* @since 1.4
*/
PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
throws SQLException;
/**
* @since 1.4
*/
PreparedStatement prepareStatement(String sql, int[] columnIndexes)
throws SQLException;
/**
* @since 1.4
*/
PreparedStatement prepareStatement(String sql, String[] columnNames)
throws SQLException;
}

157
libjava/java/sql/DataTruncation.java
View file

@ -1,157 +0,0 @@
/* DataTruncation.java -- Warning when data has been truncated.
Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
/**
* This exception is thrown when a piece of data is unexpectedly
* truncated in JDBC.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class DataTruncation extends SQLWarning
{
static final long serialVersionUID = 6464298989504059473L;
/**
* The original size of the data.
*/
private int dataSize;
/**
* The index of the parameter or column whose value was truncated.
*/
private int index;
/**
* Indicates whether or not a parameter value was truncated.
*/
private boolean parameter;
/**
* Indicates whether or not a data column value was truncated.
*/
private boolean read;
/**
* This is the size of the data after truncation.
*/
private int transferSize;
/**
* This method initializes a new instance of <code>DataTruncation</code>
* with the specified values. The descriptive error message for this
* exception will be "Data truncation", the SQL state will be "01004"
* and the vendor specific error code will be set to 0.
*
* @param index The index of the parameter or column that was truncated.
* @param parameter <code>true</code> if a parameter was truncated,
* <code>false</code> otherwise.
* @param read <code>true</code> if a data column was truncated,
* <code>false</code> otherwise.
* @param dataSize The original size of the data.
* @param transferSize The size of the data after truncation.
*/
public DataTruncation(int index, boolean parameter, boolean read, int
dataSize, int transferSize)
{
super("Data truncation", "01004");
this.index = index;
this.parameter = parameter;
this.read = read;
this.dataSize = dataSize;
this.transferSize = transferSize;
}
/**
* This method returns the index of the column or parameter that was
* truncated.
*
* @return The index of the column or parameter that was truncated.
*/
public int getIndex()
{
return index;
}
/**
* This method determines whether or not it was a parameter that was
* truncated.
*
* @return <code>true</code> if a parameter was truncated, <code>false</code>
* otherwise.
*/
public boolean getParameter()
{
return parameter;
}
/**
* This method determines whether or not it was a column that was
* truncated.
*
* @return <code>true</code> if a column was truncated, <code>false</code>
* otherwise.
*/
public boolean getRead()
{
return read;
}
/**
* This method returns the original size of the parameter or column that
* was truncated.
*
* @return The original size of the parameter or column that was truncated.
*/
public int getDataSize()
{
return dataSize;
}
/**
* This method returns the size of the parameter or column after it was
* truncated.
*
* @return The size of the parameter or column after it was truncated.
*/
public int getTransferSize()
{
return transferSize;
}
}

2214
libjava/java/sql/DatabaseMetaData.java
View file

File diff suppressed because it is too large Load diff

188
libjava/java/sql/Date.java
View file

@ -1,188 +0,0 @@
/* Date.java -- Wrapper around java.util.Date
Copyright (C) 1999, 2000, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.text.ParseException;
import java.text.SimpleDateFormat;
/**
* This class is a wrapper around java.util.Date to allow the JDBC
* driver to identify the value as a SQL Date.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class Date extends java.util.Date
{
static final long serialVersionUID = 1511598038487230103L;
/**
* Used for parsing and formatting this date.
*/
private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
/**
* This method initializes a new instance of this class with the
* specified year, month, and day.
*
* @param year The year of this date minue 1900.
* @param month The month of this date (0-11).
* @param day The day of this date (1-31).
*
* @deprecated
*/
public Date(int year, int month, int day)
{
super(year, month, day);
}
/**
* This method initializes a new instance of this class with the
* specified time value representing the number of seconds since
* Jan 1, 1970 at 12:00 midnight GMT.
*
* @param time The time value to intialize this date to.
*/
public Date(long date)
{
super(date);
}
/**
* This method always throws an IllegalArgumentException.
*
* @throws IllegalArgumentException when it's called.
* @deprecated
*/
public int getHours() throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
/**
* This method always throws an IllegalArgumentException.
*
* @throws IllegalArgumentException when it's called.
* @deprecated
*/
public int getMinutes() throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
/**
* This method always throws an IllegalArgumentException.
*
* @throws IllegalArgumentException when it's called.
* @deprecated
*/
public int getSeconds() throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
/**
* This method always throws an IllegalArgumentException.
*
* @throws IllegalArgumentException when it's called.
* @deprecated
*/
public void setHours(int newValue) throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
/**
* This method always throws an IllegalArgumentException.
*
* @throws IllegalArgumentException when it's called.
* @deprecated
*/
public void setMinutes(int newValue) throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
/**
* This method always throws an IllegalArgumentException.
*
* @throws IllegalArgumentException when it's called.
* @deprecated
*/
public void setSeconds(int newValue) throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
/**
* This method returns a new instance of this class by parsing a
* date in JDBC format into a Java date.
*
* @param str The string to parse.
* @return The resulting <code>java.sql.Date</code> value.
*
* @deprecated
*/
public static Date valueOf (String str)
{
try
{
java.util.Date d = (java.util.Date) sdf.parseObject(str);
if (d == null)
throw new IllegalArgumentException(str);
else
return new Date(d.getTime());
}
catch (ParseException e)
{
throw new IllegalArgumentException(str);
}
}
/**
* This method returns this date in JDBC format.
*
* @return This date as a string.
*
* @deprecated
*/
public String toString()
{
return sdf.format(this);
}
}

123
libjava/java/sql/Driver.java
View file

@ -1,123 +0,0 @@
/* Driver.java -- A JDBC driver
Copyright (C) 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.util.Properties;
/**
* This interface specifies a mechanism for accessing a JDBC database
* driver. When the class implementing this method is loaded, it should
* register an instance of itself with the <code>DriverManager</code> in
* a static initializer.
* <p>
* Because the <code>DriverManager</code> might attempt to use several
* drivers to find one that can connect to the requested database,
* this driver should not cause large numbers of classes and code to
* be loaded. If another driver is the one that ends up performing the
* request, any loading done by this driver would be wasted.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface Driver
{
/**
* This method connects to the specified database using the connection
* properties supplied. If the driver does not understand the database
* URL, it should return <code>null</code> instead of throwing an
* exception since the <code>DriverManager</code> will probe a driver
* in this manner.
*
* @param url The URL string for this connection.
* @param properties The list of database connection properties.
* @return A <code>Connection</code> object for the newly established
* connection, or <code>null</code> if the URL is not understood.
* @exception SQLException If an error occurs.
*/
Connection connect(String url, Properties info) throws SQLException;
/**
* This method tests whether or not the driver believes it can connect to
* the specified database. The driver should only test whether it
* understands and accepts the URL. It should not necessarily attempt to
* probe the database for a connection.
*
* @param The database URL string.
* @return <code>true</code> if the drivers can connect to the database,
* <code>false</code> otherwise.
* @exception SQLException If an error occurs.
*/
boolean acceptsURL(String url) throws SQLException;
/**
* This method returns an array of possible properties that could be
* used to connect to the specified database.
*
* @param url The URL string of the database to connect to.
* @param properties The list of properties the caller is planning to use
* to connect to the database.
* @return A list of possible additional properties for a connection to this
* database. This list may be empty.
* @exception SQLException If an error occurs.
*/
DriverPropertyInfo[] getPropertyInfo(String url, Properties properties)
throws SQLException;
/**
* This method returns the major version number of the driver.
*
* @return The major version number of the driver.
*/
int getMajorVersion();
/**
* This method returns the minor version number of the driver.
*
* @return The minor version number of the driver.
*/
int getMinorVersion();
/**
* This method tests whether or not the driver is JDBC compliant. This
* method should only return <code>true</code> if the driver has been
* certified as JDBC compliant.
*
* @return <code>true</code> if the driver has been certified JDBC compliant,
* <code>false</code> otherwise.
*/
boolean jdbcCompliant();
}

346
libjava/java/sql/DriverManager.java
View file

@ -1,346 +0,0 @@
/* DriverManager.java -- Manage JDBC drivers
Copyright (C) 1999, 2000, 2001, 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Enumeration;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.Vector;
/**
* This class manages the JDBC drivers in the system. It maintains a
* registry of drivers and locates the appropriate driver to handle a
* JDBC database URL.
* <p>
* On startup, <code>DriverManager</code> loads all the managers specified
* by the system property <code>jdbc.drivers</code>. The value of this
* property should be a colon separated list of fully qualified driver
* class names. Additional drivers can be loaded at any time by
* simply loading the driver class with <code>class.forName(String)</code>.
* The driver should automatically register itself in a static
* initializer.
* <p>
* The methods in this class are all <code>static</code>. This class
* cannot be instantiated.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class DriverManager
{
/**
* This is the log stream for JDBC drivers.
*/
private static PrintStream log_stream;
/**
* This is the log writer for JDBC drivers.
*/
private static PrintWriter log_writer;
/**
* This is the login timeout used by JDBC drivers.
*/
private static int login_timeout;
/**
* This is the list of JDBC drivers that are loaded.
*/
private static Vector drivers;
// Hmm, seems like we might want to do a Hashtable and lookup by something,
// but what would it be?
// Load all drivers on startup
static
{
drivers = new Vector();
String driver_string = System.getProperty("jdbc.drivers");
if (driver_string != null)
{
StringTokenizer st = new StringTokenizer(driver_string);
while (st.hasMoreTokens())
{
String driver_classname = st.nextToken();
try
{
Class.forName(driver_classname); // The driver registers itself
}
catch (Exception e)
{
// Ignore not founds
}
}
}
}
/** Can't be instantiated. */
private DriverManager()
{
}
/**
* This method returns the log writer being used by all JDBC drivers.
* This method should be used in place of the deprecated
* <code>getLogStream</code> method.
*
* @return The log writer in use by JDBC drivers.
*/
public static PrintWriter getLogWriter()
{
return log_writer;
}
/**
* This method sets the log writer being used by JDBC drivers. This is a
* system-wide parameter that affects all drivers. Note that since there
* is no way to retrieve a <code>PrintStream</code> from a
* <code>PrintWriter</code>, this method cannot set the log stream in
* use by JDBC. Thus any older drivers may not see this setting.
*
* @param out The new log writer for JDBC.
*/
public static void setLogWriter(PrintWriter out)
{
DriverManager.log_writer = out;
}
/**
* This method attempts to return a connection to the specified
* JDBC URL string using the specified connection properties.
*
* @param url The JDBC URL string to connect to.
* @param properties The connection properties.
*
* @return A <code>Connection</code> to that URL.
*
* @exception SQLException If an error occurs.
*/
public static Connection getConnection(String url, Properties properties)
throws SQLException
{
Driver d = getDriver(url);
if (d == null)
throw new SQLException("Driver not found for URL: " + url);
return d.connect(url, properties);
}
/**
* This method attempts to return a connection to the specified
* JDBC URL string using the specified username and password.
*
* @param url The JDBC URL string to connect to.
* @param user The username to connect with.
* @param password The password to connect with.
* @return A <code>Connection</code> to that URL.
* @exception SQLException If an error occurs.
*/
public static Connection getConnection(String url, String user,
String password) throws SQLException
{
Properties p = new Properties();
if (user != null)
p.setProperty("user", user);
if (password != null)
p.setProperty("password", password);
return getConnection(url, p);
}
/**
* This method attempts to return a connection to the specified
* JDBC URL string.
*
* @param url The JDBC URL string to connect to.
*
* @return A <code>Connection</code> to that URL.
*
* @exception SQLException If an error occurs.
*/
public static Connection getConnection(String url) throws SQLException
{
return getConnection(url, new Properties());
}
/**
* This method returns a driver that can connect to the specified
* JDBC URL string. This will be selected from among drivers loaded
* at initialization time and those drivers manually loaded by the
* same class loader as the caller.
*
* @param url The JDBC URL string to find a driver for.
*
* @return A <code>Driver</code> that can connect to the specified
* URL.
*
* @exception SQLException If an error occurs, or no suitable driver can be found.
*/
public static Driver getDriver(String url) throws SQLException
{
// FIXME: Limit driver search to the appropriate subset of loaded drivers.
Enumeration e = drivers.elements();
while(e.hasMoreElements())
{
Driver d = (Driver)e.nextElement();
if (d.acceptsURL(url))
return d;
}
throw new SQLException("No driver found for " + url);
}
/**
* This method registers a new driver with the manager. This is normally
* called by the driver itself in a static initializer.
*
* @param driver The new <code>Driver</code> to add.
*
* @exception SQLException If an error occurs.
*/
public static void registerDriver(Driver driver) throws SQLException
{
if (! drivers.contains(driver))
drivers.addElement(driver);
}
/**
* This method de-registers a driver from the manager.
*
* @param driver The <code>Driver</code> to unregister.
*
* @exception SQLException If an error occurs.
*/
public static void deregisterDriver(Driver driver) throws SQLException
{
if (drivers.contains(driver))
drivers.removeElement(driver);
}
/**
* This method returns a list of all the currently registered JDBC drivers
* that were loaded by the current <code>ClassLoader</code>.
*
* @return An <code>Enumeration</code> of all currently loaded JDBC drivers.
*/
public static Enumeration getDrivers()
{
Vector v = new Vector();
Enumeration e = drivers.elements();
// Is this right?
ClassLoader cl = Thread.currentThread().getContextClassLoader();
while(e.hasMoreElements())
{
Object obj = e.nextElement();
ClassLoader loader = obj.getClass().getClassLoader();
if (loader == null)
loader = ClassLoader.getSystemClassLoader();
if (! loader.equals(cl))
continue;
v.addElement(obj);
}
return v.elements();
}
/**
* This method set the login timeout used by JDBC drivers. This is a
* system-wide parameter that applies to all drivers.
*
* @param login_timeout The new login timeout value.
*/
public static void setLoginTimeout(int seconds)
{
DriverManager.login_timeout = login_timeout;
}
/**
* This method returns the login timeout in use by JDBC drivers systemwide.
*
* @return The login timeout.
*/
public static int getLoginTimeout()
{
return login_timeout;
}
/**
* This method sets the log stream in use by JDBC.
*
* @param log_stream The log stream in use by JDBC.
*
* @deprecated Use <code>setLogWriter</code> instead.
*/
public static void setLogStream(PrintStream out)
{
DriverManager.log_stream = log_stream;
}
/**
* This method returns the log stream in use by JDBC.
*
* @return The log stream in use by JDBC.
*
* @deprecated Use <code>getLogWriter()</code> instead.
*/
public static PrintStream getLogStream()
{
return log_stream;
}
/**
* This method prints the specified line to the log stream.
*
* @param str The string to write to the log stream.
*/
public static void println(String message)
{
if (log_stream != null) // Watch for user not using logging
log_stream.println(message);
}
}

88
libjava/java/sql/DriverPropertyInfo.java
View file

@ -1,88 +0,0 @@
/* DriverPropertyInfo.java -- Property information about drivers.
Copyright (C) 1999 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
/**
* This class holds a driver property that can be used for querying or
* setting driver configuration parameters.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class DriverPropertyInfo
{
/**
* The name of the property.
*/
public String name;
/**
* A description of the property, possibly <code>null</code>.
*/
public String description;
/**
* A flag indicating whether or not a value for this property is required
* in order to connect to the database.
*/
public boolean required;
/**
* This is the value of the property.
*/
public String value;
/**
* If values are restricted to certain choices, this is the list of valid
* ones. Otherwise it is <code>null</code>.
*/
public String[] choices;
/**
* This method initializes a new instance of <code>DriverPropertyInfo</code>
* with the specified name and value. All other fields are defaulted.
*
* @param name The name of the property.
* @param value The value to assign to the property.
*/
public DriverPropertyInfo(String name, String value)
{
this.name = name;
this.value = value;
}
}

103
libjava/java/sql/ParameterMetaData.java
View file

@ -1,103 +0,0 @@
/* ParameterMetaData.java
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
/**
* @since 1.4
*/
public interface ParameterMetaData
{
int parameterNoNulls = 0;
int parameterNullable = 1;
int parameterNullableUnknown = 2;
int parameterModeUnknown = 0;
int parameterModeIn = 1;
int parameterModeInOut = 2;
int parameterModeOut = 4;
/**
* @since 1.4
*/
int getParameterCount() throws SQLException;
/**
* @since 1.4
*/
int isNullable(int param) throws SQLException;
/**
* @since 1.4
*/
boolean isSigned(int param) throws SQLException;
/**
* @since 1.4
*/
int getPrecision(int param) throws SQLException;
/**
* @since 1.4
*/
int getScale(int param) throws SQLException;
/**
* @since 1.4
*/
int getParameterType(int param) throws SQLException;
/**
* @since 1.4
*/
String getParameterTypeName(int param) throws SQLException;
/**
* @since 1.4
*/
String getParameterClassName(int param) throws SQLException;
/**
* @since 1.4
*/
int getParameterMode(int param) throws SQLException;
}

438
libjava/java/sql/PreparedStatement.java
View file

@ -1,438 +0,0 @@
/* PreparedStatement.java -- Interface for pre-compiled statements.
Copyright (C) 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.util.Calendar;
/**
* This interface provides a mechanism for executing pre-compiled
* statements. This provides greater efficiency when calling the same
* statement multiple times. Parameters are allowed in a statement,
* providings for maximum reusability.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface PreparedStatement extends Statement
{
/**
* This method executes a prepared SQL query and returns its ResultSet.
*
* @return The ResultSet of the SQL statement.
* @exception SQLException If an error occurs.
*/
ResultSet executeQuery() throws SQLException;
/**
* This method executes an SQL INSERT, UPDATE or DELETE statement. SQL
* statements that return nothing such as SQL DDL statements can be executed.
*
* @return The result is either the row count for INSERT, UPDATE or DELETE
* statements; or 0 for SQL statements that return nothing.
* @exception SQLException If an error occurs.
*/
int executeUpdate() throws SQLException;
/**
* This method populates the specified parameter with a SQL NULL value
* for the specified type.
*
* @param index The index of the parameter to set.
* @param type The SQL type identifier of the parameter from <code>Types</code>
*
* @exception SQLException If an error occurs.
*/
void setNull(int parameterIndex, int sqlType) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>boolean</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setBoolean(int parameterIndex, boolean x) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>byte</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setByte(int parameterIndex, byte x) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>short</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setShort(int parameterIndex, short x) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>int</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setInt(int parameterIndex, int x) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>long</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setLong(int parameterIndex, long x) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>float</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setFloat(int parameterIndex, float x) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>double</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setDouble(int parameterIndex, double x) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>java.math.BigDecimal</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setBigDecimal(int parameterIndex, BigDecimal x) throws
SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>String</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setString(int parameterIndex, String x) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>byte</code> array value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setBytes(int parameterIndex, byte[] x) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>java.sql.Date</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setDate(int parameterIndex, Date x) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>java.sql.Time</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setTime(int parameterIndex, Time x) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>java.sql.Timestamp</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setTimestamp(int parameterIndex, Timestamp x)
throws SQLException;
/**
* This method sets the specified parameter from the given Java
* ASCII <code>InputStream</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @param length The number of bytes in the stream.
* @exception SQLException If an error occurs.
*/
void setAsciiStream(int parameterIndex, InputStream x, int length)
throws SQLException;
/**
* This method sets the specified parameter from the given Java
* Unicode UTF-8 <code>InputStream</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @param length The number of bytes in the stream.
* @exception SQLException If an error occurs.
* @deprecated
*/
void setUnicodeStream(int parameterIndex, InputStream x, int length)
throws SQLException;
/**
* This method sets the specified parameter from the given Java
* binary <code>InputStream</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @param length The number of bytes in the stream.
* @exception SQLException If an error occurs.
*/
void setBinaryStream(int parameterIndex, InputStream x, int length)
throws SQLException;
/**
* This method clears all of the input parameter that have been
* set on this statement.
*
* @exception SQLException If an error occurs.
*/
void clearParameters() throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>Object</code> value. The specified SQL object type will be used.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @param type The SQL type to use for the parameter, from <code>Types</code>
* @param scale The scale of the value, for numeric values only.
* @exception SQLException If an error occurs.
* @see Types
*/
void setObject(int parameterIndex, Object x, int targetSqlType,
int scale) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>Object</code> value. The specified SQL object type will be used.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @param type The SQL type to use for the parameter, from <code>Types</code>
* @exception SQLException If an error occurs.
* @see Types
*/
void setObject(int parameterIndex, Object x, int targetSqlType)
throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>Object</code> value. The default object type to SQL type mapping
* will be used.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setObject(int parameterIndex, Object x) throws SQLException;
/**
* This method executes a prepared SQL query.
* Some prepared statements return multiple results; the execute method
* handles these complex statements as well as the simpler form of
* statements handled by executeQuery and executeUpdate.
*
* @return The result of the SQL statement.
* @exception SQLException If an error occurs.
*/
boolean execute() throws SQLException;
/**
* This method adds a set of parameters to the batch for JDBC 2.0.
* @exception SQLException If an error occurs.
*/
void addBatch() throws SQLException;
/**
* This method sets the specified parameter from the given Java
* character <code>Reader</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @param length The number of bytes in the stream.
* @exception SQLException If an error occurs.
*/
void setCharacterStream(int parameterIndex, Reader reader,
int length) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>Ref</code> value. The default object type to SQL type mapping
* will be used.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setRef(int i, Ref x) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>Blob</code> value. The default object type to SQL type mapping
* will be used.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setBlob(int i, Blob x) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>Clob</code> value. The default object type to SQL type mapping
* will be used.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setClob(int i, Clob x) throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>Array</code> value. The default object type to SQL type mapping
* will be used.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @exception SQLException If an error occurs.
*/
void setArray(int i, Array x) throws SQLException;
/**
* This method returns meta data for the result set from this statement.
*
* @return Meta data for the result set from this statement.
* @exception SQLException If an error occurs.
*/
ResultSetMetaData getMetaData() throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>java.sql.Date</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @param calendar The <code>Calendar</code> to use for timezone and locale.
* @exception SQLException If an error occurs.
*/
void setDate(int parameterIndex, Date x, Calendar cal)
throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>java.sql.Time</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @param calendar The <code>Calendar</code> to use for timezone and locale.
* @exception SQLException If an error occurs.
*/
void setTime(int parameterIndex, Time x, Calendar cal)
throws SQLException;
/**
* This method sets the specified parameter from the given Java
* <code>java.sql.Timestamp</code> value.
*
* @param index The index of the parameter value to set.
* @param value The value of the parameter.
* @param calendar The <code>Calendar</code> to use for timezone and locale.
* @exception SQLException If an error occurs.
*/
void setTimestamp(int parameterIndex, Timestamp x, Calendar cal)
throws SQLException;
/**
* This method populates the specified parameter with a SQL NULL value
* for the specified type.
*
* @param index The index of the parameter to set.
* @param type The SQL type identifier of the parameter from <code>Types</code>
* @param name The name of the data type, for user defined types.
* @exception SQLException If an error occurs.
*/
void setNull(int paramIndex, int sqlType, String typeName)
throws SQLException;
/**
* @since 1.4
*/
void setURL(int parameterIndex, URL x) throws SQLException;
/**
* @since 1.4
*/
ParameterMetaData getParameterMetaData() throws SQLException;
}

75
libjava/java/sql/Ref.java
View file

@ -1,75 +0,0 @@
/* Ref.java -- Reference to a SQL structured type.
Copyright (C) 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.util.Map;
/**
* This interface provides a mechanism for obtaining information about
* a SQL structured type
*
* @author Aaron M. Renn (arenn@urbanophile.com)
* @since 1.2
*/
public interface Ref
{
/**
* This method returns the fully qualified name of the SQL structured
* type of the referenced item.
*
* @return The fully qualified name of the SQL structured type.
* @exception SQLException If an error occurs.
* @since 1.2
*/
String getBaseTypeName() throws SQLException;
/**
* @since 1.4
*/
Object getObject(Map map) throws SQLException;
/**
* @since 1.4
*/
Object getObject() throws SQLException;
/**
* @since 1.4
*/
void setObject(Object value) throws SQLException;
}

1530
libjava/java/sql/ResultSet.java
View file

File diff suppressed because it is too large Load diff

281
libjava/java/sql/ResultSetMetaData.java
View file

@ -1,281 +0,0 @@
/* ResultSetMetaData.java -- Returns information about the ResultSet
Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
/**
* This interface provides a mechanism for obtaining information about
* the columns that are present in a <code>ResultSet</code>.
* <p>
* Note that in this class column indexes start at 1, not 0.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface ResultSetMetaData
{
/**
* The column does not allow NULL's.
*/
int columnNoNulls = 0;
/**
* The column allows NULL's.
*/
int columnNullable = 1;
/**
* It is unknown whether or not the column allows NULL's.
*/
int columnNullableUnknown = 2;
/**
* This method returns the number of columns in the result set.
*
* @return The number of columns in the result set.
* @exception SQLException If an error occurs.
*/
int getColumnCount() throws SQLException;
/**
* This method test whether or not the column is an auto-increment column.
* Auto-increment columns are read-only.
*
* @param index The index of the column to test.
* @return <code>true</code> if the column is auto-increment, <code>false</code>
* otherwise.
* @exception SQLException If an error occurs.
*/
boolean isAutoIncrement(int column) throws SQLException;
/**
* This method tests whether or not a column is case sensitive in its values.
*
* @param index The index of the column to test.
* @return <code>true</code> if the column value is case sensitive,
* <code>false</code> otherwise.
* @exception SQLException If an error occurs.
*/
boolean isCaseSensitive(int column) throws SQLException;
/**
* This method tests whether not the specified column can be used in
* a WHERE clause.
*
* @param index The index of the column to test.
* @return <code>true</code> if the column may be used in a WHERE clause,
* <code>false</code> otherwise.
* @exception SQLException If an error occurs.
*/
boolean isSearchable(int column) throws SQLException;
/**
* This method tests whether or not the column stores a monetary value.
*
* @param index The index of the column to test.
* @return <code>true</code> if the column contains a monetary value,
* <code>false</code> otherwise.
* @exception SQLException If an error occurs.
*/
boolean isCurrency(int column) throws SQLException;
/**
* This method returns a value indicating whether or not the specified
* column may contain a NULL value.
*
* @param index The index of the column to test.
* @return A constant indicating whether or not the column can contain NULL,
* which will be one of <code>columnNoNulls</code>,
* <code>columnNullable</code>, or <code>columnNullableUnknown</code>.
* @exception SQLException If an error occurs.
*/
int isNullable(int column) throws SQLException;
/**
* This method tests whether or not the value of the specified column
* is signed or unsigned.
*
* @param index The index of the column to test.
* @return <code>true</code> if the column value is signed, <code>false</code>
* otherwise.
* @exception SQLException If an error occurs.
*/
boolean isSigned(int column) throws SQLException;
/**
* This method returns the maximum number of characters that can be used
* to display a value in this column.
*
* @param index The index of the column to check.
* @return The maximum number of characters that can be used to display a
* value for this column.
* @exception SQLException If an error occurs.
*/
int getColumnDisplaySize(int column) throws SQLException;
/**
* This method returns a string that should be used as a caption for this
* column for user display purposes.
*
* @param index The index of the column to check.
* @return A display string for the column.
* @exception SQLException If an error occurs.
*/
String getColumnLabel(int column) throws SQLException;
/**
* This method returns the name of the specified column.
*
* @param index The index of the column to return the name of.
* @return The name of the column.
* @exception SQLException If an error occurs.
*/
String getColumnName(int column) throws SQLException;
/**
* This method returns the name of the schema that contains the specified
* column.
*
* @param index The index of the column to check the schema name for.
* @return The name of the schema that contains the column.
* @exception SQLException If an error occurs.
*/
String getSchemaName(int column) throws SQLException;
/**
* This method returns the precision of the specified column, which is the
* number of decimal digits it contains.
*
* @param index The index of the column to check the precision on.
* @return The precision of the specified column.
* @exception SQLException If an error occurs.
*/
int getPrecision(int column) throws SQLException;
/**
* This method returns the scale of the specified column, which is the
* number of digits to the right of the decimal point.
*
* @param index The index column to check the scale of.
* @return The scale of the column.
* @exception SQLException If an error occurs.
*/
int getScale(int column) throws SQLException;
/**
* This method returns the name of the table containing the specified
* column.
*
* @param index The index of the column to check the table name for.
* @return The name of the table containing the column.
* @exception SQLException If an error occurs.
*/
String getTableName(int column) throws SQLException;
/**
* This method returns the name of the catalog containing the specified
* column.
*
* @param index The index of the column to check the catalog name for.
* @return The name of the catalog containing the column.
* @exception SQLException If an error occurs.
*/
String getCatalogName(int column) throws SQLException;
/**
* This method returns the SQL type of the specified column. This will
* be one of the constants from <code>Types</code>.
*
* @param index The index of the column to check the SQL type of.
* @return The SQL type for this column.
* @exception SQLException If an error occurs.
* @see Types
*/
int getColumnType(int column) throws SQLException;
/**
* This method returns the name of the SQL type for this column.
*
* @param index The index of the column to check the SQL type name for.
* @return The name of the SQL type for this column.
* @exception SQLException If an error occurs.
*/
String getColumnTypeName(int column) throws SQLException;
/**
* This method tests whether or not the specified column is read only.
*
* @param index The index of the column to check.
* @return <code>true</code> if the column is read only, <code>false</code>
* otherwise.
* @exception SQLException If an error occurs.
*/
boolean isReadOnly(int column) throws SQLException;
/**
* This method tests whether or not the column may be writable. This
* does not guarantee that a write will be successful.
*
* @param index The index of the column to check for writability.
* @return <code>true</code> if the column may be writable,
* <code>false</code> otherwise.
* @exception SQLException If an error occurs.
*/
boolean isWritable(int column) throws SQLException;
/**
* This method tests whether or not the column is writable. This
* does guarantee that a write will be successful.
*
* @param index The index of the column to check for writability.
* @return <code>true</code> if the column is writable,
* <code>false</code> otherwise.
* @exception SQLException If an error occurs.
*/
boolean isDefinitelyWritable(int column) throws SQLException;
/**
* This method returns the name of the Java class which will be used to
* create objects representing the data in this column.
*
* @param index The index of the column to check.
* @return The name of the Java class that will be used for values in
* this column.
* @exception SQLException If an error occurs.
*/
String getColumnClassName(int column) throws SQLException;
}

72
libjava/java/sql/SQLData.java
View file

@ -1,72 +0,0 @@
/* SQLData.java -- Custom mapping for a user defined datatype
Copyright (C) 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
/**
* This interface is used for mapping SQL data to user defined datatypes.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface SQLData
{
/**
* This method returns the user defined datatype name for this object.
*
* @return The user defined data type name for this object.
* @exception SQLException If an error occurs.
*/
String getSQLTypeName() throws SQLException;
/**
* This method populates the data in the object from the specified stream.
*
* @param stream The stream to read the data from.
* @param name The data type name of the data on the stream.
* @exception SQLException If an error occurs.
*/
void readSQL(SQLInput stream, String typeName) throws SQLException;
/**
* This method writes the data in this object to the specified stream.
*
* @param stream The stream to write the data to.
* @exception SQLException If an error occurs.
*/
void writeSQL(SQLOutput stream) throws SQLException;
}

167
libjava/java/sql/SQLException.java
View file

@ -1,167 +0,0 @@
/* SQLException.java -- General SQL exception
Copyright (C) 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
/**
* This exception is thrown when a database error occurs.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class SQLException extends Exception
{
static final long serialVersionUID = 2135244094396331484L;
/**
* This is the next exception in the chain
*/
private SQLException next;
/**
* This is the state of the SQL statement at the time of the error.
*/
private String SQLState;
/**
* The vendor error code for this error
*/
private int vendorCode;
/**
* This method initializes a nwe instance of <code>SQLException</code>
* with the specified descriptive error message, SQL state string, and
* vendor code.
*
* @param message A string describing the nature of the error.
* @param SQLState A string containing the SQL state of the error.
* @param vendorCode The vendor error code associated with this error.
*/
public SQLException(String message, String SQLState, int vendorCode)
{
super(message);
this.SQLState = SQLState;
this.vendorCode = vendorCode;
}
/**
* This method initializes a new instance of <code>SQLException</code>
* with the specified descriptive error message and SQL state string.
* The vendor error code of this instance will be 0.
*
* @param message A string describing the nature of the error.
* @param SQLState A string containing the SQL state of the error.
*/
public SQLException(String message, String SQLState)
{
this(message, SQLState, 0);
}
/**
* This method initializes a new instance of <code>SQLException</code>
* with the specified descriptive error message. The SQL state of this
* instance will be <code>null</code> and the vendor error code will be 0.
*
* @param message A string describing the nature of the error.
*/
public SQLException(String message)
{
this(message, null, 0);
}
/**
* This method initializes a new instance of <code>SQLException</code>
* that does not have a descriptive messages and SQL state, and which
* has a vendor error code of 0.
*/
public SQLException()
{
this(null, null, 0);
}
/**
* This method returns the SQLState information associated with this
* error. The value returned is a <code>String</code> which is formatted
* using the XOPEN SQL state conventions.
*
* @return The SQL state, which may be <code>null</code>.
*/
public String getSQLState()
{
return SQLState;
}
/**
* This method returns the vendor specific error code associated with
* this error.
*
* @return The vendor specific error code associated with this error.
*/
public int getErrorCode()
{
return vendorCode;
}
/**
* This method returns the exception that is chained to this object.
*
* @return The exception chained to this object, which may be
* <code>null</code>.
*/
public SQLException getNextException()
{
return next;
}
/**
* This method adds a new exception to the end of the chain of exceptions
* that are chained to this object.
*
* @param e The exception to add to the end of the chain.
*/
public void setNextException(SQLException e)
{
if (e == null)
return;
SQLException list_entry = this;
while (list_entry.getNextException() != null)
list_entry = list_entry.getNextException();
list_entry.next = e;
}
}

259
libjava/java/sql/SQLInput.java
View file

@ -1,259 +0,0 @@
/* SQLInput.java -- Read SQL values from a stream
Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
/**
* This interface provides methods for reading values from a stream
* that is connected to a SQL structured or distinct type. It is used
* for custom mapping of user defined data types.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface SQLInput
{
/**
* This method reads the next item from the stream a Java
* <code>String</code>.
*
* @return The value read from the stream as a <code>String</code>.
* @exception SQLException If an error occurs.
*/
String readString() throws SQLException;
/**
* This method reads the next item from the stream a Java
* <code>boolean</code>.
*
* @return The value read from the stream as a <code>boolean</code>.
* @exception SQLException If an error occurs.
*/
boolean readBoolean() throws SQLException;
/**
* This method reads the next item from the stream a Java
* <code>byte</code>.
*
* @return The value read from the stream as a <code>byte</code>.
* @exception SQLException If an error occurs.
*/
byte readByte() throws SQLException;
/**
* This method reads the next item from the stream a Java
* <code>short</code>.
*
* @return The value read from the stream as a <code>short</code>.
* @exception SQLException If an error occurs.
*/
short readShort() throws SQLException;
/**
* This method reads the next item from the stream a Java
* <code>int</code>.
*
* @return The value read from the stream as an <code>int</code>.
* @exception SQLException If an error occurs.
*/
int readInt() throws SQLException;
/**
* This method reads the next item from the stream a Java
* <code>long</code>.
*
* @return The value read from the stream as a <code>long</code>.
* @exception SQLException If an error occurs.
*/
long readLong() throws SQLException;
/**
* This method reads the next item from the stream a Java
* <code>float</code>.
*
* @return The value read from the stream as a <code>float</code>.
* @exception SQLException If an error occurs.
*/
float readFloat() throws SQLException;
/**
* This method reads the next item from the stream a Java
* <code>double</code>.
*
* @return The value read from the stream as a <code>double</code>.
* @exception SQLException If an error occurs.
*/
double readDouble() throws SQLException;
/**
* This method reads the next item from the stream a Java
* <code>BigDecimal</code>.
*
* @return The value read from the stream as a <code>BigDecimal</code>.
* @exception SQLException If an error occurs.
*/
BigDecimal readBigDecimal() throws SQLException;
/**
* This method reads the next item from the stream a Java
* byte array
*
* @return The value read from the stream as a byte array.
* @exception SQLException If an error occurs.
*/
byte[] readBytes() throws SQLException;
/**
* This method reads the next item from the stream a Java
* <code>java.sql.Date</code>.
*
* @return The value read from the stream as a <code>java.sql.Date</code>.
* @exception SQLException If an error occurs.
*/
Date readDate() throws SQLException;
/**
* This method reads the next item from the stream a Java
* <code>java.sql.Time</code>.
*
* @return The value read from the stream as a <code>java.sql.Time</code>.
* @exception SQLException If an error occurs.
*/
Time readTime() throws SQLException;
/**
* This method reads the next item from the stream a Java
* <code>java.sql.Timestamp</code>.
*
* @return The value read from the stream as a <code>java.sql.Timestamp</code>.
* @exception SQLException If an error occurs.
*/
Timestamp readTimestamp() throws SQLException;
/**
* This method reads the next item from the stream a character
* <code>Reader</code>.
*
* @return The value read from the stream as a <code>Reader</code>.
* @exception SQLException If an error occurs.
*/
Reader readCharacterStream() throws SQLException;
/**
* This method reads the next item from the stream a ASCII text
* <code>InputStream</code>.
*
* @return The value read from the stream as an <code>InputStream</code>.
* @exception SQLException If an error occurs.
*/
InputStream readAsciiStream() throws SQLException;
/**
* This method reads the next item from the stream a binary
* <code>InputStream</code>.
*
* @return The value read from the stream as an <code>InputStream</code>.
* @exception SQLException If an error occurs.
*/
InputStream readBinaryStream() throws SQLException;
/**
* This method reads the next item from the stream a Java
* <code>Object</code>.
*
* @return The value read from the stream as an <code>Object</code>.
* @exception SQLException If an error occurs.
*/
Object readObject() throws SQLException;
/**
* This method reads the next item from the stream a Java SQL
* <code>Ref</code>.
*
* @return The value read from the stream as an <code>Ref</code>.
* @exception SQLException If an error occurs.
*/
Ref readRef() throws SQLException;
/**
* This method reads the next item from the stream a Java SQL
* <code>Blob</code>.
*
* @return The value read from the stream as a <code>Blob</code>.
* @exception SQLException If an error occurs.
*/
Blob readBlob() throws SQLException;
/**
* This method reads the next item from the stream a Java SQL
* <code>Clob</code>.
*
* @return The value read from the stream as a <code>Clob</code>.
* @exception SQLException If an error occurs.
*/
Clob readClob() throws SQLException;
/**
* This method reads the next item from the stream a Java SQL
* <code>Array</code>.
*
* @return The value read from the stream as an <code>Array</code>.
* @exception SQLException If an error occurs.
*/
Array readArray() throws SQLException;
/**
* This method tests whether or not the last value read was a SQL
* NULL value.
*
* @return <code>true</code> if the last value read was a NULL,
* <code>false</code> otherwise.
* @exception SQLException If an error occurs.
*/
boolean wasNull() throws SQLException;
/**
* @since 1.4
*/
URL readURL() throws SQLException;
}

257
libjava/java/sql/SQLOutput.java
View file

@ -1,257 +0,0 @@
/* SQLOutput.java -- Write SQL values to a stream
Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
/**
* This interface provides methods for writing Java types to a SQL stream.
* It is used for implemented custom type mappings for user defined data
* types.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface SQLOutput
{
/**
* This method writes the specified Java <code>String</code>
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeString(String x) throws SQLException;
/**
* This method writes the specified Java <code>boolean</code>
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeBoolean(boolean x) throws SQLException;
/**
* This method writes the specified Java <code>byte</code>
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeByte(byte x) throws SQLException;
/**
* This method writes the specified Java <code>short</code>
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeShort(short x) throws SQLException;
/**
* This method writes the specified Java <code>int</code>
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeInt(int x) throws SQLException;
/**
* This method writes the specified Java <code>long</code>
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeLong(long x) throws SQLException;
/**
* This method writes the specified Java <code>float</code>
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeFloat(float x) throws SQLException;
/**
* This method writes the specified Java <code>double</code>
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeDouble(double x) throws SQLException;
/**
* This method writes the specified Java <code>BigDecimal</code>
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeBigDecimal(BigDecimal x) throws SQLException;
/**
* This method writes the specified Java <code>byte</code> array
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeBytes(byte[] x) throws SQLException;
/**
* This method writes the specified Java <code>java.sql.Date</code>
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeDate(Date x) throws SQLException;
/**
* This method writes the specified Java <code>java.sql.Time</code>
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeTime(Time x) throws SQLException;
/**
* This method writes the specified Java <code>java.sql.Timestamp</code>
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeTimestamp(Timestamp x) throws SQLException;
/**
* This method writes the specified Java character stream
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeCharacterStream(Reader x) throws SQLException;
/**
* This method writes the specified ASCII text stream
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeAsciiStream(InputStream x) throws SQLException;
/**
* This method writes the specified uninterpreted binary byte stream
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeBinaryStream(InputStream x) throws SQLException;
/**
* This method writes the specified Java <code>SQLData</code> object
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeObject(SQLData x) throws SQLException;
/**
* This method writes the specified Java SQL <code>Ref</code> object
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeRef(Ref x) throws SQLException;
/**
* This method writes the specified Java SQL <code>Blob</code> object
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeBlob(Blob x) throws SQLException;
/**
* This method writes the specified Java SQL <code>Clob</code> object
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeClob(Clob x) throws SQLException;
/**
* This method writes the specified Java SQL <code>Struct</code> object
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeStruct(Struct x) throws SQLException;
/**
* This method writes the specified Java SQL <code>Array</code> object
* to the SQL stream.
*
* @param value The value to write to the stream.
* @exception SQLException If an error occurs.
*/
void writeArray(Array x) throws SQLException;
/**
* @since 1.4
*/
void writeURL(URL x) throws SQLException;
}

57
libjava/java/sql/SQLPermission.java
View file

@ -1,57 +0,0 @@
/* SQLPermission.java
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.security.BasicPermission;
/**
* @since 1.3
*/
public final class SQLPermission extends BasicPermission
{
public SQLPermission(String name)
{
super(name);
}
public SQLPermission(String name, String actions)
{
super(name, actions);
}
}

120
libjava/java/sql/SQLWarning.java
View file

@ -1,120 +0,0 @@
/* SQLWarning.java -- Database access warnings.
Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
/**
* This exception is thrown when a database warning occurs.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class SQLWarning extends SQLException
{
static final long serialVersionUID = 3917336774604784856L;
/**
* This method initializes a nwe instance of <code>SQLWarning</code>
* with the specified descriptive error message, SQL state string, and
* vendor code.
*
* @param message A string describing the nature of the error.
* @param SQLState A string containing the SQL state of the error.
* @param vendorCode The vendor error code associated with this error.
*/
public SQLWarning(String reason, String SQLState, int vendorCode)
{
super(reason, SQLState, vendorCode);
}
/**
* This method initializes a new instance of <code>SQLWarning</code>
* with the specified descriptive error message and SQL state string.
* The vendor error code of this instance will be 0.
*
* @param message A string describing the nature of the error.
* @param SQLState A string containing the SQL state of the error.
*/
public SQLWarning(String message, String SQLState)
{
super(message, SQLState);
}
/**
* This method initializes a new instance of <code>SQLWarning</code>
* with the specified descriptive error message. The SQL state of this
* instance will be <code>null</code> and the vendor error code will be 0.
*
* @param message A string describing the nature of the error.
*/
public SQLWarning(String message)
{
super(message);
}
/**
* This method initializes a new instance of <code>SQLWarning</code>
* that does not have a descriptive messages and SQL state, and which
* has a vendor error code of 0.
*/
public SQLWarning()
{
super();
}
/**
* This method returns the exception that is chained to this object.
*
* @return The exception chained to this object, which may be
* <code>null</code>.
*/
public SQLWarning getNextWarning()
{
return (SQLWarning) super.getNextException();
}
/**
* This method adds a new exception to the end of the chain of exceptions
* that are chained to this object.
*
* @param w The exception to add to the end of the chain.
*/
public void setNextWarning(SQLWarning w)
{
super.setNextException(w);
}
}

55
libjava/java/sql/Savepoint.java
View file

@ -1,55 +0,0 @@
/* SavePoint.java -- Returns information about the ResultSet
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
/**
* @since 1.4
*/
public interface Savepoint
{
/**
* @since 1.4
*/
int getSavepointId() throws SQLException;
/**
* @since 1.4
*/
String getSavepointName() throws SQLException;
}

366
libjava/java/sql/Statement.java
View file

@ -1,366 +0,0 @@
/* Statement.java -- Interface for executing SQL statements.
Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
/**
* This interface provides a mechanism for executing SQL statements.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface Statement
{
int CLOSE_CURRENT_RESULT = 1;
int KEEP_CURRENT_RESULT = 2;
int CLOSE_ALL_RESULTS = 3;
int SUCCESS_NO_INFO = -2;
int EXECUTE_FAILED = -3;
int RETURN_GENERATED_KEYS = 1;
int NO_GENERATED_KEYS = 2;
/**
* This method executes the specified SQL SELECT statement and returns a
* (possibly empty) <code>ResultSet</code> with the results of the query.
*
* @param sql The SQL statement to execute.
* @return The result set of the SQL statement.
* @exception SQLException If an error occurs.
*/
ResultSet executeQuery(String sql) throws SQLException;
/**
* This method executes the specified SQL INSERT, UPDATE, or DELETE statement
* and returns the number of rows affected, which may be 0.
*
* @param sql The SQL statement to execute.
* @return The number of rows affected by the SQL statement.
* @exception SQLException If an error occurs.
*/
int executeUpdate(String sql) throws SQLException;
/**
* This method closes the statement and frees any associated resources.
*
* @exception SQLException If an error occurs.
*/
void close() throws SQLException;
/**
* This method returns the maximum length of any column value in bytes.
*
* @return The maximum length of any column value in bytes.
* @exception SQLException If an error occurs.
*/
int getMaxFieldSize() throws SQLException;
/**
* This method sets the limit for the maximum length of any column in bytes.
*
* @param maxsize The new maximum length of any column in bytes.
* @exception SQLException If an error occurs.
*/
void setMaxFieldSize(int max) throws SQLException;
/**
* This method returns the maximum possible number of rows in a result set.
*
* @return The maximum possible number of rows in a result set.
* @exception SQLException If an error occurs.
*/
int getMaxRows() throws SQLException;
/**
* This method sets the maximum number of rows that can be present in a
* result set.
*
* @param maxrows The maximum possible number of rows in a result set.
* @exception SQLException If an error occurs.
*/
void setMaxRows(int max) throws SQLException;
/**
* This method sets the local escape processing mode on or off. The
* default value is on.
*
* @param escape <code>true</code> to enable local escape processing,
* <code>false</code> to disable it.
* @exception SQLException If an error occurs.
*/
void setEscapeProcessing(boolean enable) throws SQLException;
/**
* The method returns the number of seconds a statement may be in process
* before timing out. A value of 0 means there is no timeout.
*
* @return The SQL statement timeout in seconds.
* @exception SQLException If an error occurs.
*/
int getQueryTimeout() throws SQLException;
/**
* This method sets the number of seconds a statement may be in process
* before timing out. A value of 0 means there is no timeout.
*
* @param timeout The new SQL statement timeout value.
* @exception SQLException If an error occurs.
*/
void setQueryTimeout(int seconds) throws SQLException;
/**
* This method cancels an outstanding statement, if the database supports
* that operation.
*
* @exception SQLException If an error occurs.
*/
void cancel() throws SQLException;
/**
* This method returns the first SQL warning attached to this statement.
* Subsequent warnings will be chained to this one.
*
* @return The first SQL warning for this statement.
* @exception SQLException If an error occurs.
*/
SQLWarning getWarnings() throws SQLException;
/**
* This method clears any SQL warnings that have been attached to this
* statement.
*
* @exception SQLException If an error occurs.
*/
void clearWarnings() throws SQLException;
/**
* This method sets the cursor name that will be used by the result set.
*
* @param name The cursor name to use for this statement.
* @exception SQLException If an error occurs.
*/
void setCursorName(String name) throws SQLException;
/**
* This method executes an arbitrary SQL statement of any time. The
* methods <code>getResultSet</code>, <code>getMoreResults</code> and
* <code>getUpdateCount</code> retrieve the results.
*
* @return <code>true</code> if a result set was returned, <code>false</code>
* if an update count was returned.
* @exception SQLException If an error occurs.
*/
boolean execute(String sql) throws SQLException;
/**
* This method returns the result set of the SQL statement that was
* executed. This should be called only once per result set returned.
*
* @return The result set of the query, or <code>null</code> if there was
* no result set (for example, if the statement was an UPDATE).
* @exception SQLException If an error occurs.
* @see execute
*/
ResultSet getResultSet() throws SQLException;
/**
* This method returns the update count of the SQL statement that was
* executed. This should be called only once per executed SQL statement.
*
* @return The update count of the query, or -1 if there was no update
* count (for example, if the statement was a SELECT).
* @exception SQLException If an error occurs.
* @see execute
*/
int getUpdateCount() throws SQLException;
/**
* This method advances the result set pointer to the next result set,
* which can then be retrieved using <code>getResultSet</code>
*
* @return <code>true</code> if there is another result set,
* <code>false</code> otherwise (for example, the next result is an
* update count).
* @exception SQLException If an error occurs.
* @see execute
*/
boolean getMoreResults() throws SQLException;
/**
* This method informs the driver which direction the result set will
* be accessed in.
*
* @param direction The direction the result set will be accessed in (?????)
* @exception SQLException If an error occurs.
*/
void setFetchDirection(int direction) throws SQLException;
/**
* This method returns the current direction that the driver thinks the
* result set will be accessed int.
*
* @return The direction the result set will be accessed in (????)
* @exception SQLException If an error occurs.
*/
int getFetchDirection() throws SQLException;
/**
* This method informs the driver how many rows it should fetch from the
* database at a time.
*
* @param numrows The number of rows the driver should fetch at a time
* to populate the result set.
* @exception SQLException If an error occurs.
*/
void setFetchSize(int rows) throws SQLException;
/**
* This method returns the number of rows the driver believes should be
* fetched from the database at a time.
*
* @return The number of rows that will be fetched from the database at a time.
* @exception SQLException If an error occurs.
*/
int getFetchSize() throws SQLException;
/**
* This method returns the concurrency type of the result set for this
* statement. This will be one of the concurrency types defined in
* <code>ResultSet</code>.
*
* @return The concurrency type of the result set for this statement.
* @exception SQLException If an error occurs.
* @see ResultSet
*/
int getResultSetConcurrency() throws SQLException;
/**
* This method returns the result set type for this statement. This will
* be one of the result set types defined in <code>ResultSet</code>.
*
* @return The result set type for this statement.
* @exception SQLException If an error occurs.
* @see ResultSet
*/
int getResultSetType() throws SQLException;
/**
* This method adds a SQL statement to a SQL batch. A driver is not
* required to implement this method.
*
* @param sql The sql statement to add to the batch.
* @exception SQLException If an error occurs.
*/
void addBatch(String sql) throws SQLException;
/**
* This method clears out any SQL statements that have been populated in
* the current batch. A driver is not required to implement this method.
*
* @exception SQLException If an error occurs.
*/
void clearBatch() throws SQLException;
/**
* This method executes the SQL batch and returns an array of update
* counts - one for each SQL statement in the batch - ordered in the same
* order the statements were added to the batch. A driver is not required
* to implement this method.
*
* @return An array of update counts for this batch.
* @exception SQLException If an error occurs.
*/
int[] executeBatch() throws SQLException;
/**
* This method returns the <code>Connection</code> instance that was
* used to create this object.
*
* @return The connection used to create this object.
* @exception SQLException If an error occurs.
*/
Connection getConnection() throws SQLException;
/**
* @since 1.4
*/
boolean getMoreResults(int current) throws SQLException;
/**
* @since 1.4
*/
ResultSet getGeneratedKeys() throws SQLException;
/**
* @since 1.4
*/
int executeUpdate(String sql, int autoGeneratedKeys)
throws SQLException;
/**
* @since 1.4
*/
int executeUpdate(String sql, int[] columnIndexes)
throws SQLException;
/**
* @since 1.4
*/
int executeUpdate(String sql, String[] columnNames)
throws SQLException;
/**
* @since 1.4
*/
boolean execute(String sql, int autoGeneratedKeys)
throws SQLException;
/**
* @since 1.4
*/
boolean execute(String sql, int[] columnIndexes) throws SQLException;
/**
* @since 1.4
*/
boolean execute(String sql, String[] columnNames)
throws SQLException;
/**
* @since 1.4
*/
int getResultSetHoldability() throws SQLException;
}

77
libjava/java/sql/Struct.java
View file

@ -1,77 +0,0 @@
/* Struct.java -- Mapping for a SQL structured type.
Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.util.Map;
/**
* This interface implements the standard type mapping for a SQL
* structured type.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface Struct
{
/**
* This method returns the name of the SQL structured type for this
* object.
*
* @return The SQL structured type name.
* @exception SQLException If an error occurs.
*/
String getSQLTypeName() throws SQLException;
/**
* This method returns the attributes of this SQL structured type.
*
* @return The attributes of this structure type.
* @exception SQLException If an error occurs.
*/
Object[] getAttributes() throws SQLException;
/**
* This method returns the attributes of this SQL structured type.
* The specified map of type mappings overrides the default mappings.
*
* @param map The map of SQL type mappings.
* @return The attributes of this structure type.
* @exception SQLException If a error occurs.
*/
Object[] getAttributes(Map map) throws SQLException;
}

205
libjava/java/sql/Time.java
View file

@ -1,205 +0,0 @@
/* Time.java -- Wrapper around java.util.Date
Copyright (C) 1999, 2000, 2002, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.text.ParseException;
import java.text.SimpleDateFormat;
/**
* This class is a wrapper around java.util.Date to allow the JDBC
* driver to identify the value as a SQL Time.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class Time extends java.util.Date
{
static final long serialVersionUID = 8397324403548013681L;
/**
* Used for parsing and formatting this date.
*/
private static SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
/**
* This method always throws an IllegalArgumentException.
*
* @throws IllegalArgumentException when it's called.
* @deprecated
*/
public int getDate() throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
/**
* This method always throws an IllegalArgumentException.
*
* @throws IllegalArgumentException when it's called.
* @deprecated
*/
public int getDay() throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
/**
* This method always throws an IllegalArgumentException.
*
* @throws IllegalArgumentException when it's called.
* @deprecated
*/
public int getMonth() throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
/**
* This method always throws an IllegalArgumentException.
*
* @throws IllegalArgumentException when it's called.
* @deprecated
*/
public int getYear() throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
/**
* This method always throws an IllegalArgumentException.
*
* @throws IllegalArgumentException when it's called.
* @deprecated
*/
public void setDate(int newValue) throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
/**
* This method always throws an IllegalArgumentException.
*
* @throws IllegalArgumentException when it's called.
* @deprecated
*/
public void setMonth(int newValue) throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
/**
* This method always throws an IllegalArgumentException.
*
* @throws IllegalArgumentException when it's called.
* @deprecated
*/
public void setYear(int newValue) throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
/**
* This method returns a new instance of this class by parsing a
* date in JDBC format into a Java date.
*
* @param str The string to parse.
* @return The resulting <code>java.sql.Time</code> value.
*
* @deprecated
*/
public static Time valueOf (String str)
{
try
{
java.util.Date d = (java.util.Date) sdf.parseObject(str);
if (d == null)
throw new IllegalArgumentException(str);
else
return new Time(d.getTime());
}
catch (ParseException e)
{
throw new IllegalArgumentException(str);
}
}
/**
* This method initializes a new instance of this class with the
* specified year, month, and day.
*
* @param hour The hour for this Time (0-23)
* @param minute The minute for this time (0-59)
* @param second The second for this time (0-59)
* @deprecated
*/
public Time(int hour, int minute, int second)
{
super(System.currentTimeMillis());
setHours(hour);
setMinutes(minute);
setSeconds(second);
}
/**
* This method initializes a new instance of this class with the
* specified time value representing the number of seconds since
* Jan 1, 1970 at 12:00 midnight GMT.
*
* @param time The time value to intialize this <code>Time</code> to.
*/
public Time(long date)
{
super(date);
}
/**
* This method returns this date in JDBC format.
*
* @return This date as a string.
*
* @deprecated
*/
public String toString ()
{
return sdf.format (this);
}
}

315
libjava/java/sql/Timestamp.java
View file

@ -1,315 +0,0 @@
/* Time.java -- Wrapper around java.util.Date
Copyright (C) 1999, 2000, 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
/**
* This class is a wrapper around java.util.Date to allow the JDBC
* driver to identify the value as a SQL Timestamp. Note that this
* class also adds an additional field for nano-seconds, and so
* is not completely identical to <code>java.util.Date</code> as
* the <code>java.sql.Date</code> and <code>java.sql.Time</code>
* classes are.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class Timestamp extends java.util.Date
{
static final long serialVersionUID = 2745179027874758501L;
/**
* Used for parsing and formatting this date.
*/
private static SimpleDateFormat dateFormat =
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
private static DecimalFormat decimalFormat = new DecimalFormat("000000000");
private static StringBuffer sbuf = new StringBuffer(29);
/**
* The nanosecond value for this object
*/
private int nanos;
/**
* This method returns a new instance of this class by parsing a
* date in JDBC format into a Java date.
*
* @param str The string to parse.
* @return The resulting <code>java.sql.Timestamp</code> value.
*/
public static Timestamp valueOf(String str)
{
int nanos = 0;
int dot = str.indexOf('.');
if (dot != -1)
{
if (str.lastIndexOf('.') != dot)
throw new IllegalArgumentException(str);
int len = str.length() - dot - 1;
if (len < 1 || len > 9)
throw new IllegalArgumentException(str);
nanos = Integer.parseInt(str.substring(dot + 1));
for (int i = len; i < 9; i++)
nanos *= 10;
str = str.substring(0, dot);
}
try
{
java.util.Date d;
synchronized (dateFormat)
{
d = (java.util.Date) dateFormat.parseObject(str);
}
if (d == null)
throw new IllegalArgumentException(str);
Timestamp ts = new Timestamp(d.getTime() + nanos / 1000000);
ts.nanos = nanos;
return ts;
}
catch (ParseException e)
{
throw new IllegalArgumentException(str);
}
}
/**
* This method initializes a new instance of this class with the
* specified year, month, and day.
*
* @param year The year for this Timestamp (year - 1900)
* @param month The month for this Timestamp (0-11)
* @param day The day for this Timestamp (1-31)
* @param hour The hour for this Timestamp (0-23)
* @param minute The minute for this Timestamp (0-59)
* @param second The second for this Timestamp (0-59)
* @param nanos The nanosecond value for this Timestamp (0 to 999,999,9999)
* @deprecated
*/
public Timestamp(int year, int month, int day, int hour, int minute,
int second, int nanos)
{
super(year, month, day, hour, minute, second);
this.nanos = nanos;
}
/**
* This method initializes a new instance of this class with the
* specified time value representing the number of milliseconds since
* Jan 1, 1970 at 12:00 midnight GMT.
*
* @param time The time value to intialize this <code>Time</code> to.
*/
public Timestamp(long date)
{
super(date - (date % 1000));
nanos = (int) (date % 1000) * 1000000;
}
/**
* Return the value of this Timestamp as the number of milliseconds
* since Jan 1, 1970 at 12:00 midnight GMT.
*/
public long getTime()
{
return super.getTime() + (nanos / 1000000);
}
/**
* This method returns this date in JDBC format.
*
* @return This date as a string.
*/
public String toString()
{
synchronized (dateFormat)
{
sbuf.setLength(0);
dateFormat.format(this, sbuf, null);
sbuf.append('.');
decimalFormat.format(nanos, sbuf, null);
int end = sbuf.length() - 1;
while (end > 20 && sbuf.charAt(end) == '0')
end--;
return sbuf.substring(0, end + 1);
}
}
/**
* This method returns the nanosecond value for this object.
* @return The nanosecond value for this object.
*/
public int getNanos()
{
return nanos;
}
/**
* This method sets the nanosecond value for this object.
*
* @param nanos The nanosecond value for this object.
*/
public void setNanos(int nanos)
{
this.nanos = nanos;
}
/**
* This methods tests whether this object is earlier than the specified
* object.
*
* @param ts The other <code>Timestamp</code> to test against.
* @return <code>true</code> if this object is earlier than the other object,
* <code>false</code> otherwise.
*/
public boolean before(Timestamp ts)
{
long time1 = getTime();
long time2 = ts.getTime();
if (time1 < time2 || (time1 == time2 && getNanos() < ts.getNanos()))
return true;
return false;
}
/**
* This methods tests whether this object is later than the specified
* object.
*
* @param ts The other <code>Timestamp</code> to test against.
*
* @return <code>true</code> if this object is later than the other object,
* <code>false</code> otherwise.
*/
public boolean after(Timestamp ts)
{
long time1 = getTime();
long time2 = ts.getTime();
if (time1 > time2 || (time1 == time2 && getNanos() > ts.getNanos()))
return true;
return false;
}
/**
* This method these the specified <code>Object</code> for equality
* against this object. This will be true if an only if the specified
* object is an instance of <code>Timestamp</code> and has the same
* time value fields.
*
* @param obj The object to test against for equality.
*
* @return <code>true</code> if the specified object is equal to this
* object, <code>false</code> otherwise.
*/
public boolean equals(Object obj)
{
if (!(obj instanceof Timestamp))
return false;
return equals((Timestamp) obj);
}
/**
* This method tests the specified timestamp for equality against this
* object. This will be true if and only if the specified object is
* not <code>null</code> and contains all the same time value fields
* as this object.
*
* @param ts The <code>Timestamp</code> to test against for equality.
*
* @return <code>true</code> if the specified object is equal to this
* object, <code>false</code> otherwise.
*/
public boolean equals(Timestamp ts)
{
if (ts == null)
return false;
if (ts.getTime() != getTime())
return false;
if (ts.getNanos() != getNanos())
return false;
return true;
}
/**
* Compare two Timestamp
* @param when the other Timestamp.
* @return 0, if the date represented
* by obj is exactly the same as the time represented by this
* object, a negative if this Timestamp is before the other Timestamp, and
* a positive value otherwise.
* @since 1.2
*/
public int compareTo(Timestamp ts)
{
int s = super.compareTo((java.util.Date) ts);
if (s != 0)
return s;
// If Date components were equal, then we check the nanoseconds.
return nanos - ts.nanos;
}
/**
* Compares this Timestamp to another. This behaves like
* <code>compareTo(Timestamp)</code>, but it may throw a
* <code>ClassCastException</code>
* @param obj the other Timestamp.
* @return 0, if the Timestamp represented
* by obj is exactly the same as the time represented by this
* object, a negative if this Timestamp is before the other Timestamp, and
* a positive value otherwise.
* @exception ClassCastException if obj is not of type Timestamp.
* @since 1.2
*/
public int compareTo(Object obj)
{
return compareTo((Timestamp) obj);
}
}

85
libjava/java/sql/Types.java
View file

@ -1,85 +0,0 @@
/* Types.java -- SQL type constants
Copyright (C) 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.sql;
/**
* This class contains constants that are used to identify SQL data types.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class Types
{
// These should be self explanatory. People need a SQL book, not
// Javadoc comments for these.
public static final int BIT = -7;
public static final int TINYINT = -6;
public static final int SMALLINT = 5;
public static final int INTEGER = 4;
public static final int BIGINT = -5;
public static final int FLOAT = 6;
public static final int REAL = 7;
public static final int DOUBLE = 8;
public static final int NUMERIC = 2;
public static final int DECIMAL = 3;
public static final int CHAR = 1;
public static final int VARCHAR = 12;
public static final int LONGVARCHAR = -1;
public static final int DATE = 91;
public static final int TIME = 92;
public static final int TIMESTAMP = 93;
public static final int BINARY = -2;
public static final int VARBINARY = -3;
public static final int LONGVARBINARY = -4;
public static final int NULL = 0;
public static final int OTHER = 1111;
public static final int JAVA_OBJECT = 2000;
public static final int DISTINCT = 2001;
public static final int STRUCT = 2002;
public static final int ARRAY = 2003;
public static final int BLOB = 2004;
public static final int CLOB = 2005;
public static final int REF = 2006;
public static final int DATALINK = 70;
public static final int BOOLEAN = 16;
// This class can't be instantiated.
private Types()
{
}
}