Skip to content

D
dragonwell8_jdk

openanolis / dragonwell8_jdk

通知 4
Star 2
Fork 0
D
dragonwell8_jdk
提交 a9a95392 编写于 作者: L lancea
浏览文件
操作

8005080: JDBC 4.2 Core changes 

Reviewed-by: naoto
上级 06879c2d
展开全部 隐藏空白更改
内联 并排
Showing with 1912 addition and 373 deletion
src/share/classes/java/sql/CallableStatement.java
浏览文件 @ a9a95392
/* /*
* Copyright (c) 1996, 2012, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
...@@ -1079,9 +1079,7 @@ public interface CallableStatement extends PreparedStatement { ...@@ -1079,9 +1079,7 @@ public interface CallableStatement extends PreparedStatement {
int length) throws SQLException; int length) throws SQLException;
/** /**
* Sets the value of the designated parameter with the given object. The second * Sets the value of the designated parameter with the given object.
* argument must be an object type; for integral values, the
* <code>java.lang</code> equivalent objects should be used.
* *
* <p>The given Java object will be converted to the given targetSqlType * <p>The given Java object will be converted to the given targetSqlType
* before being sent to the database. * before being sent to the database.
...@@ -1109,13 +1107,8 @@ public interface CallableStatement extends PreparedStatement { ...@@ -1109,13 +1107,8 @@ public interface CallableStatement extends PreparedStatement {
* @exception SQLException if parameterName does not correspond to a named * @exception SQLException if parameterName does not correspond to a named
* parameter; if a database access error occurs or * parameter; if a database access error occurs or
* this method is called on a closed <code>CallableStatement</code> * this method is called on a closed <code>CallableStatement</code>
* @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is * @exception SQLFeatureNotSupportedException if
* a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>, * the JDBC driver does not support this data type
* <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
* <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
* <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
* or <code>STRUCT</code> data type and the JDBC driver does not support
* this data type
* @see Types * @see Types
* @see #getObject * @see #getObject
* @since 1.4 * @since 1.4
...@@ -1125,8 +1118,10 @@ public interface CallableStatement extends PreparedStatement { ...@@ -1125,8 +1118,10 @@ public interface CallableStatement extends PreparedStatement {
/** /**
* Sets the value of the designated parameter with the given object. * Sets the value of the designated parameter with the given object.
* This method is like the method <code>setObject</code> *
* above, except that it assumes a scale of zero. * This method is similar to {@link #setObject(String parameterName,
* Object x, int targetSqlType, int scaleOrLength)},
* except that it assumes a scale of zero.
* *
* @param parameterName the name of the parameter * @param parameterName the name of the parameter
* @param x the object containing the input parameter value * @param x the object containing the input parameter value
...@@ -1135,13 +1130,8 @@ public interface CallableStatement extends PreparedStatement { ...@@ -1135,13 +1130,8 @@ public interface CallableStatement extends PreparedStatement {
* @exception SQLException if parameterName does not correspond to a named * @exception SQLException if parameterName does not correspond to a named
* parameter; if a database access error occurs or * parameter; if a database access error occurs or
* this method is called on a closed <code>CallableStatement</code> * this method is called on a closed <code>CallableStatement</code>
* @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is * @exception SQLFeatureNotSupportedException if
* a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>, * the JDBC driver does not support this data type
* <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
* <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
* <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
* or <code>STRUCT</code> data type and the JDBC driver does not support
* this data type
* @see #getObject * @see #getObject
* @since 1.4 * @since 1.4
*/ */
...@@ -1150,8 +1140,6 @@ public interface CallableStatement extends PreparedStatement { ...@@ -1150,8 +1140,6 @@ public interface CallableStatement extends PreparedStatement {
/** /**
* Sets the value of the designated parameter with the given object. * Sets the value of the designated parameter with the given object.
* The second parameter must be of type <code>Object</code>; therefore, the
* <code>java.lang</code> equivalent objects should be used for built-in types.
* *
* <p>The JDBC specification specifies a standard mapping from * <p>The JDBC specification specifies a standard mapping from
* Java <code>Object</code> types to SQL types. The given argument * Java <code>Object</code> types to SQL types. The given argument
...@@ -2497,4 +2485,338 @@ public interface CallableStatement extends PreparedStatement { ...@@ -2497,4 +2485,338 @@ public interface CallableStatement extends PreparedStatement {
*/ */
public <T> T getObject(String parameterName, Class<T> type) throws SQLException; public <T> T getObject(String parameterName, Class<T> type) throws SQLException;
//------------------------- JDBC 4.2 -----------------------------------
/**
* <p>Sets the value of the designated parameter with the given object.
*
* If the second argument is an {@code InputStream} then the stream
* must contain the number of bytes specified by scaleOrLength.
* If the second argument is a {@code Reader} then the reader must
* contain the number of characters specified
* by scaleOrLength. If these conditions are not true the driver
* will generate a
* {@code SQLException} when the prepared statement is executed.
*
* <p>The given Java object will be converted to the given targetSqlType
* before being sent to the database.
*
* If the object has a custom mapping (is of a class implementing the
* interface {@code SQLData}),
* the JDBC driver should call the method {@code SQLData.writeSQL} to
* write it to the SQL data stream.
* If, on the other hand, the object is of a class implementing
* {@code Ref}, {@code Blob}, {@code Clob}, {@code NClob},
* {@code Struct}, {@code java.net.URL},
* or {@code Array}, the driver should pass it to the database as a
* value of the corresponding SQL type.
*
* <p>Note that this method may be used to pass database-specific
* abstract data types.
*<P>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param parameterName the name of the parameter
* @param x the object containing the input parameter value
* @param targetSqlType the SQL type to be
* sent to the database. The scale argument may further qualify this type.
* @param scaleOrLength for {@code java.sql.JDBCType.DECIMAL}
* or {@code java.sql.JDBCType.NUMERIC types},
* this is the number of digits after the decimal point. For
* Java Object types {@code InputStream} and {@code Reader},
* this is the length
* of the data in the stream or reader. For all other types,
* this value will be ignored.
* @exception SQLException if parameterName does not correspond to a named
* parameter; if a database access error occurs
* or this method is called on a closed {@code CallableStatement} or
* if the Java Object specified by x is an InputStream
* or Reader object and the value of the scale parameter is less
* than zero
* @exception SQLFeatureNotSupportedException if
* the JDBC driver does not support this data type
* @see JDBCType
* @see SQLType
*
* @since 1.8
*/
default void setObject(String parameterName, Object x, SQLType targetSqlType,
int scaleOrLength) throws SQLException {
throw new SQLFeatureNotSupportedException("setObject not implemented");
}
/**
* Sets the value of the designated parameter with the given object.
*
* This method is similar to {@link #setObject(String parameterName,
* Object x, SQLType targetSqlType, int scaleOrLength)},
* except that it assumes a scale of zero.
*<P>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param parameterName the name of the parameter
* @param x the object containing the input parameter value
* @param targetSqlType the SQL type to be sent to the database
* @exception SQLException if parameterName does not correspond to a named
* parameter; if a database access error occurs
* or this method is called on a closed {@code CallableStatement}
* @exception SQLFeatureNotSupportedException if
* the JDBC driver does not support this data type
* @see JDBCType
* @see SQLType
* @since 1.8
*/
default void setObject(String parameterName, Object x, SQLType targetSqlType)
throws SQLException {
throw new SQLFeatureNotSupportedException("setObject not implemented");
}
/**
* Registers the OUT parameter in ordinal position
* {@code parameterIndex} to the JDBC type
* {@code sqlType}. All OUT parameters must be registered
* before a stored procedure is executed.
* <p>
* The JDBC type specified by {@code sqlType} for an OUT
* parameter determines the Java type that must be used
* in the {@code get} method to read the value of that parameter.
* <p>
* If the JDBC type expected to be returned to this output parameter
* is specific to this particular database, {@code sqlType}
* may be {@code JDBCType.OTHER} or a {@code SQLType} that is supported by
* the JDBC driver. The method
* {@link #getObject} retrieves the value.
*<P>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param parameterIndex the first parameter is 1, the second is 2,
* and so on
* @param sqlType the JDBC type code defined by {@code SQLType} to use to
* register the OUT Parameter.
* If the parameter is of JDBC type {@code JDBCType.NUMERIC}
* or {@code JDBCType.DECIMAL}, the version of
* {@code registerOutParameter} that accepts a scale value
* should be used.
*
* @exception SQLException if the parameterIndex is not valid;
* if a database access error occurs or
* this method is called on a closed {@code CallableStatement}
* @exception SQLFeatureNotSupportedException if
* the JDBC driver does not support this data type
* @see JDBCType
* @see SQLType
* @since 1.8
*/
default void registerOutParameter(int parameterIndex, SQLType sqlType)
throws SQLException {
throw new SQLFeatureNotSupportedException("registerOutParameter not implemented");
}
/**
* Registers the parameter in ordinal position
* {@code parameterIndex} to be of JDBC type
* {@code sqlType}. All OUT parameters must be registered
* before a stored procedure is executed.
* <p>
* The JDBC type specified by {@code sqlType} for an OUT
* parameter determines the Java type that must be used
* in the {@code get} method to read the value of that parameter.
* <p>
* This version of {@code registrOutParameter} should be
* used when the parameter is of JDBC type {@code JDBCType.NUMERIC}
* or {@code JDBCType.DECIMAL}.
*<P>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param parameterIndex the first parameter is 1, the second is 2,
* and so on
* @param sqlType the JDBC type code defined by {@code SQLType} to use to
* register the OUT Parameter.
* @param scale the desired number of digits to the right of the
* decimal point. It must be greater than or equal to zero.
* @exception SQLException if the parameterIndex is not valid;
* if a database access error occurs or
* this method is called on a closed {@code CallableStatement}
* @exception SQLFeatureNotSupportedException if
* the JDBC driver does not support this data type
* @see JDBCType
* @see SQLType
* @since 1.8
*/
default void registerOutParameter(int parameterIndex, SQLType sqlType,
int scale) throws SQLException {
throw new SQLFeatureNotSupportedException("registerOutParameter not implemented");
}
/**
* Registers the designated output parameter.
* This version of
* the method {@code registrOutParameter}
* should be used for a user-defined or {@code REF} output parameter.
* Examples
* of user-defined types include: {@code STRUCT}, {@code DISTINCT},
* {@code JAVA_OBJECT}, and named array types.
*<p>
* All OUT parameters must be registered
* before a stored procedure is executed.
* <p> For a user-defined parameter, the fully-qualified SQL
* type name of the parameter should also be given, while a {@code REF}
* parameter requires that the fully-qualified type name of the
* referenced type be given. A JDBC driver that does not need the
* type code and type name information may ignore it. To be portable,
* however, applications should always provide these values for
* user-defined and {@code REF} parameters.
*
* Although it is intended for user-defined and {@code REF} parameters,
* this method may be used to register a parameter of any JDBC type.
* If the parameter does not have a user-defined or {@code REF} type, the
* <i>typeName</i> parameter is ignored.
*
* <P><B>Note:</B> When reading the value of an out parameter, you
* must use the getter method whose Java type corresponds to the
* parameter's registered SQL type.
*<P>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @param sqlType the JDBC type code defined by {@code SQLType} to use to
* register the OUT Parameter.
* @param typeName the fully-qualified name of an SQL structured type
* @exception SQLException if the parameterIndex is not valid;
* if a database access error occurs or
* this method is called on a closed {@code CallableStatement}
* @exception SQLFeatureNotSupportedException if
* the JDBC driver does not support this data type
* @see JDBCType
* @see SQLType
* @since 1.8
*/
default void registerOutParameter (int parameterIndex, SQLType sqlType,
String typeName) throws SQLException {
throw new SQLFeatureNotSupportedException("registerOutParameter not implemented");
}
/**
* Registers the OUT parameter named
* <code>parameterName</code> to the JDBC type
* {@code sqlType}. All OUT parameters must be registered
* before a stored procedure is executed.
* <p>
* The JDBC type specified by {@code sqlType} for an OUT
* parameter determines the Java type that must be used
* in the {@code get} method to read the value of that parameter.
* <p>
* If the JDBC type expected to be returned to this output parameter
* is specific to this particular database, {@code sqlType}
* should be {@code JDBCType.OTHER} or a {@code SQLType} that is supported
* by the JDBC driver.. The method
* {@link #getObject} retrieves the value.
*<P>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param parameterName the name of the parameter
* @param sqlType the JDBC type code defined by {@code SQLType} to use to
* register the OUT Parameter.
* If the parameter is of JDBC type {@code JDBCType.NUMERIC}
* or {@code JDBCType.DECIMAL}, the version of
* {@code registrOutParameter} that accepts a scale value
* should be used.
* @exception SQLException if parameterName does not correspond to a named
* parameter; if a database access error occurs or
* this method is called on a closed {@code CallableStatement}
* @exception SQLFeatureNotSupportedException if
* the JDBC driver does not support this data type
* or if the JDBC driver does not support
* this method
* @since 1.8
* @see JDBCType
* @see SQLType
*/
default void registerOutParameter(String parameterName, SQLType sqlType)
throws SQLException {
throw new SQLFeatureNotSupportedException("registerOutParameter not implemented");
}
/**
* Registers the parameter named
* <code>parameterName</code> to be of JDBC type
* {@code sqlType}. All OUT parameters must be registered
* before a stored procedure is executed.
* <p>
* The JDBC type specified by {@code sqlType} for an OUT
* parameter determines the Java type that must be used
* in the {@code get} method to read the value of that parameter.
* <p>
* This version of {@code registrOutParameter} should be
* used when the parameter is of JDBC type {@code JDBCType.NUMERIC}
* or {@code JDBCType.DECIMAL}.
*<P>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param parameterName the name of the parameter
* @param sqlType the JDBC type code defined by {@code SQLType} to use to
* register the OUT Parameter.
* @param scale the desired number of digits to the right of the
* decimal point. It must be greater than or equal to zero.
* @exception SQLException if parameterName does not correspond to a named
* parameter; if a database access error occurs or
* this method is called on a closed {@code CallableStatement}
* @exception SQLFeatureNotSupportedException if
* the JDBC driver does not support this data type
* or if the JDBC driver does not support
* this method
* @since 1.8
* @see JDBCType
* @see SQLType
*/
default void registerOutParameter(String parameterName, SQLType sqlType,
int scale) throws SQLException {
throw new SQLFeatureNotSupportedException("registerOutParameter not implemented");
}
/**
* Registers the designated output parameter. This version of
* the method {@code registrOutParameter}
* should be used for a user-named or REF output parameter. Examples
* of user-named types include: STRUCT, DISTINCT, JAVA_OBJECT, and
* named array types.
*<p>
* All OUT parameters must be registered
* before a stored procedure is executed.
* </p>
* For a user-named parameter the fully-qualified SQL
* type name of the parameter should also be given, while a REF
* parameter requires that the fully-qualified type name of the
* referenced type be given. A JDBC driver that does not need the
* type code and type name information may ignore it. To be portable,
* however, applications should always provide these values for
* user-named and REF parameters.
*
* Although it is intended for user-named and REF parameters,
* this method may be used to register a parameter of any JDBC type.
* If the parameter does not have a user-named or REF type, the
* typeName parameter is ignored.
*
* <P><B>Note:</B> When reading the value of an out parameter, you
* must use the {@code getXXX} method whose Java type XXX corresponds to the
* parameter's registered SQL type.
*<P>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param parameterName the name of the parameter
* @param sqlType the JDBC type code defined by {@code SQLType} to use to
* register the OUT Parameter.
* @param typeName the fully-qualified name of an SQL structured type
* @exception SQLException if parameterName does not correspond to a named
* parameter; if a database access error occurs or
* this method is called on a closed {@code CallableStatement}
* @exception SQLFeatureNotSupportedException if
* the JDBC driver does not support this data type
* or if the JDBC driver does not support this method
* @see JDBCType
* @see SQLType
* @since 1.8
*/
default void registerOutParameter (String parameterName, SQLType sqlType,
String typeName) throws SQLException {
throw new SQLFeatureNotSupportedException("registerOutParameter not implemented");
}
} }
src/share/classes/java/sql/DatabaseMetaData.java
浏览文件 @ a9a95392
/* /*
* Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
...@@ -2522,10 +2522,10 @@ public interface DatabaseMetaData extends Wrapper { ...@@ -2522,10 +2522,10 @@ public interface DatabaseMetaData extends Wrapper {
* <LI><B>ASC_OR_DESC</B> String => column sort sequence, "A" => ascending, * <LI><B>ASC_OR_DESC</B> String => column sort sequence, "A" => ascending,
* "D" => descending, may be <code>null</code> if sort sequence is not supported; * "D" => descending, may be <code>null</code> if sort sequence is not supported;
* <code>null</code> when TYPE is tableIndexStatistic * <code>null</code> when TYPE is tableIndexStatistic
* <LI><B>CARDINALITY</B> int => When TYPE is tableIndexStatistic, then * <LI><B>CARDINALITY</B> long => When TYPE is tableIndexStatistic, then
* this is the number of rows in the table; otherwise, it is the * this is the number of rows in the table; otherwise, it is the
* number of unique values in the index. * number of unique values in the index.
* <LI><B>PAGES</B> int => When TYPE is tableIndexStatisic then * <LI><B>PAGES</B> long => When TYPE is tableIndexStatisic then
* this is the number of pages used for the table, otherwise it * this is the number of pages used for the table, otherwise it
* is the number of pages used for the current index. * is the number of pages used for the current index.
* <LI><B>FILTER_CONDITION</B> String => Filter condition, if any. * <LI><B>FILTER_CONDITION</B> String => Filter condition, if any.
...@@ -2759,7 +2759,7 @@ public interface DatabaseMetaData extends Wrapper { ...@@ -2759,7 +2759,7 @@ public interface DatabaseMetaData extends Wrapper {
/** /**
* Retrieves whether this database supports batch updates. * Retrieves whether this database supports batch updates.
* *
* @return <code>true</code> if this database supports batch upcates; * @return <code>true</code> if this database supports batch updates;
* <code>false</code> otherwise * <code>false</code> otherwise
* @exception SQLException if a database access error occurs * @exception SQLException if a database access error occurs
* @since 1.2 * @since 1.2
...@@ -3652,4 +3652,37 @@ public interface DatabaseMetaData extends Wrapper { ...@@ -3652,4 +3652,37 @@ public interface DatabaseMetaData extends Wrapper {
* @since 1.7 * @since 1.7
*/ */
boolean generatedKeyAlwaysReturned() throws SQLException; boolean generatedKeyAlwaysReturned() throws SQLException;
//--------------------------JDBC 4.2 -----------------------------
/**
*
* Retrieves the maximum number of bytes this database allows for
* the logical size for a {@code LOB}.
*<p>
* The default implementation will return {@code 0}
*
* @return the maximum number of bytes allowed; a result of zero
* means that there is no limit or the limit is not known
* @exception SQLException if a database access error occurs
* @since 1.8
*/
default long getMaxLogicalLobSize() throws SQLException {
return 0;
}
/**
* Retrieves whether this database supports REF CURSOR.
*<p>
* The default implementation will return {@code false}
*
* @return {@code true} if this database supports REF CURSOR;
* {@code false} otherwise
* @exception SQLException if a database access error occurs
* @since 1.8
*/
default boolean supportsRefCursors() throws SQLException{
return false;
}
} }
src/share/classes/java/sql/Driver.java
浏览文件 @ a9a95392
/* /*
* Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
...@@ -65,10 +65,15 @@ public interface Driver { ...@@ -65,10 +65,15 @@ public interface Driver {
* driver to connect to the given URL but has trouble connecting to * driver to connect to the given URL but has trouble connecting to
* the database. * the database.
* *
* <P>The <code>java.util.Properties</code> argument can be used to pass * <P>The {@code Properties} argument can be used to pass
* arbitrary string tag/value pairs as connection arguments. * arbitrary string tag/value pairs as connection arguments.
* Normally at least "user" and "password" properties should be * Normally at least "user" and "password" properties should be
* included in the <code>Properties</code> object. * included in the {@code Properties} object.
* <p>
* <B>Note:</B> If a property is specified as part of the {@code url} and
* is also specified in the {@code Properties} object, it is
* implementation-defined as to which value will take precedence. For
* maximum portability, an application should only specify a property once.
* *
* @param url the URL of the database to which to connect * @param url the URL of the database to which to connect
* @param info a list of arbitrary string tag/value pairs as * @param info a list of arbitrary string tag/value pairs as
...@@ -76,7 +81,8 @@ public interface Driver { ...@@ -76,7 +81,8 @@ public interface Driver {
* "password" property should be included. * "password" property should be included.
* @return a <code>Connection</code> object that represents a * @return a <code>Connection</code> object that represents a
* connection to the URL * connection to the URL
* @exception SQLException if a database access error occurs * @exception SQLException if a database access error occurs or the url is
* {@code null}
*/ */
Connection connect(String url, java.util.Properties info) Connection connect(String url, java.util.Properties info)
throws SQLException; throws SQLException;
...@@ -84,13 +90,14 @@ public interface Driver { ...@@ -84,13 +90,14 @@ public interface Driver {
/** /**
* Retrieves whether the driver thinks that it can open a connection * Retrieves whether the driver thinks that it can open a connection
* to the given URL. Typically drivers will return <code>true</code> if they * to the given URL. Typically drivers will return <code>true</code> if they
* understand the subprotocol specified in the URL and <code>false</code> if * understand the sub-protocol specified in the URL and <code>false</code> if
* they do not. * they do not.
* *
* @param url the URL of the database * @param url the URL of the database
* @return <code>true</code> if this driver understands the given URL; * @return <code>true</code> if this driver understands the given URL;
* <code>false</code> otherwise * <code>false</code> otherwise
* @exception SQLException if a database access error occurs * @exception SQLException if a database access error occurs or the url is
* {@code null}
*/ */
boolean acceptsURL(String url) throws SQLException; boolean acceptsURL(String url) throws SQLException;
......
src/share/classes/java/sql/DriverManager.java
浏览文件 @ a9a95392
/* /*
* Copyright (c) 1996, 2012, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
...@@ -172,6 +172,12 @@ public class DriverManager { ...@@ -172,6 +172,12 @@ public class DriverManager {
* Attempts to establish a connection to the given database URL. * Attempts to establish a connection to the given database URL.
* The <code>DriverManager</code> attempts to select an appropriate driver from * The <code>DriverManager</code> attempts to select an appropriate driver from
* the set of registered JDBC drivers. * the set of registered JDBC drivers.
*<p>
* <B>Note:</B> If a property is specified as part of the {@code url} and
* is also specified in the {@code Properties} object, it is
* implementation-defined as to which value will take precedence.
* For maximum portability, an application should only specify a
* property once.
* *
* @param url a database url of the form * @param url a database url of the form
* <code> jdbc:<em>subprotocol</em>:<em>subname</em></code> * <code> jdbc:<em>subprotocol</em>:<em>subname</em></code>
...@@ -179,7 +185,12 @@ public class DriverManager { ...@@ -179,7 +185,12 @@ public class DriverManager {
* connection arguments; normally at least a "user" and * connection arguments; normally at least a "user" and
* "password" property should be included * "password" property should be included
* @return a Connection to the URL * @return a Connection to the URL
* @exception SQLException if a database access error occurs * @exception SQLException if a database access error occurs or the url is
* {@code null}
* @throws SQLTimeoutException when the driver has determined that the
* timeout value specified by the {@code setLoginTimeout} method
* has been exceeded and has at least tried to cancel the
* current database connection attempt
*/ */
public static Connection getConnection(String url, public static Connection getConnection(String url,
java.util.Properties info) throws SQLException { java.util.Properties info) throws SQLException {
...@@ -195,6 +206,12 @@ public class DriverManager { ...@@ -195,6 +206,12 @@ public class DriverManager {
* Attempts to establish a connection to the given database URL. * Attempts to establish a connection to the given database URL.
* The <code>DriverManager</code> attempts to select an appropriate driver from * The <code>DriverManager</code> attempts to select an appropriate driver from
* the set of registered JDBC drivers. * the set of registered JDBC drivers.
*<p>
* <B>Note:</B> If a property is specified as part of the {@code url} and
* is also specified in the {@code Properties} object, it is
* implementation-defined as to which value will take precedence.
* For maximum portability, an application should only specify a
* property once.
* *
* @param url a database url of the form * @param url a database url of the form
* <code>jdbc:<em>subprotocol</em>:<em>subname</em></code> * <code>jdbc:<em>subprotocol</em>:<em>subname</em></code>
...@@ -202,7 +219,12 @@ public class DriverManager { ...@@ -202,7 +219,12 @@ public class DriverManager {
* made * made
* @param password the user's password * @param password the user's password
* @return a connection to the URL * @return a connection to the URL
* @exception SQLException if a database access error occurs * @exception SQLException if a database access error occurs or the url is
* {@code null}
* @throws SQLTimeoutException when the driver has determined that the
* timeout value specified by the {@code setLoginTimeout} method
* has been exceeded and has at least tried to cancel the
* current database connection attempt
*/ */
public static Connection getConnection(String url, public static Connection getConnection(String url,
String user, String password) throws SQLException { String user, String password) throws SQLException {
...@@ -230,7 +252,12 @@ public class DriverManager { ...@@ -230,7 +252,12 @@ public class DriverManager {
* @param url a database url of the form * @param url a database url of the form
* <code> jdbc:<em>subprotocol</em>:<em>subname</em></code> * <code> jdbc:<em>subprotocol</em>:<em>subname</em></code>
* @return a connection to the URL * @return a connection to the URL
* @exception SQLException if a database access error occurs * @exception SQLException if a database access error occurs or the url is
* {@code null}
* @throws SQLTimeoutException when the driver has determined that the
* timeout value specified by the {@code setLoginTimeout} method
* has been exceeded and has at least tried to cancel the
* current database connection attempt
*/ */
public static Connection getConnection(String url) public static Connection getConnection(String url)
throws SQLException { throws SQLException {
...@@ -380,7 +407,8 @@ public class DriverManager { ...@@ -380,7 +407,8 @@ public class DriverManager {
/** /**
* Sets the maximum time in seconds that a driver will wait * Sets the maximum time in seconds that a driver will wait
* while attempting to connect to a database. * while attempting to connect to a database once the driver has
* been identified.
* *
* @param seconds the login time limit in seconds; zero means there is no limit * @param seconds the login time limit in seconds; zero means there is no limit
* @see #getLoginTimeout * @see #getLoginTimeout
......
src/share/classes/java/sql/JDBCType.java 0 → 100644
浏览文件 @ a9a95392
/*
* Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code 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
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.sql;
/**
* <P>Defines the constants that are used to identify generic
* SQL types, called JDBC types.
* <p>
* @see SQLType
* @since 1.8
*/
public enum JDBCType implements SQLType {
/**
* Identifies the generic SQL type {@code BIT}.
*/
BIT(Types.BIT),
/**
* Identifies the generic SQL type {@code TINYINT}.
*/
TINYINT(Types.TINYINT),
/**
* Identifies the generic SQL type {@code SMALLINT}.
*/
SMALLINT(Types.SMALLINT),
/**
* Identifies the generic SQL type {@code INTEGER}.
*/
INTEGER(Types.INTEGER),
/**
* Identifies the generic SQL type {@code BIGINT}.
*/
BIGINT(Types.BIGINT),
/**
* Identifies the generic SQL type {@code FLOAT}.
*/
FLOAT(Types.FLOAT),
/**
* Identifies the generic SQL type {@code REAL}.
*/
REAL(Types.REAL),
/**
* Identifies the generic SQL type {@code DOUBLE}.
*/
DOUBLE(Types.DOUBLE),
/**
* Identifies the generic SQL type {@code NUMERIC}.
*/
NUMERIC(Types.NUMERIC),
/**
* Identifies the generic SQL type {@code DECIMAL}.
*/
DECIMAL(Types.DECIMAL),
/**
* Identifies the generic SQL type {@code CHAR}.
*/
CHAR(Types.CHAR),
/**
* Identifies the generic SQL type {@code VARCHAR}.
*/
VARCHAR(Types.VARCHAR),
/**
* Identifies the generic SQL type {@code LONGVARCHAR}.
*/
LONGVARCHAR(Types.LONGVARCHAR),
/**
* Identifies the generic SQL type {@code DATE}.
*/
DATE(Types.DATE),
/**
* Identifies the generic SQL type {@code TIME}.
*/
TIME(Types.TIME),
/**
* Identifies the generic SQL type {@code TIMESTAMP}.
*/
TIMESTAMP(Types.TIMESTAMP),
/**
* Identifies the generic SQL type {@code BINARY}.
*/
BINARY(Types.BINARY),
/**
* Identifies the generic SQL type {@code VARBINARY}.
*/
VARBINARY(Types.VARBINARY),
/**
* Identifies the generic SQL type {@code LONGVARBINARY}.
*/
LONGVARBINARY(Types.LONGVARBINARY),
/**
* Identifies the generic SQL value {@code NULL}.
*/
NULL(Types.NULL),
/**
* Indicates that the SQL type
* is database-specific and gets mapped to a Java object that can be
* accessed via the methods getObject and setObject.
*/
OTHER(Types.OTHER),
/**
* Indicates that the SQL type
* is database-specific and gets mapped to a Java object that can be
* accessed via the methods getObject and setObject.
*/
JAVA_OBJECT(Types.JAVA_OBJECT),
/**
* Identifies the generic SQL type {@code DISTINCT}.
*/
DISTINCT(Types.DISTINCT),
/**
* Identifies the generic SQL type {@code STRUCT}.
*/
STRUCT(Types.STRUCT),
/**
* Identifies the generic SQL type {@code ARRAY}.
*/
ARRAY(Types.ARRAY),
/**
* Identifies the generic SQL type {@code BLOB}.
*/
BLOB(Types.BLOB),
/**
* Identifies the generic SQL type {@code CLOB}.
*/
CLOB(Types.CLOB),
/**
* Identifies the generic SQL type {@code REF}.
*/
REF(Types.REF),
/**
* Identifies the generic SQL type {@code DATALINK}.
*/
DATALINK(Types.DATALINK),
/**
* Identifies the generic SQL type {@code BOOLEAN}.
*/
BOOLEAN(Types.BOOLEAN),
/* JDBC 4.0 Types */
/**
* Identifies the SQL type {@code ROWID}.
*/
ROWID(Types.ROWID),
/**
* Identifies the generic SQL type {@code NCHAR}.
*/
NCHAR(Types.NCHAR),
/**
* Identifies the generic SQL type {@code NVARCHAR}.
*/
NVARCHAR(Types.NVARCHAR),
/**
* Identifies the generic SQL type {@code LONGNVARCHAR}.
*/
LONGNVARCHAR(Types.LONGNVARCHAR),
/**
* Identifies the generic SQL type {@code NCLOB}.
*/
NCLOB(Types.NCLOB),
/**
* Identifies the generic SQL type {@code SQLXML}.
*/
SQLXML(Types.SQLXML),
/* JDBC 4.2 Types */
/**
* Identifies the generic SQL type {@code REF_CURSOR}.
*/
REF_CURSOR(Types.REF_CURSOR);
/**
* The Integer value for the JDBCType. It maps to a value in
* {@code Types.java}
*/
private Integer type;
/**
* Constructor to specify the data type value from {@code Types) for
* this data type.
* @param type The value from {@code Types) for this data type
*/
JDBCType(final Integer type) {
this.type = type;
}
/**
* Returns the name of the data type.
* @return The name of the data type.
*/
public String getName() {
return name();
}
/**
* Returns the name of the vendor that supports this data type.
* @return The name of the vendor for this data type which is
* {@literal java.sql} for JDBCType.
*/
public String getVendor() {
return "java.sql";
}
/**
* Returns the vendor specific type number for the data type.
* @return An Integer representing the data type. For {@code JDBCType},
* the value will be the same value as in {@code Types} for the data type.
*/
public Integer getVendorTypeNumber() {
return type;
}
/**
* Returns the {@code JDBCType} that corresponds to the specified
* {@code Types} value
* @param type {@code Types} value
* @return The {@code JDBCType} constant
* @throws IllegalArgumentException if this enum type has no constant with
* the specified {@code Types} value
* @see Types
*/
public static JDBCType valueOf(int type) {
for( JDBCType sqlType : JDBCType.class.getEnumConstants()) {
if(type == sqlType.type)
return sqlType;
}
throw new IllegalArgumentException("Type:" + type + " is not a valid "
+ "Types.java value.");
}
}
src/share/classes/java/sql/PreparedStatement.java
浏览文件 @ a9a95392
/* /*
* Copyright (c) 1996, 2012, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
...@@ -388,23 +388,20 @@ public interface PreparedStatement extends Statement { ...@@ -388,23 +388,20 @@ public interface PreparedStatement extends Statement {
/** /**
* Sets the value of the designated parameter with the given object. * Sets the value of the designated parameter with the given object.
* This method is like the method <code>setObject</code> *
* above, except that it assumes a scale of zero. * This method is similar to {@link #setObject(int parameterIndex,
* Object x, int targetSqlType, int scaleOrLength)},
* except that it assumes a scale of zero.
* *
* @param parameterIndex the first parameter is 1, the second is 2, ... * @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the object containing the input parameter value * @param x the object containing the input parameter value
* @param targetSqlType the SQL type (as defined in java.sql.Types) to be * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
* sent to the database * sent to the database
* @exception SQLException if parameterIndex does not correspond to a parameter * @exception SQLException if parameterIndex does not correspond to a parameter
* marker in the SQL statement; if a database access error occurs or * marker in the SQL statement; if a database access error occurs or this
* this method is called on a closed <code>PreparedStatement</code> * method is called on a closed PreparedStatement
* @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is * @exception SQLFeatureNotSupportedException if
* a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>, * the JDBC driver does not support this data type
* <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
* <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
* <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
* or <code>STRUCT</code> data type and the JDBC driver does not support
* this data type
* @see Types * @see Types
*/ */
void setObject(int parameterIndex, Object x, int targetSqlType) void setObject(int parameterIndex, Object x, int targetSqlType)
...@@ -412,8 +409,6 @@ public interface PreparedStatement extends Statement { ...@@ -412,8 +409,6 @@ public interface PreparedStatement extends Statement {
/** /**
* <p>Sets the value of the designated parameter using the given object. * <p>Sets the value of the designated parameter using the given object.
* The second parameter must be of type <code>Object</code>; therefore, the
* <code>java.lang</code> equivalent objects should be used for built-in types.
* *
* <p>The JDBC specification specifies a standard mapping from * <p>The JDBC specification specifies a standard mapping from
* Java <code>Object</code> types to SQL types. The given argument * Java <code>Object</code> types to SQL types. The given argument
...@@ -914,9 +909,7 @@ public interface PreparedStatement extends Statement { ...@@ -914,9 +909,7 @@ public interface PreparedStatement extends Statement {
void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException; void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException;
/** /**
* <p>Sets the value of the designated parameter with the given object. The second * <p>Sets the value of the designated parameter with the given object.
* argument must be an object type; for integral values, the
* <code>java.lang</code> equivalent objects should be used.
* *
* If the second argument is an <code>InputStream</code> then the stream must contain * If the second argument is an <code>InputStream</code> then the stream must contain
* the number of bytes specified by scaleOrLength. If the second argument is a * the number of bytes specified by scaleOrLength. If the second argument is a
...@@ -957,13 +950,8 @@ public interface PreparedStatement extends Statement { ...@@ -957,13 +950,8 @@ public interface PreparedStatement extends Statement {
* if the Java Object specified by x is an InputStream * if the Java Object specified by x is an InputStream
* or Reader object and the value of the scale parameter is less * or Reader object and the value of the scale parameter is less
* than zero * than zero
* @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is * @exception SQLFeatureNotSupportedException if
* a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>, * the JDBC driver does not support this data type
* <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
* <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
* <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
* or <code>STRUCT</code> data type and the JDBC driver does not support
* this data type
* @see Types * @see Types
* *
* @since 1.6 * @since 1.6
...@@ -1220,5 +1208,114 @@ public interface PreparedStatement extends Statement { ...@@ -1220,5 +1208,114 @@ public interface PreparedStatement extends Statement {
void setNClob(int parameterIndex, Reader reader) void setNClob(int parameterIndex, Reader reader)
throws SQLException; throws SQLException;
//------------------------- JDBC 4.2 -----------------------------------
/**
* <p>Sets the value of the designated parameter with the given object.
*
* If the second argument is an {@code InputStream} then the stream
* must contain the number of bytes specified by scaleOrLength.
* If the second argument is a {@code Reader} then the reader must
* contain the number of characters specified by scaleOrLength. If these
* conditions are not true the driver will generate a
* {@code SQLException} when the prepared statement is executed.
*
* <p>The given Java object will be converted to the given targetSqlType
* before being sent to the database.
*
* If the object has a custom mapping (is of a class implementing the
* interface {@code SQLData}),
* the JDBC driver should call the method {@code SQLData.writeSQL} to
* write it to the SQL data stream.
* If, on the other hand, the object is of a class implementing
* {@code Ref}, {@code Blob}, {@code Clob}, {@code NClob},
* {@code Struct}, {@code java.net.URL},
* or {@code Array}, the driver should pass it to the database as a
* value of the corresponding SQL type.
*
* <p>Note that this method may be used to pass database-specific
* abstract data types.
*<P>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the object containing the input parameter value
* @param targetSqlType the SQL type to be sent to the database. The
* scale argument may further qualify this type.
* @param scaleOrLength for {@code java.sql.JDBCType.DECIMAL}
* or {@code java.sql.JDBCType.NUMERIC types},
* this is the number of digits after the decimal point. For
* Java Object types {@code InputStream} and {@code Reader},
* this is the length
* of the data in the stream or reader. For all other types,
* this value will be ignored.
* @exception SQLException if parameterIndex does not correspond to a
* parameter marker in the SQL statement; if a database access error occurs
* or this method is called on a closed {@code PreparedStatement} or
* if the Java Object specified by x is an InputStream
* or Reader object and the value of the scale parameter is less
* than zero
* @exception SQLFeatureNotSupportedException if
* the JDBC driver does not support this data type
* @see JDBCType
* @see SQLType
* @since 1.8
*/
default void setObject(int parameterIndex, Object x, SQLType targetSqlType,
int scaleOrLength) throws SQLException {
throw new SQLFeatureNotSupportedException("setObject not implemented");
}
/**
* Sets the value of the designated parameter with the given object.
*
* This method is similar to {@link #setObject(int parameterIndex,
* Object x, SQLType targetSqlType, int scaleOrLength)},
* except that it assumes a scale of zero.
*<P>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the object containing the input parameter value
* @param targetSqlType the SQL type to be sent to the database
* @exception SQLException if parameterIndex does not correspond to a
* parameter marker in the SQL statement; if a database access error occurs
* or this method is called on a closed {@code PreparedStatement}
* @exception SQLFeatureNotSupportedException if
* the JDBC driver does not support this data type
* @see JDBCType
* @see SQLType
* @since 1.8
*/
default void setObject(int parameterIndex, Object x, SQLType targetSqlType)
throws SQLException {
throw new SQLFeatureNotSupportedException("setObject not implemented");
}
/**
* Executes the SQL statement in this <code>PreparedStatement</code> object,
* which must be an SQL Data Manipulation Language (DML) statement,
* such as <code>INSERT</code>, <code>UPDATE</code> or
* <code>DELETE</code>; or an SQL statement that returns nothing,
* such as a DDL statement.
* <p>
* This method should be used when the returned row count may exceed
* {@link Integer.MAX_VALUE}.
* <p>
* The default implementation will throw {@code UnsupportedOperationException}
*
* @return either (1) the row count for SQL Data Manipulation Language
* (DML) statements or (2) 0 for SQL statements that return nothing
* @exception SQLException if a database access error occurs;
* this method is called on a closed <code>PreparedStatement</code>
* or the SQL statement returns a <code>ResultSet</code> object
* @throws SQLTimeoutException when the driver has determined that the
* timeout value that was specified by the {@code setQueryTimeout}
* method has been exceeded and has at least attempted to cancel
* the currently running {@code Statement}
* @since 1.8
*/
default long executeLargeUpdate() throws SQLException {
throw new UnsupportedOperationException("executeLargeUpdate not implemented");
}
} }
src/share/classes/java/sql/ResultSet.java
浏览文件 @ a9a95392
/* /*
* Copyright (c) 1996, 2012, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
...@@ -1834,6 +1834,7 @@ public interface ResultSet extends Wrapper, AutoCloseable { ...@@ -1834,6 +1834,7 @@ public interface ResultSet extends Wrapper, AutoCloseable {
/** /**
* Updates the designated column with an <code>Object</code> value. * Updates the designated column with an <code>Object</code> value.
*
* The updater methods are used to update column values in the * The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not * current row or the insert row. The updater methods do not
* update the underlying database; instead the <code>updateRow</code> or * update the underlying database; instead the <code>updateRow</code> or
...@@ -1866,6 +1867,7 @@ public interface ResultSet extends Wrapper, AutoCloseable { ...@@ -1866,6 +1867,7 @@ public interface ResultSet extends Wrapper, AutoCloseable {
/** /**
* Updates the designated column with an <code>Object</code> value. * Updates the designated column with an <code>Object</code> value.
*
* The updater methods are used to update column values in the * The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not * current row or the insert row. The updater methods do not
* update the underlying database; instead the <code>updateRow</code> or * update the underlying database; instead the <code>updateRow</code> or
...@@ -2224,6 +2226,7 @@ public interface ResultSet extends Wrapper, AutoCloseable { ...@@ -2224,6 +2226,7 @@ public interface ResultSet extends Wrapper, AutoCloseable {
/** /**
* Updates the designated column with an <code>Object</code> value. * Updates the designated column with an <code>Object</code> value.
*
* The updater methods are used to update column values in the * The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not * current row or the insert row. The updater methods do not
* update the underlying database; instead the <code>updateRow</code> or * update the underlying database; instead the <code>updateRow</code> or
...@@ -2256,6 +2259,7 @@ public interface ResultSet extends Wrapper, AutoCloseable { ...@@ -2256,6 +2259,7 @@ public interface ResultSet extends Wrapper, AutoCloseable {
/** /**
* Updates the designated column with an <code>Object</code> value. * Updates the designated column with an <code>Object</code> value.
*
* The updater methods are used to update column values in the * The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not * current row or the insert row. The updater methods do not
* update the underlying database; instead the <code>updateRow</code> or * update the underlying database; instead the <code>updateRow</code> or
...@@ -4142,4 +4146,145 @@ public interface ResultSet extends Wrapper, AutoCloseable { ...@@ -4142,4 +4146,145 @@ public interface ResultSet extends Wrapper, AutoCloseable {
*/ */
public <T> T getObject(String columnLabel, Class<T> type) throws SQLException; public <T> T getObject(String columnLabel, Class<T> type) throws SQLException;
//------------------------- JDBC 4.2 -----------------------------------
/**
* Updates the designated column with an {@code Object} value.
*
* The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not
* update the underlying database; instead the {@code updateRow} or
* {@code insertRow} methods are called to update the database.
*<p>
* If the second argument is an {@code InputStream} then the stream must contain
* the number of bytes specified by scaleOrLength. If the second argument is a
* {@code Reader} then the reader must contain the number of characters specified
* by scaleOrLength. If these conditions are not true the driver will generate a
* {@code SQLException} when the statement is executed.
*<p>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @param targetSqlType the SQL type to be sent to the database
* @param scaleOrLength for an object of {@code java.math.BigDecimal} ,
* this is the number of digits after the decimal point. For
* Java Object types {@code InputStream} and {@code Reader},
* this is the length
* of the data in the stream or reader. For all other types,
* this value will be ignored.
* @exception SQLException if the columnIndex is not valid;
* if a database access error occurs;
* the result set concurrency is {@code CONCUR_READ_ONLY}
* or this method is called on a closed result set
* @exception SQLFeatureNotSupportedException if the JDBC driver does not
* support this method; if the JDBC driver does not support this data type
* @see JDBCType
* @see SQLType
* @since 1.8
*/
default void updateObject(int columnIndex, Object x,
SQLType targetSqlType, int scaleOrLength) throws SQLException {
throw new SQLFeatureNotSupportedException("updateObject not implemented");
}
/**
* Updates the designated column with an {@code Object} value.
*
* The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not
* update the underlying database; instead the {@code updateRow} or
* {@code insertRow} methods are called to update the database.
*<p>
* If the second argument is an {@code InputStream} then the stream must
* contain number of bytes specified by scaleOrLength. If the second
* argument is a {@code Reader} then the reader must contain the number
* of characters specified by scaleOrLength. If these conditions are not
* true the driver will generate a
* {@code SQLException} when the statement is executed.
*<p>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param columnLabel the label for the column specified with the SQL AS
* clause. If the SQL AS clause was not specified, then the label is
* the name of the column
* @param targetSqlType the SQL type to be sent to the database
* @param scaleOrLength for an object of {@code java.math.BigDecimal} ,
* this is the number of digits after the decimal point. For
* Java Object types {@code InputStream} and {@code Reader},
* this is the length
* of the data in the stream or reader. For all other types,
* this value will be ignored.
* @exception SQLException if the columnLabel is not valid;
* if a database access error occurs;
* the result set concurrency is {@code CONCUR_READ_ONLY}
* or this method is called on a closed result set
* @exception SQLFeatureNotSupportedException if the JDBC driver does not
* support this method; if the JDBC driver does not support this data type
* @see JDBCType
* @see SQLType
* @since 1.8
*/
default void updateObject(String columnLabel, Object x,
SQLType targetSqlType, int scaleOrLength) throws SQLException {
throw new SQLFeatureNotSupportedException("updateObject not implemented");
}
/**
* Updates the designated column with an {@code Object} value.
*
* The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not
* update the underlying database; instead the {@code updateRow} or
* {@code insertRow} methods are called to update the database.
*<p>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @param targetSqlType the SQL type to be sent to the database
* @exception SQLException if the columnIndex is not valid;
* if a database access error occurs;
* the result set concurrency is {@code CONCUR_READ_ONLY}
* or this method is called on a closed result set
* @exception SQLFeatureNotSupportedException if the JDBC driver does not
* support this method; if the JDBC driver does not support this data type
* @see JDBCType
* @see SQLType
* @since 1.8
*/
default void updateObject(int columnIndex, Object x, SQLType targetSqlType)
throws SQLException {
throw new SQLFeatureNotSupportedException("updateObject not implemented");
}
/**
* Updates the designated column with an {@code Object} value.
*
* The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not
* update the underlying database; instead the {@code updateRow} or
* {@code insertRow} methods are called to update the database.
*<p>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param columnLabel the label for the column specified with the SQL AS
* clause. If the SQL AS clause was not specified, then the label is
* the name of the column
* @param x the new column value
* @param targetSqlType the SQL type to be sent to the database
* @exception SQLException if the columnLabel is not valid;
* if a database access error occurs;
* the result set concurrency is {@code CONCUR_READ_ONLY}
* or this method is called on a closed result set
* @exception SQLFeatureNotSupportedException if the JDBC driver does not
* support this method; if the JDBC driver does not support this data type
* @see JDBCType
* @see SQLType
* @since 1.8
*/
default void updateObject(String columnLabel, Object x,
SQLType targetSqlType) throws SQLException {
throw new SQLFeatureNotSupportedException("updateObject not implemented");
}
} }
src/share/classes/java/sql/SQLTimeoutException.java
浏览文件 @ a9a95392
/* /*
* Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
...@@ -26,8 +26,10 @@ ...@@ -26,8 +26,10 @@
package java.sql; package java.sql;
/** /**
* <P>The subclass of {@link SQLException} thrown when the timeout specified by <code>Statement</code> * <P>The subclass of {@link SQLException} thrown when the timeout specified by
* has expired. * {@code Statement.setQueryTimeout}, {@code DriverManager.setLoginTimeout},
* {@code DataSource.setLoginTimeout},{@code XADataSource.setLoginTimeout}
* has expired.
* <P> This exception does not correspond to a standard SQLState. * <P> This exception does not correspond to a standard SQLState.
* *
* @since 1.6 * @since 1.6
......
src/share/classes/java/sql/SQLType.java 0 → 100644
浏览文件 @ a9a95392
/*
* Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code 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
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.sql;
/**
* An object that is used to identify a generic SQL type, called a JDBC type or
* a vendor specific data type.
*
* @since 1.8
*/
public interface SQLType {
/**
* Returns the {@code SQLType} name that represents a SQL data type.
*
* @return The name of this {@code SQLType}.
*/
String getName();
/**
* Returns the name of the vendor that supports this data type. The value
* returned typically is the package name for this vendor.
*
* @return The name of the vendor for this data type
*/
String getVendor();
/**
* Returns the vendor specific type number for the data type.
*
* @return An Integer representing the vendor specific data type
*/
Integer getVendorTypeNumber();
}
src/share/classes/java/sql/Statement.java
浏览文件 @ a9a95392
/* /*
* Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
...@@ -183,7 +183,15 @@ public interface Statement extends Wrapper, AutoCloseable { ...@@ -183,7 +183,15 @@ public interface Statement extends Wrapper, AutoCloseable {
* Sets escape processing on or off. * Sets escape processing on or off.
* If escape scanning is on (the default), the driver will do * If escape scanning is on (the default), the driver will do
* escape substitution before sending the SQL statement to the database. * escape substitution before sending the SQL statement to the database.
* *<p>
* The {@code Connection} and {@code DataSource} property
* {@code escapeProcessing} may be used to change the default escape processing
* behavior. A value of true (the default) enables escape Processing for
* all {@code Statement} objects. A value of false disables escape processing
* for all {@code Statement} objects. The {@code setEscapeProcessing}
* method may be used to specify the escape processing behavior for an
* individual {@code Statement} object.
* <p>
* Note: Since prepared statements have usually been parsed prior * Note: Since prepared statements have usually been parsed prior
* to making this call, disabling escape processing for * to making this call, disabling escape processing for
* <code>PreparedStatements</code> objects will have no effect. * <code>PreparedStatements</code> objects will have no effect.
...@@ -1060,4 +1068,304 @@ public interface Statement extends Wrapper, AutoCloseable { ...@@ -1060,4 +1068,304 @@ public interface Statement extends Wrapper, AutoCloseable {
*/ */
public boolean isCloseOnCompletion() throws SQLException; public boolean isCloseOnCompletion() throws SQLException;
//--------------------------JDBC 4.2 -----------------------------
/**
* Retrieves the current result as an update count; if the result
* is a <code>ResultSet</code> object or there are no more results, -1
* is returned. This method should be called only once per result.
* <p>
* This method should be used when the returned row count may exceed
* {@link Integer.MAX_VALUE}.
*<p>
* The default implementation will throw {@code UnsupportedOperationException}
*
* @return the current result as an update count; -1 if the current result
* is a <code>ResultSet</code> object or there are no more results
* @exception SQLException if a database access error occurs or
* this method is called on a closed <code>Statement</code>
* @see #execute
* @since 1.8
*/
default long getLargeUpdateCount() throws SQLException {
throw new UnsupportedOperationException("getLargeUpdateCount not implemented");
}
/**
* Sets the limit for the maximum number of rows that any
* <code>ResultSet</code> object generated by this <code>Statement</code>
* object can contain to the given number.
* If the limit is exceeded, the excess
* rows are silently dropped.
* <p>
* This method should be used when the row limit may exceed
* {@link Integer.MAX_VALUE}.
*<p>
* The default implementation will throw {@code UnsupportedOperationException}
*
* @param max the new max rows limit; zero means there is no limit
* @exception SQLException if a database access error occurs,
* this method is called on a closed <code>Statement</code>
* or the condition max >= 0 is not satisfied
* @see #getMaxRows
* @since 1.8
*/
default void setLargeMaxRows(long max) throws SQLException {
throw new UnsupportedOperationException("setLargeMaxRows not implemented");
}
/**
* Retrieves the maximum number of rows that a
* <code>ResultSet</code> object produced by this
* <code>Statement</code> object can contain. If this limit is exceeded,
* the excess rows are silently dropped.
* <p>
* This method should be used when the returned row limit may exceed
* {@link Integer.MAX_VALUE}.
*<p>
* The default implementation will return {@code 0}
*
* @return the current maximum number of rows for a <code>ResultSet</code>
* object produced by this <code>Statement</code> object;
* zero means there is no limit
* @exception SQLException if a database access error occurs or
* this method is called on a closed <code>Statement</code>
* @see #setMaxRows
* @since 1.8
*/
default long getLargeMaxRows() throws SQLException {
return 0;
}
/**
* Submits a batch of commands to the database for execution and
* if all commands execute successfully, returns an array of update counts.
* The <code>long</code> elements of the array that is returned are ordered
* to correspond to the commands in the batch, which are ordered
* according to the order in which they were added to the batch.
* The elements in the array returned by the method {@code executeLargeBatch}
* may be one of the following:
* <OL>
* <LI>A number greater than or equal to zero -- indicates that the
* command was processed successfully and is an update count giving the
* number of rows in the database that were affected by the command's
* execution
* <LI>A value of <code>SUCCESS_NO_INFO</code> -- indicates that the command was
* processed successfully but that the number of rows affected is
* unknown
* <P>
* If one of the commands in a batch update fails to execute properly,
* this method throws a <code>BatchUpdateException</code>, and a JDBC
* driver may or may not continue to process the remaining commands in
* the batch. However, the driver's behavior must be consistent with a
* particular DBMS, either always continuing to process commands or never
* continuing to process commands. If the driver continues processing
* after a failure, the array returned by the method
* <code>BatchUpdateException.getLargeUpdateCounts</code>
* will contain as many elements as there are commands in the batch, and
* at least one of the elements will be the following:
* <P>
* <LI>A value of <code>EXECUTE_FAILED</code> -- indicates that the command failed
* to execute successfully and occurs only if a driver continues to
* process commands after a command fails
* </OL>
* <p>
* This method should be used when the returned row count may exceed
* {@link Integer.MAX_VALUE}.
*<p>
* The default implementation will throw {@code UnsupportedOperationException}
*
* @return an array of update counts containing one element for each
* command in the batch. The elements of the array are ordered according
* to the order in which commands were added to the batch.
* @exception SQLException if a database access error occurs,
* this method is called on a closed <code>Statement</code> or the
* driver does not support batch statements. Throws {@link BatchUpdateException}
* (a subclass of <code>SQLException</code>) if one of the commands sent to the
* database fails to execute properly or attempts to return a result set.
* @throws SQLTimeoutException when the driver has determined that the
* timeout value that was specified by the {@code setQueryTimeout}
* method has been exceeded and has at least attempted to cancel
* the currently running {@code Statement}
*
* @see #addBatch
* @see DatabaseMetaData#supportsBatchUpdates
* @since 1.8
*/
default long[] executeLargeBatch() throws SQLException {
throw new UnsupportedOperationException("executeLargeBatch not implemented");
}
/**
* Executes the given SQL statement, which may be an <code>INSERT</code>,
* <code>UPDATE</code>, or <code>DELETE</code> statement or an
* SQL statement that returns nothing, such as an SQL DDL statement.
* <p>
* This method should be used when the returned row count may exceed
* {@link Integer.MAX_VALUE}.
* <p>
* <strong>Note:</strong>This method cannot be called on a
* <code>PreparedStatement</code> or <code>CallableStatement</code>.
*<p>
* The default implementation will throw {@code UnsupportedOperationException}
*
* @param sql an SQL Data Manipulation Language (DML) statement,
* such as <code>INSERT</code>, <code>UPDATE</code> or
* <code>DELETE</code>; or an SQL statement that returns nothing,
* such as a DDL statement.
*
* @return either (1) the row count for SQL Data Manipulation Language
* (DML) statements or (2) 0 for SQL statements that return nothing
*
* @exception SQLException if a database access error occurs,
* this method is called on a closed <code>Statement</code>, the given
* SQL statement produces a <code>ResultSet</code> object, the method is called on a
* <code>PreparedStatement</code> or <code>CallableStatement</code>
* @throws SQLTimeoutException when the driver has determined that the
* timeout value that was specified by the {@code setQueryTimeout}
* method has been exceeded and has at least attempted to cancel
* the currently running {@code Statement}
* @since 1.8
*/
default long executeLargeUpdate(String sql) throws SQLException {
throw new UnsupportedOperationException("executeLargeUpdate not implemented");
}
/**
* Executes the given SQL statement and signals the driver with the
* given flag about whether the
* auto-generated keys produced by this <code>Statement</code> object
* should be made available for retrieval. The driver will ignore the
* flag if the SQL statement
* is not an <code>INSERT</code> statement, or an SQL statement able to return
* auto-generated keys (the list of such statements is vendor-specific).
* <p>
* This method should be used when the returned row count may exceed
* {@link Integer.MAX_VALUE}.
* <p>
* <strong>Note:</strong>This method cannot be called on a
* <code>PreparedStatement</code> or <code>CallableStatement</code>.
*<p>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param sql an SQL Data Manipulation Language (DML) statement,
* such as <code>INSERT</code>, <code>UPDATE</code> or
* <code>DELETE</code>; or an SQL statement that returns nothing,
* such as a DDL statement.
*
* @param autoGeneratedKeys a flag indicating whether auto-generated keys
* should be made available for retrieval;
* one of the following constants:
* <code>Statement.RETURN_GENERATED_KEYS</code>
* <code>Statement.NO_GENERATED_KEYS</code>
* @return either (1) the row count for SQL Data Manipulation Language (DML) statements
* or (2) 0 for SQL statements that return nothing
*
* @exception SQLException if a database access error occurs,
* this method is called on a closed <code>Statement</code>, the given
* SQL statement returns a <code>ResultSet</code> object,
* the given constant is not one of those allowed, the method is called on a
* <code>PreparedStatement</code> or <code>CallableStatement</code>
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method with a constant of Statement.RETURN_GENERATED_KEYS
* @throws SQLTimeoutException when the driver has determined that the
* timeout value that was specified by the {@code setQueryTimeout}
* method has been exceeded and has at least attempted to cancel
* the currently running {@code Statement}
* @since 1.8
*/
default long executeLargeUpdate(String sql, int autoGeneratedKeys)
throws SQLException {
throw new SQLFeatureNotSupportedException("executeLargeUpdate not implemented");
}
/**
* Executes the given SQL statement and signals the driver that the
* auto-generated keys indicated in the given array should be made available
* for retrieval. This array contains the indexes of the columns in the
* target table that contain the auto-generated keys that should be made
* available. The driver will ignore the array if the SQL statement
* is not an <code>INSERT</code> statement, or an SQL statement able to return
* auto-generated keys (the list of such statements is vendor-specific).
* <p>
* This method should be used when the returned row count may exceed
* {@link Integer.MAX_VALUE}.
* <p>
* <strong>Note:</strong>This method cannot be called on a
* <code>PreparedStatement</code> or <code>CallableStatement</code>.
*<p>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param sql an SQL Data Manipulation Language (DML) statement,
* such as <code>INSERT</code>, <code>UPDATE</code> or
* <code>DELETE</code>; or an SQL statement that returns nothing,
* such as a DDL statement.
*
* @param columnIndexes an array of column indexes indicating the columns
* that should be returned from the inserted row
* @return either (1) the row count for SQL Data Manipulation Language (DML) statements
* or (2) 0 for SQL statements that return nothing
*
* @exception SQLException if a database access error occurs,
* this method is called on a closed <code>Statement</code>, the SQL
* statement returns a <code>ResultSet</code> object,the second argument
* supplied to this method is not an
* <code>int</code> array whose elements are valid column indexes, the method is called on a
* <code>PreparedStatement</code> or <code>CallableStatement</code>
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @throws SQLTimeoutException when the driver has determined that the
* timeout value that was specified by the {@code setQueryTimeout}
* method has been exceeded and has at least attempted to cancel
* the currently running {@code Statement}
* @since 1.8
*/
default long executeLargeUpdate(String sql, int columnIndexes[]) throws SQLException {
throw new SQLFeatureNotSupportedException("executeLargeUpdate not implemented");
}
/**
* Executes the given SQL statement and signals the driver that the
* auto-generated keys indicated in the given array should be made available
* for retrieval. This array contains the names of the columns in the
* target table that contain the auto-generated keys that should be made
* available. The driver will ignore the array if the SQL statement
* is not an <code>INSERT</code> statement, or an SQL statement able to return
* auto-generated keys (the list of such statements is vendor-specific).
* <p>
* This method should be used when the returned row count may exceed
* {@link Integer.MAX_VALUE}.
* <p>
* <strong>Note:</strong>This method cannot be called on a
* <code>PreparedStatement</code> or <code>CallableStatement</code>.
*<p>
* The default implementation will throw {@code SQLFeatureNotSupportedException}
*
* @param sql an SQL Data Manipulation Language (DML) statement,
* such as <code>INSERT</code>, <code>UPDATE</code> or
* <code>DELETE</code>; or an SQL statement that returns nothing,
* such as a DDL statement.
* @param columnNames an array of the names of the columns that should be
* returned from the inserted row
* @return either the row count for <code>INSERT</code>, <code>UPDATE</code>,
* or <code>DELETE</code> statements, or 0 for SQL statements
* that return nothing
* @exception SQLException if a database access error occurs,
* this method is called on a closed <code>Statement</code>, the SQL
* statement returns a <code>ResultSet</code> object, the
* second argument supplied to this method is not a <code>String</code> array
* whose elements are valid column names, the method is called on a
* <code>PreparedStatement</code> or <code>CallableStatement</code>
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @throws SQLTimeoutException when the driver has determined that the
* timeout value that was specified by the {@code setQueryTimeout}
* method has been exceeded and has at least attempted to cancel
* the currently running {@code Statement}
* @since 1.8
*/
default long executeLargeUpdate(String sql, String columnNames[])
throws SQLException {
throw new SQLFeatureNotSupportedException("executeLargeUpdate not implemented");
}
} }
src/share/classes/java/sql/Types.java
浏览文件 @ a9a95392
/* /*
* Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
...@@ -309,6 +309,16 @@ public class Types { ...@@ -309,6 +309,16 @@ public class Types {
*/ */
public static final int SQLXML = 2009; public static final int SQLXML = 2009;
//--------------------------JDBC 4.2 -----------------------------
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type {@code REF CURSOR}.
*
* @since 1.8
*/
public static final int REF_CURSOR = 2012;
// Prevent instantiation // Prevent instantiation
private Types() {} private Types() {}
} }
src/share/classes/java/sql/package.html
浏览文件 @ a9a95392
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
<html> <html>
<head> <head>
<!-- <!--
Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved. Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
This code is free software; you can redistribute it and/or modify it This code is free software; you can redistribute it and/or modify it
...@@ -45,8 +45,8 @@ The reader/writer facility, available through the ...@@ -45,8 +45,8 @@ The reader/writer facility, available through the
use and update data from a spread sheet, flat file, or any other tabular use and update data from a spread sheet, flat file, or any other tabular
data source. data source.
<P> <P>
<h2>What the JDBC<sup><font size=-2>TM</font></sup> 4.1 API Includes</h2> <h2>What the JDBC<sup><font size=-2>TM</font></sup> 4.2 API Includes</h2>
The JDBC<sup><font size=-2>TM</font></sup> 4.1 API includes both The JDBC<sup><font size=-2>TM</font></sup> 4.2 API includes both
the <code>java.sql</code> package, referred to as the JDBC core API, the <code>java.sql</code> package, referred to as the JDBC core API,
and the <code>javax.sql</code> package, referred to as the JDBC Optional and the <code>javax.sql</code> package, referred to as the JDBC Optional
Package API. This complete JDBC API Package API. This complete JDBC API
...@@ -58,16 +58,17 @@ of the Java<sup><font size=-2>TM</font></sup> Enterprise Edition ...@@ -58,16 +58,17 @@ of the Java<sup><font size=-2>TM</font></sup> Enterprise Edition
(Java EE<sup><font size=-2>TM</font></sup>) technology. (Java EE<sup><font size=-2>TM</font></sup>) technology.
<P> <P>
<h2>Versions</h2> <h2>Versions</h2>
The JDBC 4.1 API incorporates all of the previous JDBC API versions: The JDBC 4.2 API incorporates all of the previous JDBC API versions:
<UL> <UL>
<LI> The JDBC 4.0 API <LI> The JDBC 4.1 API</li>
<LI> The JDBC 3.0 API <LI> The JDBC 4.0 API</li>
<LI> The JDBC 2.1 core API <LI> The JDBC 3.0 API</li>
<LI> The JDBC 2.1 core API</li>
<LI> The JDBC 2.0 Optional Package API<br> <LI> The JDBC 2.0 Optional Package API<br>
(Note that the JDBC 2.1 core API and the JDBC 2.0 Optional Package (Note that the JDBC 2.1 core API and the JDBC 2.0 Optional Package
API together are referred to as the JDBC 2.0 API.) API together are referred to as the JDBC 2.0 API.)</li>
<LI> The JDBC 1.2 API <LI> The JDBC 1.2 API</li>
<LI> The JDBC 1.0 API <LI> The JDBC 1.0 API</li>
</UL> </UL>
<P> <P>
Classes, interfaces, methods, fields, constructors, and exceptions Classes, interfaces, methods, fields, constructors, and exceptions
...@@ -76,16 +77,18 @@ into the Java platform. When these "since" tags are used in ...@@ -76,16 +77,18 @@ into the Java platform. When these "since" tags are used in
Javadoc<sup><font size=-2>TM</font></sup> comments for the JDBC API, Javadoc<sup><font size=-2>TM</font></sup> comments for the JDBC API,
they indicate the following: they indicate the following:
<UL> <UL>
<LI>Since 1.8 -- new in the JDBC 4.2 API and part of the Java SE platform,
version 8</li>
<LI>Since 1.7 -- new in the JDBC 4.1 API and part of the Java SE platform, <LI>Since 1.7 -- new in the JDBC 4.1 API and part of the Java SE platform,
version 7 version 7</li>
<LI>Since 1.6 -- new in the JDBC 4.0 API and part of the Java SE platform, <LI>Since 1.6 -- new in the JDBC 4.0 API and part of the Java SE platform,
version 6 version 6</li>
<LI>Since 1.4 -- new in the JDBC 3.0 API and part of the J2SE platform, <LI>Since 1.4 -- new in the JDBC 3.0 API and part of the J2SE platform,
version 1.4 version 1.4</li>
<LI>Since 1.2 -- new in the JDBC 2.0 API and part of the J2SE platform, <LI>Since 1.2 -- new in the JDBC 2.0 API and part of the J2SE platform,
version 1.2 version 1.2</li>
<LI>Since 1.1 or no "since" tag -- in the original JDBC 1.0 API and part of <LI>Since 1.1 or no "since" tag -- in the original JDBC 1.0 API and part of
the JDK<sup><font size=-2>TM</font></sup>, version 1.1 the JDK<sup><font size=-2>TM</font></sup>, version 1.1</li>
</UL> </UL>
<P> <P>
<b>NOTE:</b> Many of the new features are optional; consequently, there is <b>NOTE:</b> Many of the new features are optional; consequently, there is
...@@ -178,6 +181,17 @@ The <code>java.sql</code> package contains API for the following: ...@@ -178,6 +181,17 @@ The <code>java.sql</code> package contains API for the following:
commands in a batch update executed successfully commands in a batch update executed successfully
</UL> </UL>
</UL> </UL>
<P>
<h3><code>java.sql</code> and <code>javax.sql</code> Features Introduced in the JDBC 4.2 API</h3>
<UL>
<LI>Added <code>JDBCType</code> enum and <code>SQLType</code> interface</li>
<LI>Support for <code>REF CURSORS</code> in <code>CallableStatement</code>
</LI>
<LI><code>DatabaseMetaData</code> methods to return maximum Logical LOB size
and if Ref Cursors are supported</LI>
<LI>Added support for large update counts</LI>
</UL>
<P> <P>
<h3><code>java.sql</code> and <code>javax.sql</code> Features Introduced in the JDBC 4.1 API</h3> <h3><code>java.sql</code> and <code>javax.sql</code> Features Introduced in the JDBC 4.1 API</h3>
<UL> <UL>
......
src/share/classes/javax/sql/DataSource.java
浏览文件 @ a9a95392
/* /*
* Copyright (c) 2000, 2006, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
...@@ -31,69 +31,79 @@ import java.sql.Wrapper; ...@@ -31,69 +31,79 @@ import java.sql.Wrapper;
/** /**
* <p>A factory for connections to the physical data source that this * <p>A factory for connections to the physical data source that this
* <code>DataSource</code> object represents. An alternative to the * {@code DataSource} object represents. An alternative to the
* <code>DriverManager</code> facility, a <code>DataSource</code> object * {@code DriverManager} facility, a {@code DataSource} object
* is the preferred means of getting a connection. An object that implements * is the preferred means of getting a connection. An object that implements
* the <code>DataSource</code> interface will typically be * the {@code DataSource} interface will typically be
* registered with a naming service based on the * registered with a naming service based on the
* Java<sup><font size=-2>TM</font></sup> Naming and Directory (JNDI) API. * Java<sup><font size=-2>TM</font></sup> Naming and Directory (JNDI) API.
* <P> * <P>
* The <code>DataSource</code> interface is implemented by a driver vendor. * The {@code DataSource} interface is implemented by a driver vendor.
* There are three types of implementations: * There are three types of implementations:
* <OL> * <OL>
* <LI>Basic implementation -- produces a standard <code>Connection</code> * <LI>Basic implementation -- produces a standard {@code Connection}
* object * object
* <LI>Connection pooling implementation -- produces a <code>Connection</code> * <LI>Connection pooling implementation -- produces a {@code Connection}
* object that will automatically participate in connection pooling. This * object that will automatically participate in connection pooling. This
* implementation works with a middle-tier connection pooling manager. * implementation works with a middle-tier connection pooling manager.
* <LI>Distributed transaction implementation -- produces a * <LI>Distributed transaction implementation -- produces a
* <code>Connection</code> object that may be used for distributed * {@code Connection} object that may be used for distributed
* transactions and almost always participates in connection pooling. * transactions and almost always participates in connection pooling.
* This implementation works with a middle-tier * This implementation works with a middle-tier
* transaction manager and almost always with a connection * transaction manager and almost always with a connection
* pooling manager. * pooling manager.
* </OL> * </OL>
* <P> * <P>
* A <code>DataSource</code> object has properties that can be modified * A {@code DataSource} object has properties that can be modified
* when necessary. For example, if the data source is moved to a different * when necessary. For example, if the data source is moved to a different
* server, the property for the server can be changed. The benefit is that * server, the property for the server can be changed. The benefit is that
* because the data source's properties can be changed, any code accessing * because the data source's properties can be changed, any code accessing
* that data source does not need to be changed. * that data source does not need to be changed.
* <P> * <P>
* A driver that is accessed via a <code>DataSource</code> object does not * A driver that is accessed via a {@code DataSource} object does not
* register itself with the <code>DriverManager</code>. Rather, a * register itself with the {@code DriverManager}. Rather, a
* <code>DataSource</code> object is retrieved though a lookup operation * {@code DataSource} object is retrieved though a lookup operation
* and then used to create a <code>Connection</code> object. With a basic * and then used to create a {@code Connection} object. With a basic
* implementation, the connection obtained through a <code>DataSource</code> * implementation, the connection obtained through a {@code DataSource}
* object is identical to a connection obtained through the * object is identical to a connection obtained through the
* <code>DriverManager</code> facility. * {@code DriverManager} facility.
* <p>
* An implementation of {@code DataSource} must include a public no-arg
* constructor.
* *
* @since 1.4 * @since 1.4
*/ */
public interface DataSource extends CommonDataSource,Wrapper { public interface DataSource extends CommonDataSource, Wrapper {
/** /**
* <p>Attempts to establish a connection with the data source that * <p>Attempts to establish a connection with the data source that
* this <code>DataSource</code> object represents. * this {@code DataSource} object represents.
* *
* @return a connection to the data source * @return a connection to the data source
* @exception SQLException if a database access error occurs * @exception SQLException if a database access error occurs
* @throws SQLTimeoutException when the driver has determined that the
* timeout value specified by the {@code setLoginTimeout} method
* has been exceeded and has at least tried to cancel the
* current database connection attempt
*/ */
Connection getConnection() throws SQLException; Connection getConnection() throws SQLException;
/** /**
* <p>Attempts to establish a connection with the data source that * <p>Attempts to establish a connection with the data source that
* this <code>DataSource</code> object represents. * this {@code DataSource} object represents.
* *
* @param username the database user on whose behalf the connection is * @param username the database user on whose behalf the connection is
* being made * being made
* @param password the user's password * @param password the user's password
* @return a connection to the data source * @return a connection to the data source
* @exception SQLException if a database access error occurs * @exception SQLException if a database access error occurs
* @throws SQLTimeoutException when the driver has determined that the
* timeout value specified by the {@code setLoginTimeout} method
* has been exceeded and has at least tried to cancel the
* current database connection attempt
* @since 1.4 * @since 1.4
*/ */
Connection getConnection(String username, String password) Connection getConnection(String username, String password)
throws SQLException; throws SQLException;
} }
src/share/classes/javax/sql/XADataSource.java
浏览文件 @ a9a95392
...@@ -28,12 +28,14 @@ package javax.sql; ...@@ -28,12 +28,14 @@ package javax.sql;
import java.sql.*; import java.sql.*;
/** /**
* A factory for <code>XAConnection</code> objects that is used internally. * A factory for {@code XAConnection} objects that is used internally.
* An object that implements the <code>XADataSource</code> interface is * An object that implements the {@code XADataSource} interface is
* typically registered with a naming service that uses the * typically registered with a naming service that uses the
* Java Naming and Directory Interface<sup><font size=-3>TM</font></sup> * Java Naming and Directory Interface<sup><font size=-3>TM</font></sup>
* (JNDI). * (JNDI).
* * <p>
* An implementation of {@code XADataSource} must include a public no-arg
* constructor.
* @since 1.4 * @since 1.4
*/ */
...@@ -43,12 +45,16 @@ public interface XADataSource extends CommonDataSource { ...@@ -43,12 +45,16 @@ public interface XADataSource extends CommonDataSource {
* Attempts to establish a physical database connection that can be * Attempts to establish a physical database connection that can be
* used in a distributed transaction. * used in a distributed transaction.
* *
* @return an <code>XAConnection</code> object, which represents a * @return an {@code XAConnection} object, which represents a
* physical connection to a data source, that can be used in * physical connection to a data source, that can be used in
* a distributed transaction * a distributed transaction
* @exception SQLException if a database access error occurs * @exception SQLException if a database access error occurs
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method * this method
* @throws SQLTimeoutException when the driver has determined that the
* timeout value specified by the {@code setLoginTimeout} method
* has been exceeded and has at least tried to cancel the
* current database connection attempt
* @since 1.4 * @since 1.4
*/ */
XAConnection getXAConnection() throws SQLException; XAConnection getXAConnection() throws SQLException;
...@@ -60,12 +66,16 @@ public interface XADataSource extends CommonDataSource { ...@@ -60,12 +66,16 @@ public interface XADataSource extends CommonDataSource {
* *
* @param user the database user on whose behalf the connection is being made * @param user the database user on whose behalf the connection is being made
* @param password the user's password * @param password the user's password
* @return an <code>XAConnection</code> object, which represents a * @return an {@code XAConnection} object, which represents a
* physical connection to a data source, that can be used in * physical connection to a data source, that can be used in
* a distributed transaction * a distributed transaction
* @exception SQLException if a database access error occurs * @exception SQLException if a database access error occurs
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method * this method
* @throws SQLTimeoutException when the driver has determined that the
* timeout value specified by the {@code setLoginTimeout} method
* has been exceeded and has at least tried to cancel the
* current database connection attempt
* @since 1.4 * @since 1.4
*/ */
XAConnection getXAConnection(String user, String password) XAConnection getXAConnection(String user, String password)
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或