8253936: Replace <code>...</code> with {@code ...} for java.sql

Reviewed-by: lancea
This commit is contained in:
Vipin Sharma 2020-11-25 16:01:40 +00:00 committed by Lance Andersen
parent cfb175dfdf
commit dee79d6053
58 changed files with 4698 additions and 4698 deletions

@ -27,18 +27,18 @@ package java.sql;
/**
* The mapping in the Java programming language for the SQL type
* <code>ARRAY</code>.
* By default, an <code>Array</code> value is a transaction-duration
* reference to an SQL <code>ARRAY</code> value. By default, an <code>Array</code>
* {@code ARRAY}.
* By default, an {@code Array} value is a transaction-duration
* reference to an SQL {@code ARRAY} value. By default, an {@code Array}
* object is implemented using an SQL LOCATOR(array) internally, which
* means that an <code>Array</code> object contains a logical pointer
* to the data in the SQL <code>ARRAY</code> value rather
* than containing the <code>ARRAY</code> value's data.
* means that an {@code Array} object contains a logical pointer
* to the data in the SQL {@code ARRAY} value rather
* than containing the {@code ARRAY} value's data.
* <p>
* The <code>Array</code> interface provides methods for bringing an SQL
* <code>ARRAY</code> value's data to the client as either an array or a
* <code>ResultSet</code> object.
* If the elements of the SQL <code>ARRAY</code>
* The {@code Array} interface provides methods for bringing an SQL
* {@code ARRAY} value's data to the client as either an array or a
* {@code ResultSet} object.
* If the elements of the SQL {@code ARRAY}
* are a UDT, they may be custom mapped. To create a custom mapping,
* a programmer must do two things:
* <ul>
@ -47,21 +47,21 @@ package java.sql;
* <li>make an entry in a type map that contains
* <ul>
* <li>the fully-qualified SQL type name of the UDT
* <li>the <code>Class</code> object for the class implementing
* <code>SQLData</code>
* <li>the {@code Class} object for the class implementing
* {@code SQLData}
* </ul>
* </ul>
* <p>
* When a type map with an entry for
* the base type is supplied to the methods <code>getArray</code>
* and <code>getResultSet</code>, the mapping
* it contains will be used to map the elements of the <code>ARRAY</code> value.
* the base type is supplied to the methods {@code getArray}
* and {@code getResultSet}, the mapping
* it contains will be used to map the elements of the {@code ARRAY} value.
* If no type map is supplied, which would typically be the case,
* the connection's type map is used by default.
* If the connection's type map or a type map supplied to a method has no entry
* for the base type, the elements are mapped according to the standard mapping.
* <p>
* All methods on the <code>Array</code> interface must be fully implemented if the
* All methods on the {@code Array} interface must be fully implemented if the
* JDBC driver supports the data type.
*
* @since 1.2
@ -71,13 +71,13 @@ public interface Array {
/**
* Retrieves the SQL type name of the elements in
* the array designated by this <code>Array</code> object.
* the array designated by this {@code Array} object.
* If the elements are a built-in type, it returns
* the database-specific type name of the elements.
* If the elements are a user-defined type (UDT),
* this method returns the fully-qualified SQL type name.
*
* @return a <code>String</code> that is the database-specific
* @return a {@code String} that is the database-specific
* name for a built-in base type; or the fully-qualified SQL type
* name for a base type that is a UDT
* @throws SQLException if an error occurs while attempting
@ -90,11 +90,11 @@ public interface Array {
/**
* Retrieves the JDBC type of the elements in the array designated
* by this <code>Array</code> object.
* by this {@code Array} object.
*
* @return a constant from the class {@link java.sql.Types} that is
* the type code for the elements in the array designated by this
* <code>Array</code> object
* {@code Array} object
* @throws SQLException if an error occurs while attempting
* to access the base type
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -104,21 +104,21 @@ public interface Array {
int getBaseType() throws SQLException;
/**
* Retrieves the contents of the SQL <code>ARRAY</code> value designated
* Retrieves the contents of the SQL {@code ARRAY} value designated
* by this
* <code>Array</code> object in the form of an array in the Java
* programming language. This version of the method <code>getArray</code>
* {@code Array} object in the form of an array in the Java
* programming language. This version of the method {@code getArray}
* uses the type map associated with the connection for customizations of
* the type mappings.
* <p>
* <strong>Note:</strong> When <code>getArray</code> is used to materialize
* <strong>Note:</strong> When {@code getArray} is used to materialize
* a base type that maps to a primitive data type, then it is
* implementation-defined whether the array returned is an array of
* that primitive data type or an array of <code>Object</code>.
* that primitive data type or an array of {@code Object}.
*
* @return an array in the Java programming language that contains
* the ordered elements of the SQL <code>ARRAY</code> value
* designated by this <code>Array</code> object
* the ordered elements of the SQL {@code ARRAY} value
* designated by this {@code Array} object
* @throws SQLException if an error occurs while attempting to
* access the array
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -128,22 +128,22 @@ public interface Array {
Object getArray() throws SQLException;
/**
* Retrieves the contents of the SQL <code>ARRAY</code> value designated by this
* <code>Array</code> object.
* Retrieves the contents of the SQL {@code ARRAY} value designated by this
* {@code Array} object.
* This method uses
* the specified <code>map</code> for type map customizations
* the specified {@code map} for type map customizations
* unless the base type of the array does not match a user-defined
* type in <code>map</code>, in which case it
* type in {@code map}, in which case it
* uses the standard mapping. This version of the method
* <code>getArray</code> uses either the given type map or the standard mapping;
* {@code getArray} uses either the given type map or the standard mapping;
* it never uses the type map associated with the connection.
* <p>
* <strong>Note:</strong> When <code>getArray</code> is used to materialize
* <strong>Note:</strong> When {@code getArray} is used to materialize
* a base type that maps to a primitive data type, then it is
* implementation-defined whether the array returned is an array of
* that primitive data type or an array of <code>Object</code>.
* that primitive data type or an array of {@code Object}.
*
* @param map a <code>java.util.Map</code> object that contains mappings
* @param map a {@code java.util.Map} object that contains mappings
* of SQL type names to classes in the Java programming language
* @return an array in the Java programming language that contains the ordered
* elements of the SQL array designated by this object
@ -156,22 +156,22 @@ public interface Array {
Object getArray(java.util.Map<String,Class<?>> map) throws SQLException;
/**
* Retrieves a slice of the SQL <code>ARRAY</code>
* value designated by this <code>Array</code> object, beginning with the
* specified <code>index</code> and containing up to <code>count</code>
* Retrieves a slice of the SQL {@code ARRAY}
* value designated by this {@code Array} object, beginning with the
* specified {@code index} and containing up to {@code count}
* successive elements of the SQL array. This method uses the type map
* associated with the connection for customizations of the type mappings.
* <p>
* <strong>Note:</strong> When <code>getArray</code> is used to materialize
* <strong>Note:</strong> When {@code getArray} is used to materialize
* a base type that maps to a primitive data type, then it is
* implementation-defined whether the array returned is an array of
* that primitive data type or an array of <code>Object</code>.
* that primitive data type or an array of {@code Object}.
*
* @param index the array index of the first element to retrieve;
* the first element is at index 1
* @param count the number of successive SQL array elements to retrieve
* @return an array containing up to <code>count</code> consecutive elements
* of the SQL array, beginning with element <code>index</code>
* @return an array containing up to {@code count} consecutive elements
* of the SQL array, beginning with element {@code index}
* @throws SQLException if an error occurs while attempting to
* access the array
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -181,35 +181,35 @@ public interface Array {
Object getArray(long index, int count) throws SQLException;
/**
* Retrieves a slice of the SQL <code>ARRAY</code> value
* designated by this <code>Array</code> object, beginning with the specified
* <code>index</code> and containing up to <code>count</code>
* Retrieves a slice of the SQL {@code ARRAY} value
* designated by this {@code Array} object, beginning with the specified
* {@code index} and containing up to {@code count}
* successive elements of the SQL array.
* <P>
* This method uses
* the specified <code>map</code> for type map customizations
* the specified {@code map} for type map customizations
* unless the base type of the array does not match a user-defined
* type in <code>map</code>, in which case it
* type in {@code map}, in which case it
* uses the standard mapping. This version of the method
* <code>getArray</code> uses either the given type map or the standard mapping;
* {@code getArray} uses either the given type map or the standard mapping;
* it never uses the type map associated with the connection.
* <p>
* <strong>Note:</strong> When <code>getArray</code> is used to materialize
* <strong>Note:</strong> When {@code getArray} is used to materialize
* a base type that maps to a primitive data type, then it is
* implementation-defined whether the array returned is an array of
* that primitive data type or an array of <code>Object</code>.
* that primitive data type or an array of {@code Object}.
*
* @param index the array index of the first element to retrieve;
* the first element is at index 1
* @param count the number of successive SQL array elements to
* retrieve
* @param map a <code>java.util.Map</code> object
* @param map a {@code java.util.Map} object
* that contains SQL type names and the classes in
* the Java programming language to which they are mapped
* @return an array containing up to <code>count</code>
* consecutive elements of the SQL <code>ARRAY</code> value designated by this
* <code>Array</code> object, beginning with element
* <code>index</code>
* @return an array containing up to {@code count}
* consecutive elements of the SQL {@code ARRAY} value designated by this
* {@code Array} object, beginning with element
* {@code index}
* @throws SQLException if an error occurs while attempting to
* access the array
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -221,8 +221,8 @@ public interface Array {
/**
* Retrieves a result set that contains the elements of the SQL
* <code>ARRAY</code> value
* designated by this <code>Array</code> object. If appropriate,
* {@code ARRAY} value
* designated by this {@code Array} object. If appropriate,
* the elements of the array are mapped using the connection's type
* map; otherwise, the standard mapping is used.
* <p>
@ -234,7 +234,7 @@ public interface Array {
* the order of the indices.
*
* @return a {@link ResultSet} object containing one row for each
* of the elements in the array designated by this <code>Array</code>
* of the elements in the array designated by this {@code Array}
* object, with the rows in ascending order based on the indices.
* @throws SQLException if an error occurs while attempting to
* access the array
@ -246,13 +246,13 @@ public interface Array {
/**
* Retrieves a result set that contains the elements of the SQL
* <code>ARRAY</code> value designated by this <code>Array</code> object.
* {@code ARRAY} value designated by this {@code Array} object.
* This method uses
* the specified <code>map</code> for type map customizations
* the specified {@code map} for type map customizations
* unless the base type of the array does not match a user-defined
* type in <code>map</code>, in which case it
* type in {@code map}, in which case it
* uses the standard mapping. This version of the method
* <code>getResultSet</code> uses either the given type map or the standard mapping;
* {@code getResultSet} uses either the given type map or the standard mapping;
* it never uses the type map associated with the connection.
* <p>
* The result set contains one row for each array element, with
@ -264,8 +264,8 @@ public interface Array {
*
* @param map contains the mapping of SQL user-defined types to
* classes in the Java programming language
* @return a <code>ResultSet</code> object containing one row for each
* of the elements in the array designated by this <code>Array</code>
* @return a {@code ResultSet} object containing one row for each
* of the elements in the array designated by this {@code Array}
* object, with the rows in ascending order based on the indices.
* @throws SQLException if an error occurs while attempting to
* access the array
@ -277,16 +277,16 @@ public interface Array {
/**
* Retrieves a result set holding the elements of the subarray that
* starts at index <code>index</code> and contains up to
* <code>count</code> successive elements. This method uses
* starts at index {@code index} and contains up to
* {@code count} successive elements. This method uses
* the connection's type map to map the elements of the array if
* the map contains an entry for the base type. Otherwise, the
* standard mapping is used.
* <P>
* The result set has one row for each element of the SQL array
* designated by this object, with the first row containing the
* element at index <code>index</code>. The result set has
* up to <code>count</code> rows in ascending order based on the
* element at index {@code index}. The result set has
* up to {@code count} rows in ascending order based on the
* indices. Each row has two columns: The second column stores
* the element value; the first column stores the index into the
* array for that element.
@ -294,10 +294,10 @@ public interface Array {
* @param index the array index of the first element to retrieve;
* the first element is at index 1
* @param count the number of successive SQL array elements to retrieve
* @return a <code>ResultSet</code> object containing up to
* <code>count</code> consecutive elements of the SQL array
* designated by this <code>Array</code> object, starting at
* index <code>index</code>.
* @return a {@code ResultSet} object containing up to
* {@code count} consecutive elements of the SQL array
* designated by this {@code Array} object, starting at
* index {@code index}.
* @throws SQLException if an error occurs while attempting to
* access the array
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -308,20 +308,20 @@ public interface Array {
/**
* Retrieves a result set holding the elements of the subarray that
* starts at index <code>index</code> and contains up to
* <code>count</code> successive elements.
* starts at index {@code index} and contains up to
* {@code count} successive elements.
* This method uses
* the specified <code>map</code> for type map customizations
* the specified {@code map} for type map customizations
* unless the base type of the array does not match a user-defined
* type in <code>map</code>, in which case it
* type in {@code map}, in which case it
* uses the standard mapping. This version of the method
* <code>getResultSet</code> uses either the given type map or the standard mapping;
* {@code getResultSet} uses either the given type map or the standard mapping;
* it never uses the type map associated with the connection.
* <P>
* The result set has one row for each element of the SQL array
* designated by this object, with the first row containing the
* element at index <code>index</code>. The result set has
* up to <code>count</code> rows in ascending order based on the
* element at index {@code index}. The result set has
* up to {@code count} rows in ascending order based on the
* indices. Each row has two columns: The second column stores
* the element value; the first column stores the index into the
* array for that element.
@ -329,12 +329,12 @@ public interface Array {
* @param index the array index of the first element to retrieve;
* the first element is at index 1
* @param count the number of successive SQL array elements to retrieve
* @param map the <code>Map</code> object that contains the mapping
* @param map the {@code Map} object that contains the mapping
* of SQL type names to classes in the Java(tm) programming language
* @return a <code>ResultSet</code> object containing up to
* <code>count</code> consecutive elements of the SQL array
* designated by this <code>Array</code> object, starting at
* index <code>index</code>.
* @return a {@code ResultSet} object containing up to
* {@code count} consecutive elements of the SQL array
* designated by this {@code Array} object, starting at
* index {@code index}.
* @throws SQLException if an error occurs while attempting to
* access the array
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -345,14 +345,14 @@ public interface Array {
java.util.Map<String,Class<?>> map)
throws SQLException;
/**
* This method frees the <code>Array</code> object and releases the resources that
* it holds. The object is invalid once the <code>free</code>
* This method frees the {@code Array} object and releases the resources that
* it holds. The object is invalid once the {@code free}
* method is called.
* <p>
* After <code>free</code> has been called, any attempt to invoke a
* method other than <code>free</code> will result in a <code>SQLException</code>
* being thrown. If <code>free</code> is called multiple times, the subsequent
* calls to <code>free</code> are treated as a no-op.
* After {@code free} has been called, any attempt to invoke a
* method other than {@code free} will result in a {@code SQLException}
* being thrown. If {@code free} is called multiple times, the subsequent
* calls to {@code free} are treated as a no-op.
*
* @throws SQLException if an error occurs releasing
* the Array's resources

@ -35,23 +35,23 @@ import java.util.Arrays;
* The subclass of {@link SQLException} thrown when an error
* occurs during a batch update operation. In addition to the
* information provided by {@link SQLException}, a
* <code>BatchUpdateException</code> provides the update
* {@code BatchUpdateException} provides the update
* counts for all commands that were executed successfully during the
* batch update, that is, all commands that were executed before the error
* occurred. The order of elements in an array of update counts
* corresponds to the order in which commands were added to the batch.
* <P>
* After a command in a batch update fails to execute properly
* and a <code>BatchUpdateException</code> is thrown, the driver
* and a {@code BatchUpdateException} is thrown, the driver
* may or may not continue to process the remaining commands in
* the batch. If the driver continues processing after a failure,
* the array returned by the method
* <code>BatchUpdateException.getUpdateCounts</code> will have
* {@code BatchUpdateException.getUpdateCounts} will have
* an element for every command in the batch rather than only
* elements for the commands that executed successfully before
* the error. In the case where the driver continues processing
* commands, the array element for any command
* that failed is <code>Statement.EXECUTE_FAILED</code>.
* that failed is {@code Statement.EXECUTE_FAILED}.
* <P>
* A JDBC driver implementation should use
* the constructor {@code BatchUpdateException(String reason, String SQLState,
@ -68,10 +68,10 @@ import java.util.Arrays;
public class BatchUpdateException extends SQLException {
/**
* Constructs a <code>BatchUpdateException</code> object initialized with a given
* <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code> and
* <code>updateCounts</code>.
* The <code>cause</code> is not initialized, and may subsequently be
* Constructs a {@code BatchUpdateException} object initialized with a given
* {@code reason}, {@code SQLState}, {@code vendorCode} and
* {@code updateCounts}.
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
* <p>
@ -84,12 +84,12 @@ public class BatchUpdateException extends SQLException {
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode an exception code used by a particular
* database vendor
* @param updateCounts an array of <code>int</code>, with each element
* indicating the update count, <code>Statement.SUCCESS_NO_INFO</code> or
* <code>Statement.EXECUTE_FAILED</code> for each SQL command in
* @param updateCounts an array of {@code int}, with each element
* indicating the update count, {@code Statement.SUCCESS_NO_INFO} or
* {@code Statement.EXECUTE_FAILED} for each SQL command in
* the batch for JDBC drivers that continue processing
* after a command failure; an update count or
* <code>Statement.SUCCESS_NO_INFO</code> for each SQL command in the batch
* {@code Statement.SUCCESS_NO_INFO} for each SQL command in the batch
* prior to the failure for JDBC drivers that stop processing after a command
* failure
* @since 1.2
@ -104,10 +104,10 @@ public class BatchUpdateException extends SQLException {
}
/**
* Constructs a <code>BatchUpdateException</code> object initialized with a given
* <code>reason</code>, <code>SQLState</code> and
* <code>updateCounts</code>.
* The <code>cause</code> is not initialized, and may subsequently be
* Constructs a {@code BatchUpdateException} object initialized with a given
* {@code reason}, {@code SQLState} and
* {@code updateCounts}.
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The vendor code
* is initialized to 0.
@ -119,12 +119,12 @@ public class BatchUpdateException extends SQLException {
* </p>
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param updateCounts an array of <code>int</code>, with each element
* indicating the update count, <code>Statement.SUCCESS_NO_INFO</code> or
* <code>Statement.EXECUTE_FAILED</code> for each SQL command in
* @param updateCounts an array of {@code int}, with each element
* indicating the update count, {@code Statement.SUCCESS_NO_INFO} or
* {@code Statement.EXECUTE_FAILED} for each SQL command in
* the batch for JDBC drivers that continue processing
* after a command failure; an update count or
* <code>Statement.SUCCESS_NO_INFO</code> for each SQL command in the batch
* {@code Statement.SUCCESS_NO_INFO} for each SQL command in the batch
* prior to the failure for JDBC drivers that stop processing after a command
* failure
* @since 1.2
@ -137,12 +137,12 @@ public class BatchUpdateException extends SQLException {
}
/**
* Constructs a <code>BatchUpdateException</code> object initialized with a given
* <code>reason</code> and <code>updateCounts</code>.
* The <code>cause</code> is not initialized, and may subsequently be
* Constructs a {@code BatchUpdateException} object initialized with a given
* {@code reason} and {@code updateCounts}.
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The
* <code>SQLState</code> is initialized to <code>null</code>
* {@code SQLState} is initialized to {@code null}
* and the vendor code is initialized to 0.
* <p>
* <strong>Note:</strong> There is no validation of {@code updateCounts} for
@ -151,12 +151,12 @@ public class BatchUpdateException extends SQLException {
* int vendorCode, long []updateCounts,Throwable cause) }.
* </p>
* @param reason a description of the exception
* @param updateCounts an array of <code>int</code>, with each element
* indicating the update count, <code>Statement.SUCCESS_NO_INFO</code> or
* <code>Statement.EXECUTE_FAILED</code> for each SQL command in
* @param updateCounts an array of {@code int}, with each element
* indicating the update count, {@code Statement.SUCCESS_NO_INFO} or
* {@code Statement.EXECUTE_FAILED} for each SQL command in
* the batch for JDBC drivers that continue processing
* after a command failure; an update count or
* <code>Statement.SUCCESS_NO_INFO</code> for each SQL command in the batch
* {@code Statement.SUCCESS_NO_INFO} for each SQL command in the batch
* prior to the failure for JDBC drivers that stop processing after a command
* failure
* @since 1.2
@ -168,11 +168,11 @@ public class BatchUpdateException extends SQLException {
}
/**
* Constructs a <code>BatchUpdateException</code> object initialized with a given
* <code>updateCounts</code>.
* Constructs a {@code BatchUpdateException} object initialized with a given
* {@code updateCounts}.
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The <code>reason</code>
* and <code>SQLState</code> are initialized to null and the vendor code
* {@link Throwable#initCause(java.lang.Throwable)} method. The {@code reason}
* and {@code SQLState} are initialized to null and the vendor code
* is initialized to 0.
* <p>
* <strong>Note:</strong> There is no validation of {@code updateCounts} for
@ -180,12 +180,12 @@ public class BatchUpdateException extends SQLException {
* {@code BatchUpdateException(String reason, String SQLState,
* int vendorCode, long []updateCounts,Throwable cause) }.
* </p>
* @param updateCounts an array of <code>int</code>, with each element
* indicating the update count, <code>Statement.SUCCESS_NO_INFO</code> or
* <code>Statement.EXECUTE_FAILED</code> for each SQL command in
* @param updateCounts an array of {@code int}, with each element
* indicating the update count, {@code Statement.SUCCESS_NO_INFO} or
* {@code Statement.EXECUTE_FAILED} for each SQL command in
* the batch for JDBC drivers that continue processing
* after a command failure; an update count or
* <code>Statement.SUCCESS_NO_INFO</code> for each SQL command in the batch
* {@code Statement.SUCCESS_NO_INFO} for each SQL command in the batch
* prior to the failure for JDBC drivers that stop processing after a command
* failure
* @since 1.2
@ -197,10 +197,10 @@ public class BatchUpdateException extends SQLException {
}
/**
* Constructs a <code>BatchUpdateException</code> object.
* The <code>reason</code>, <code>SQLState</code> and <code>updateCounts</code>
* are initialized to <code>null</code> and the vendor code is initialized to 0.
* The <code>cause</code> is not initialized, and may subsequently be
* Constructs a {@code BatchUpdateException} object.
* The {@code reason}, {@code SQLState} and {@code updateCounts}
* are initialized to {@code null} and the vendor code is initialized to 0.
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -213,16 +213,16 @@ public class BatchUpdateException extends SQLException {
}
/**
* Constructs a <code>BatchUpdateException</code> object initialized with
* a given <code>cause</code>.
* The <code>SQLState</code> and <code>updateCounts</code>
* Constructs a {@code BatchUpdateException} object initialized with
* a given {@code cause}.
* The {@code SQLState} and {@code updateCounts}
* are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* @param cause the underlying reason for this <code>SQLException</code>
* (which is saved for later retrieval by the <code>getCause()</code> method);
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
* @param cause the underlying reason for this {@code SQLException}
* (which is saved for later retrieval by the {@code getCause()} method);
* may be null indicating the cause is non-existent or unknown.
* @since 1.6
* @see #BatchUpdateException(java.lang.String, java.lang.String, int, long[],
@ -233,29 +233,29 @@ public class BatchUpdateException extends SQLException {
}
/**
* Constructs a <code>BatchUpdateException</code> object initialized with a
* given <code>cause</code> and <code>updateCounts</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* Constructs a {@code BatchUpdateException} object initialized with a
* given {@code cause} and {@code updateCounts}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
* <p>
* <strong>Note:</strong> There is no validation of {@code updateCounts} for
* overflow and because of this it is recommended that you use the constructor
* {@code BatchUpdateException(String reason, String SQLState,
* int vendorCode, long []updateCounts,Throwable cause) }.
* </p>
* @param updateCounts an array of <code>int</code>, with each element
* indicating the update count, <code>Statement.SUCCESS_NO_INFO</code> or
* <code>Statement.EXECUTE_FAILED</code> for each SQL command in
* @param updateCounts an array of {@code int}, with each element
* indicating the update count, {@code Statement.SUCCESS_NO_INFO} or
* {@code Statement.EXECUTE_FAILED} for each SQL command in
* the batch for JDBC drivers that continue processing
* after a command failure; an update count or
* <code>Statement.SUCCESS_NO_INFO</code> for each SQL command in the batch
* {@code Statement.SUCCESS_NO_INFO} for each SQL command in the batch
* prior to the failure for JDBC drivers that stop processing after a command
* failure
* @param cause the underlying reason for this <code>SQLException</code>
* (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException}
* (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
* @see #BatchUpdateException(java.lang.String, java.lang.String, int, long[],
@ -266,10 +266,10 @@ public class BatchUpdateException extends SQLException {
}
/**
* Constructs a <code>BatchUpdateException</code> object initialized with
* a given <code>reason</code>, <code>cause</code>
* and <code>updateCounts</code>. The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code BatchUpdateException} object initialized with
* a given {@code reason}, {@code cause}
* and {@code updateCounts}. The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* <p>
* <strong>Note:</strong> There is no validation of {@code updateCounts} for
* overflow and because of this it is recommended that you use the constructor
@ -277,15 +277,15 @@ public class BatchUpdateException extends SQLException {
* int vendorCode, long []updateCounts,Throwable cause) }.
* </p>
* @param reason a description of the exception
* @param updateCounts an array of <code>int</code>, with each element
*indicating the update count, <code>Statement.SUCCESS_NO_INFO</code> or
* <code>Statement.EXECUTE_FAILED</code> for each SQL command in
* @param updateCounts an array of {@code int}, with each element
* indicating the update count, {@code Statement.SUCCESS_NO_INFO} or
* {@code Statement.EXECUTE_FAILED} for each SQL command in
* the batch for JDBC drivers that continue processing
* after a command failure; an update count or
* <code>Statement.SUCCESS_NO_INFO</code> for each SQL command in the batch
* {@code Statement.SUCCESS_NO_INFO} for each SQL command in the batch
* prior to the failure for JDBC drivers that stop processing after a command
* failure
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method);
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method);
* may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
@ -297,18 +297,18 @@ public class BatchUpdateException extends SQLException {
}
/**
* Constructs a <code>BatchUpdateException</code> object initialized with
* a given <code>reason</code>, <code>SQLState</code>,<code>cause</code>, and
* <code>updateCounts</code>. The vendor code is initialized to 0.
* Constructs a {@code BatchUpdateException} object initialized with
* a given {@code reason}, {@code SQLState},{@code cause}, and
* {@code updateCounts}. The vendor code is initialized to 0.
*
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param updateCounts an array of <code>int</code>, with each element
* indicating the update count, <code>Statement.SUCCESS_NO_INFO</code> or
* <code>Statement.EXECUTE_FAILED</code> for each SQL command in
* @param updateCounts an array of {@code int}, with each element
* indicating the update count, {@code Statement.SUCCESS_NO_INFO} or
* {@code Statement.EXECUTE_FAILED} for each SQL command in
* the batch for JDBC drivers that continue processing
* after a command failure; an update count or
* <code>Statement.SUCCESS_NO_INFO</code> for each SQL command in the batch
* {@code Statement.SUCCESS_NO_INFO} for each SQL command in the batch
* prior to the failure for JDBC drivers that stop processing after a command
* failure
* <p>
@ -317,8 +317,8 @@ public class BatchUpdateException extends SQLException {
* {@code BatchUpdateException(String reason, String SQLState,
* int vendorCode, long []updateCounts,Throwable cause) }.
* </p>
* @param cause the underlying reason for this <code>SQLException</code>
* (which is saved for later retrieval by the <code>getCause()</code> method);
* @param cause the underlying reason for this {@code SQLException}
* (which is saved for later retrieval by the {@code getCause()} method);
* may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
@ -331,20 +331,20 @@ public class BatchUpdateException extends SQLException {
}
/**
* Constructs a <code>BatchUpdateException</code> object initialized with
* a given <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* <code>cause</code> and <code>updateCounts</code>.
* Constructs a {@code BatchUpdateException} object initialized with
* a given {@code reason}, {@code SQLState}, {@code vendorCode}
* {@code cause} and {@code updateCounts}.
*
* @param reason a description of the error
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode an exception code used by a particular
* database vendor
* @param updateCounts an array of <code>int</code>, with each element
*indicating the update count, <code>Statement.SUCCESS_NO_INFO</code> or
* <code>Statement.EXECUTE_FAILED</code> for each SQL command in
* @param updateCounts an array of {@code int}, with each element
*indicating the update count, {@code Statement.SUCCESS_NO_INFO} or
* {@code Statement.EXECUTE_FAILED} for each SQL command in
* the batch for JDBC drivers that continue processing
* after a command failure; an update count or
* <code>Statement.SUCCESS_NO_INFO</code> for each SQL command in the batch
* {@code Statement.SUCCESS_NO_INFO} for each SQL command in the batch
* prior to the failure for JDBC drivers that stop processing after a command
* failure
* <p>
@ -353,7 +353,7 @@ public class BatchUpdateException extends SQLException {
* {@code BatchUpdateException(String reason, String SQLState,
* int vendorCode, long []updateCounts,Throwable cause) }.
* </p>
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method);
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method);
* may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
@ -376,23 +376,23 @@ public class BatchUpdateException extends SQLException {
* the array returned by this method will have as many elements as
* there are commands in the batch; otherwise, it will contain an
* update count for each command that executed successfully before
* the <code>BatchUpdateException</code> was thrown.
* the {@code BatchUpdateException} was thrown.
* <P>
* The possible return values for this method were modified for
* the Java 2 SDK, Standard Edition, version 1.3. This was done to
* accommodate the new option of continuing to process commands
* in a batch update after a <code>BatchUpdateException</code> object
* in a batch update after a {@code BatchUpdateException} object
* has been thrown.
*
* @return an array of <code>int</code> containing the update counts
* @return an array of {@code int} containing the update counts
* for the updates that were executed successfully before this error
* occurred. Or, if the driver continues to process commands after an
* error, one of the following for every command in the batch:
* <OL>
* <LI>an update count
* <LI><code>Statement.SUCCESS_NO_INFO</code> to indicate that the command
* <LI>{@code Statement.SUCCESS_NO_INFO} to indicate that the command
* executed successfully but the number of rows affected is unknown
* <LI><code>Statement.EXECUTE_FAILED</code> to indicate that the command
* <LI>{@code Statement.EXECUTE_FAILED} to indicate that the command
* failed to execute successfully
* </OL>
* @since 1.3
@ -403,9 +403,9 @@ public class BatchUpdateException extends SQLException {
}
/**
* Constructs a <code>BatchUpdateException</code> object initialized with
* a given <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* <code>cause</code> and <code>updateCounts</code>.
* Constructs a {@code BatchUpdateException} object initialized with
* a given {@code reason}, {@code SQLState}, {@code vendorCode}
* {@code cause} and {@code updateCounts}.
* <p>
* This constructor should be used when the returned update count may exceed
* {@link Integer#MAX_VALUE}.
@ -414,16 +414,16 @@ public class BatchUpdateException extends SQLException {
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode an exception code used by a particular
* database vendor
* @param updateCounts an array of <code>long</code>, with each element
*indicating the update count, <code>Statement.SUCCESS_NO_INFO</code> or
* <code>Statement.EXECUTE_FAILED</code> for each SQL command in
* @param updateCounts an array of {@code long}, with each element
*indicating the update count, {@code Statement.SUCCESS_NO_INFO} or
* {@code Statement.EXECUTE_FAILED} for each SQL command in
* the batch for JDBC drivers that continue processing
* after a command failure; an update count or
* <code>Statement.SUCCESS_NO_INFO</code> for each SQL command in the batch
* {@code Statement.SUCCESS_NO_INFO} for each SQL command in the batch
* prior to the failure for JDBC drivers that stop processing after a command
* failure
* @param cause the underlying reason for this <code>SQLException</code>
* (which is saved for later retrieval by the <code>getCause()</code> method);
* @param cause the underlying reason for this {@code SQLException}
* (which is saved for later retrieval by the {@code getCause()} method);
* may be null indicating the cause is non-existent or unknown.
* @since 1.8
*/
@ -443,20 +443,20 @@ public class BatchUpdateException extends SQLException {
* the array returned by this method will have as many elements as
* there are commands in the batch; otherwise, it will contain an
* update count for each command that executed successfully before
* the <code>BatchUpdateException</code> was thrown.
* the {@code BatchUpdateException} was thrown.
* <p>
* This method should be used when {@code Statement.executeLargeBatch} is
* invoked and the returned update count may exceed {@link Integer#MAX_VALUE}.
*
* @return an array of <code>long</code> containing the update counts
* @return an array of {@code long} containing the update counts
* for the updates that were executed successfully before this error
* occurred. Or, if the driver continues to process commands after an
* error, one of the following for every command in the batch:
* <OL>
* <LI>an update count
* <LI><code>Statement.SUCCESS_NO_INFO</code> to indicate that the command
* <LI>{@code Statement.SUCCESS_NO_INFO} to indicate that the command
* executed successfully but the number of rows affected is unknown
* <LI><code>Statement.EXECUTE_FAILED</code> to indicate that the command
* <LI>{@code Statement.EXECUTE_FAILED} to indicate that the command
* failed to execute successfully
* </OL>
* @since 1.8

File diff suppressed because it is too large Load Diff

@ -1,5 +1,5 @@
/*
* Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2006, 2020, 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
@ -29,7 +29,7 @@ import java.util.*;
/**
* Enumeration for status of the reason that a property could not be set
* via a call to <code>Connection.setClientInfo</code>
* via a call to {@code Connection.setClientInfo}
* @since 1.6
*/

File diff suppressed because it is too large Load Diff

@ -1,5 +1,5 @@
/*
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1996, 2020, 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
@ -26,14 +26,14 @@
package java.sql;
/**
* An exception thrown as a <code>DataTruncation</code> exception
* An exception thrown as a {@code DataTruncation} exception
* (on writes) or reported as a
* <code>DataTruncation</code> warning (on reads)
* {@code DataTruncation} warning (on reads)
* when a data values is unexpectedly truncated for reasons other than its having
* exceeded <code>MaxFieldSize</code>.
* exceeded {@code MaxFieldSize}.
*
* <P>The SQLstate for a <code>DataTruncation</code> during read is <code>01004</code>.
* <P>The SQLstate for a <code>DataTruncation</code> during write is <code>22001</code>.
* <P>The SQLstate for a {@code DataTruncation} during read is {@code 01004}.
* <P>The SQLstate for a {@code DataTruncation} during write is {@code 22001}.
*
* @since 1.1
*/
@ -41,14 +41,14 @@ package java.sql;
public class DataTruncation extends SQLWarning {
/**
* Creates a <code>DataTruncation</code> object
* Creates a {@code DataTruncation} object
* with the SQLState initialized
* to 01004 when <code>read</code> is set to <code>true</code> and 22001
* when <code>read</code> is set to <code>false</code>,
* to 01004 when {@code read} is set to {@code true} and 22001
* when {@code read} is set to {@code false},
* the reason set to "Data truncation", the
* vendor code set to 0, and
* the other fields set to the given values.
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -71,10 +71,10 @@ public class DataTruncation extends SQLWarning {
}
/**
* Creates a <code>DataTruncation</code> object
* Creates a {@code DataTruncation} object
* with the SQLState initialized
* to 01004 when <code>read</code> is set to <code>true</code> and 22001
* when <code>read</code> is set to <code>false</code>,
* to 01004 when {@code read} is set to {@code true} and 22001
* when {@code read} is set to {@code false},
* the reason set to "Data truncation", the
* vendor code set to 0, and
* the other fields set to the given values.
@ -84,8 +84,8 @@ public class DataTruncation extends SQLWarning {
* @param read true if a read was truncated
* @param dataSize the original size of the data
* @param transferSize the size after truncation
* @param cause the underlying reason for this <code>DataTruncation</code>
* (which is saved for later retrieval by the <code>getCause()</code> method);
* @param cause the underlying reason for this {@code DataTruncation}
* (which is saved for later retrieval by the {@code getCause()} method);
* may be null indicating the cause is non-existent or unknown.
*
* @since 1.6
@ -105,7 +105,7 @@ public class DataTruncation extends SQLWarning {
* Retrieves the index of the column or parameter that was truncated.
*
* <P>This may be -1 if the column or parameter index is unknown, in
* which case the <code>parameter</code> and <code>read</code> fields should be ignored.
* which case the {@code parameter} and {@code read} fields should be ignored.
*
* @return the index of the truncated parameter or column value
*/
@ -117,8 +117,8 @@ public class DataTruncation extends SQLWarning {
* Indicates whether the value truncated was a parameter value or
* a column value.
*
* @return <code>true</code> if the value truncated was a parameter;
* <code>false</code> if it was a column value
* @return {@code true} if the value truncated was a parameter;
* {@code false} if it was a column value
*/
public boolean getParameter() {
return parameter;
@ -127,8 +127,8 @@ public class DataTruncation extends SQLWarning {
/**
* Indicates whether or not the value was truncated on a read.
*
* @return <code>true</code> if the value was truncated when read from
* the database; <code>false</code> if the data was truncated on a write
* @return {@code true} if the value was truncated when read from
* the database; {@code false} if the data was truncated on a write
*/
public boolean getRead() {
return read;
@ -137,7 +137,7 @@ public class DataTruncation extends SQLWarning {
/**
* Gets the number of bytes of data that should have been transferred.
* This number may be approximate if data conversions were being
* performed. The value may be <code>-1</code> if the size is unknown.
* performed. The value may be {@code -1} if the size is unknown.
*
* @return the number of bytes of data that should have been transferred
*/
@ -147,7 +147,7 @@ public class DataTruncation extends SQLWarning {
/**
* Gets the number of bytes of data actually transferred.
* The value may be <code>-1</code> if the size is unknown.
* The value may be {@code -1} if the size is unknown.
*
* @return the number of bytes of data actually transferred
*/

File diff suppressed because it is too large Load Diff

@ -30,12 +30,12 @@ import java.time.LocalDate;
/**
* <P>A thin wrapper around a millisecond value that allows
* JDBC to identify this as an SQL <code>DATE</code> value. A
* JDBC to identify this as an SQL {@code DATE} value. A
* milliseconds value represents the number of milliseconds that
* have passed since January 1, 1970 00:00:00.000 GMT.
* <p>
* To conform with the definition of SQL <code>DATE</code>, the
* millisecond values wrapped by a <code>java.sql.Date</code> instance
* To conform with the definition of SQL {@code DATE}, the
* millisecond values wrapped by a {@code java.sql.Date} instance
* must be 'normalized' by setting the
* hours, minutes, seconds, and milliseconds to zero in the particular
* time zone with which the instance is associated.
@ -45,7 +45,7 @@ import java.time.LocalDate;
public class Date extends java.util.Date {
/**
* Constructs a <code>Date</code> object initialized with the given
* Constructs a {@code Date} object initialized with the given
* year, month, and day.
* <P>
* The result is undefined if a given argument is out of bounds.
@ -54,7 +54,7 @@ public class Date extends java.util.Date {
* 8099 is 9999 minus 1900.)
* @param month 0 to 11
* @param day 1 to 31
* @deprecated instead use the constructor <code>Date(long date)</code>
* @deprecated instead use the constructor {@code Date(long date)}
*/
@Deprecated(since="1.2")
public Date(int year, int month, int day) {
@ -62,7 +62,7 @@ public class Date extends java.util.Date {
}
/**
* Constructs a <code>Date</code> object using the given milliseconds
* Constructs a {@code Date} object using the given milliseconds
* time value. If the given milliseconds value contains time
* information, the driver will set the time components to the
* time in the default time zone (the time zone of the Java virtual
@ -80,7 +80,7 @@ public class Date extends java.util.Date {
}
/**
* Sets an existing <code>Date</code> object
* Sets an existing {@code Date} object
* using the given milliseconds time value.
* If the given milliseconds value contains time information,
* the driver will set the time components to the
@ -99,12 +99,12 @@ public class Date extends java.util.Date {
/**
* Converts a string in JDBC date escape format to
* a <code>Date</code> value.
* a {@code Date} value.
*
* @param s a <code>String</code> object representing a date in
* in the format "yyyy-[m]m-[d]d". The leading zero for <code>mm</code>
* and <code>dd</code> may also be omitted.
* @return a <code>java.sql.Date</code> object representing the
* @param s a {@code String} object representing a date in
* in the format "yyyy-[m]m-[d]d". The leading zero for {@code mm}
* and {@code dd} may also be omitted.
* @return a {@code java.sql.Date} object representing the
* given date
* @throws IllegalArgumentException if the date given is not in the
* JDBC date escape format (yyyy-[m]m-[d]d)

@ -65,7 +65,7 @@ public interface Driver {
* the JDBC driver manager is asked to connect to a given URL it passes
* the URL to each loaded driver in turn.
*
* <P>The driver should throw an <code>SQLException</code> if it is the right
* <P>The driver should throw an {@code SQLException} if it is the right
* driver to connect to the given URL but has trouble connecting to
* the database.
*
@ -83,7 +83,7 @@ public interface Driver {
* @param info a list of arbitrary string tag/value pairs as
* connection arguments. Normally at least a "user" and
* "password" property should be included.
* @return a <code>Connection</code> object that represents a
* @return a {@code Connection} object that represents a
* connection to the URL
* @throws SQLException if a database access error occurs or the url is
* {@code null}
@ -93,13 +93,13 @@ public interface Driver {
/**
* Retrieves whether the driver thinks that it can open a connection
* to the given URL. Typically drivers will return <code>true</code> if they
* understand the sub-protocol specified in the URL and <code>false</code> if
* to the given URL. Typically drivers will return {@code true} if they
* understand the sub-protocol specified in the URL and {@code false} if
* they do not.
*
* @param url the URL of the database
* @return <code>true</code> if this driver understands the given URL;
* <code>false</code> otherwise
* @return {@code true} if this driver understands the given URL;
* {@code false} otherwise
* @throws SQLException if a database access error occurs or the url is
* {@code null}
*/
@ -109,18 +109,18 @@ public interface Driver {
/**
* Gets information about the possible properties for this driver.
* <P>
* The <code>getPropertyInfo</code> method is intended to allow a generic
* The {@code getPropertyInfo} method is intended to allow a generic
* GUI tool to discover what properties it should prompt
* a human for in order to get
* enough information to connect to a database. Note that depending on
* the values the human has supplied so far, additional values may become
* necessary, so it may be necessary to iterate though several calls
* to the <code>getPropertyInfo</code> method.
* to the {@code getPropertyInfo} method.
*
* @param url the URL of the database to which to connect
* @param info a proposed list of tag/value pairs that will be sent on
* connect open
* @return an array of <code>DriverPropertyInfo</code> objects describing
* @return an array of {@code DriverPropertyInfo} objects describing
* possible properties. This array may be an empty array if
* no properties are required.
* @throws SQLException if a database access error occurs
@ -146,8 +146,8 @@ public interface Driver {
/**
* Reports whether this driver is a genuine JDBC
* Compliant driver.
* A driver may only report <code>true</code> here if it passes the JDBC
* compliance tests; otherwise it is required to return <code>false</code>.
* A driver may only report {@code true} here if it passes the JDBC
* compliance tests; otherwise it is required to return {@code false}.
* <P>
* JDBC compliance requires full support for the JDBC API and full support
* for SQL 92 Entry Level. It is expected that JDBC compliant drivers will
@ -159,7 +159,7 @@ public interface Driver {
* databases that do not support full database functionality, or for
* special databases such as document information retrieval where a SQL
* implementation may not be feasible.
* @return <code>true</code> if this driver is JDBC Compliant; <code>false</code>
* @return {@code true} if this driver is JDBC Compliant; {@code false}
* otherwise
*/
boolean jdbcCompliant();

@ -98,7 +98,7 @@ public class DriverManager {
private DriverManager(){}
/**
* The <code>SQLPermission</code> constant that allows the
* The {@code SQLPermission} constant that allows the
* setting of the logging stream.
* @since 1.3
*/
@ -118,10 +118,10 @@ public class DriverManager {
/**
* Retrieves the log writer.
*
* The <code>getLogWriter</code> and <code>setLogWriter</code>
* The {@code getLogWriter} and {@code setLogWriter}
* methods should be used instead
* of the <code>get/setlogStream</code> methods, which are deprecated.
* @return a <code>java.io.PrintWriter</code> object
* of the {@code get/setlogStream} methods, which are deprecated.
* @return a {@code java.io.PrintWriter} object
* @see #setLogWriter
* @since 1.2
*/
@ -130,15 +130,15 @@ public class DriverManager {
}
/**
* Sets the logging/tracing <code>PrintWriter</code> object
* that is used by the <code>DriverManager</code> and all drivers.
* Sets the logging/tracing {@code PrintWriter} object
* that is used by the {@code DriverManager} and all drivers.
*<P>
* If a security manager exists, its {@code checkPermission}
* method is first called with a {@code SQLPermission("setLog")}
* permission to check that the caller is allowed to call {@code setLogWriter}.
*
* @param out the new logging/tracing <code>PrintStream</code> object;
* <code>null</code> to disable logging and tracing
* @param out the new logging/tracing {@code PrintStream} object;
* {@code null} to disable logging and tracing
* @throws SecurityException if a security manager exists and its
* {@code checkPermission} method denies permission to set the log writer.
* @see SecurityManager#checkPermission
@ -160,7 +160,7 @@ public class DriverManager {
/**
* Attempts to establish a connection to the given database URL.
* The <code>DriverManager</code> attempts to select an appropriate driver from
* The {@code DriverManager} attempts to select an appropriate driver from
* the set of registered JDBC drivers.
*<p>
* <B>Note:</B> If a property is specified as part of the {@code url} and
@ -191,7 +191,7 @@ public class DriverManager {
/**
* Attempts to establish a connection to the given database URL.
* The <code>DriverManager</code> attempts to select an appropriate driver from
* The {@code DriverManager} attempts to select an appropriate driver from
* the set of registered JDBC drivers.
*<p>
* <B>Note:</B> If the {@code user} or {@code password} property are
@ -230,7 +230,7 @@ public class DriverManager {
/**
* Attempts to establish a connection to the given database URL.
* The <code>DriverManager</code> attempts to select an appropriate driver from
* The {@code DriverManager} attempts to select an appropriate driver from
* the set of registered JDBC drivers.
*
* @param url a database url of the form
@ -253,12 +253,12 @@ public class DriverManager {
/**
* Attempts to locate a driver that understands the given URL.
* The <code>DriverManager</code> attempts to select an appropriate driver from
* The {@code DriverManager} attempts to select an appropriate driver from
* the set of registered JDBC drivers.
*
* @param url a database URL of the form
* <code>jdbc:<em>subprotocol</em>:<em>subname</em></code>
* @return a <code>Driver</code> object representing a driver
* @return a {@code Driver} object representing a driver
* that can connect to the given URL
* @throws SQLException if a database access error occurs
*/
@ -414,7 +414,7 @@ public class DriverManager {
* to which the current caller has access.
*
* <P><B>Note:</B> The classname of a driver can be found using
* <CODE>d.getClass().getName()</CODE>
* {@code d.getClass().getName()}
*
* @return the list of JDBC Drivers loaded by the caller's class loader
* @see #drivers()
@ -480,14 +480,14 @@ public class DriverManager {
/**
* Sets the logging/tracing PrintStream that is used
* by the <code>DriverManager</code>
* by the {@code DriverManager}
* and all drivers.
*<P>
* If a security manager exists, its {@code checkPermission}
* method is first called with a {@code SQLPermission("setLog")}
* permission to check that the caller is allowed to call {@code setLogStream}.
*
* @param out the new logging/tracing PrintStream; to disable, set to <code>null</code>
* @param out the new logging/tracing PrintStream; to disable, set to {@code null}
* @deprecated Use {@code setLogWriter}
* @throws SecurityException if a security manager exists and its
* {@code checkPermission} method denies permission to set the log stream.
@ -510,10 +510,10 @@ public class DriverManager {
}
/**
* Retrieves the logging/tracing PrintStream that is used by the <code>DriverManager</code>
* Retrieves the logging/tracing PrintStream that is used by the {@code DriverManager}
* and all drivers.
*
* @return the logging/tracing PrintStream; if disabled, is <code>null</code>
* @return the logging/tracing PrintStream; if disabled, is {@code null}
* @deprecated Use {@code getLogWriter}
* @see #setLogStream
*/

@ -1,5 +1,5 @@
/*
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1996, 2020, 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
@ -27,9 +27,9 @@ package java.sql;
/**
* <p>Driver properties for making a connection. The
* <code>DriverPropertyInfo</code> class is of interest only to advanced programmers
* {@code DriverPropertyInfo} class is of interest only to advanced programmers
* who need to interact with a Driver via the method
* <code>getDriverProperties</code> to discover
* {@code getDriverProperties} to discover
* and supply properties for connections.
*
* @since 1.1
@ -38,10 +38,10 @@ package java.sql;
public class DriverPropertyInfo {
/**
* Constructs a <code>DriverPropertyInfo</code> object with a given
* name and value. The <code>description</code> and <code>choices</code>
* are initialized to <code>null</code> and <code>required</code> is initialized
* to <code>false</code>.
* Constructs a {@code DriverPropertyInfo} object with a given
* name and value. The {@code description} and {@code choices}
* are initialized to {@code null} and {@code required} is initialized
* to {@code false}.
*
* @param name the name of the property
* @param value the current value, which may be null
@ -62,16 +62,16 @@ public class DriverPropertyInfo {
public String description = null;
/**
* The <code>required</code> field is <code>true</code> if a value must be
* The {@code required} field is {@code true} if a value must be
* supplied for this property
* during <code>Driver.connect</code> and <code>false</code> otherwise.
* during {@code Driver.connect} and {@code false} otherwise.
*/
public boolean required = false;
/**
* The <code>value</code> field specifies the current value of
* The {@code value} field specifies the current value of
* the property, based on a combination of the information
* supplied to the method <code>getPropertyInfo</code>, the
* supplied to the method {@code getPropertyInfo}, the
* Java environment, and the driver-supplied default values. This field
* may be null if no value is known.
*/
@ -79,7 +79,7 @@ public class DriverPropertyInfo {
/**
* An array of possible values if the value for the field
* <code>DriverPropertyInfo.value</code> may be selected
* {@code DriverPropertyInfo.value} may be selected
* from a particular set of values; otherwise null.
*/
public String[] choices = null;

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2020, 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
@ -27,24 +27,24 @@ package java.sql;
/**
* The mapping in the Java programming language
* for the SQL <code>NCLOB</code> type.
* An SQL <code>NCLOB</code> is a built-in type
* for the SQL {@code NCLOB} type.
* An SQL {@code NCLOB} is a built-in type
* that stores a Character Large Object using the National Character Set
* as a column value in a row of a database table.
* <P>The <code>NClob</code> interface extends the <code>Clob</code> interface
* <P>The {@code NClob} interface extends the {@code Clob} interface
* which provides methods for getting the
* length of an SQL <code>NCLOB</code> value,
* for materializing a <code>NCLOB</code> value on the client, and for
* searching for a substring or <code>NCLOB</code> object within a
* <code>NCLOB</code> value. A <code>NClob</code> object, just like a <code>Clob</code> object, is valid for the duration
* length of an SQL {@code NCLOB} value,
* for materializing a {@code NCLOB} value on the client, and for
* searching for a substring or {@code NCLOB} object within a
* {@code NCLOB} value. A {@code NClob} object, just like a {@code Clob} object, is valid for the duration
* of the transaction in which it was created.
* Methods in the interfaces {@link ResultSet},
* {@link CallableStatement}, and {@link PreparedStatement}, such as
* <code>getNClob</code> and <code>setNClob</code> allow a programmer to
* access an SQL <code>NCLOB</code> value. In addition, this interface
* has methods for updating a <code>NCLOB</code> value.
* {@code getNClob} and {@code setNClob} allow a programmer to
* access an SQL {@code NCLOB} value. In addition, this interface
* has methods for updating a {@code NCLOB} value.
* <p>
* All methods on the <code>NClob</code> interface must be fully implemented if the
* All methods on the {@code NClob} interface must be fully implemented if the
* JDBC driver supports the data type.
*
* @since 1.6

@ -28,13 +28,13 @@ package java.sql;
/**
* An object that can be used to get information about the types
* and properties for each parameter marker in a
* <code>PreparedStatement</code> object. For some queries and driver
* implementations, the data that would be returned by a <code>ParameterMetaData</code>
* object may not be available until the <code>PreparedStatement</code> has
* {@code PreparedStatement} object. For some queries and driver
* implementations, the data that would be returned by a {@code ParameterMetaData}
* object may not be available until the {@code PreparedStatement} has
* been executed.
*<p>
*Some driver implementations may not be able to provide information about the
*types and properties for each parameter marker in a <code>CallableStatement</code>
*types and properties for each parameter marker in a {@code CallableStatement}
*object.
*
* @since 1.4
@ -43,8 +43,8 @@ package java.sql;
public interface ParameterMetaData extends Wrapper {
/**
* Retrieves the number of parameters in the <code>PreparedStatement</code>
* object for which this <code>ParameterMetaData</code> object contains
* Retrieves the number of parameters in the {@code PreparedStatement}
* object for which this {@code ParameterMetaData} object contains
* information.
*
* @return the number of parameters
@ -58,9 +58,9 @@ public interface ParameterMetaData extends Wrapper {
*
* @param param the first parameter is 1, the second is 2, ...
* @return the nullability status of the given parameter; one of
* <code>ParameterMetaData.parameterNoNulls</code>,
* <code>ParameterMetaData.parameterNullable</code>, or
* <code>ParameterMetaData.parameterNullableUnknown</code>
* {@code ParameterMetaData.parameterNoNulls},
* {@code ParameterMetaData.parameterNullable}, or
* {@code ParameterMetaData.parameterNullableUnknown}
* @throws SQLException if a database access error occurs
* @since 1.4
*/
@ -68,13 +68,13 @@ public interface ParameterMetaData extends Wrapper {
/**
* The constant indicating that a
* parameter will not allow <code>NULL</code> values.
* parameter will not allow {@code NULL} values.
*/
int parameterNoNulls = 0;
/**
* The constant indicating that a
* parameter will allow <code>NULL</code> values.
* parameter will allow {@code NULL} values.
*/
int parameterNullable = 1;
@ -88,7 +88,7 @@ public interface ParameterMetaData extends Wrapper {
* Retrieves whether values for the designated parameter can be signed numbers.
*
* @param param the first parameter is 1, the second is 2, ...
* @return <code>true</code> if so; <code>false</code> otherwise
* @return {@code true} if so; {@code false} otherwise
* @throws SQLException if a database access error occurs
* @since 1.4
*/
@ -126,7 +126,7 @@ public interface ParameterMetaData extends Wrapper {
* Retrieves the designated parameter's SQL type.
*
* @param param the first parameter is 1, the second is 2, ...
* @return SQL type from <code>java.sql.Types</code>
* @return SQL type from {@code java.sql.Types}
* @throws SQLException if a database access error occurs
* @since 1.4
* @see Types
@ -147,12 +147,12 @@ public interface ParameterMetaData extends Wrapper {
/**
* Retrieves the fully-qualified name of the Java class whose instances
* should be passed to the method <code>PreparedStatement.setObject</code>.
* should be passed to the method {@code PreparedStatement.setObject}.
*
* @param param the first parameter is 1, the second is 2, ...
* @return the fully-qualified name of the class in the Java programming
* language that would be used by the method
* <code>PreparedStatement.setObject</code> to set the value
* {@code PreparedStatement.setObject} to set the value
* in the specified parameter. This is the class name used
* for custom mapping.
* @throws SQLException if a database access error occurs
@ -185,10 +185,10 @@ public interface ParameterMetaData extends Wrapper {
*
* @param param the first parameter is 1, the second is 2, ...
* @return mode of the parameter; one of
* <code>ParameterMetaData.parameterModeIn</code>,
* <code>ParameterMetaData.parameterModeOut</code>, or
* <code>ParameterMetaData.parameterModeInOut</code>
* <code>ParameterMetaData.parameterModeUnknown</code>.
* {@code ParameterMetaData.parameterModeIn},
* {@code ParameterMetaData.parameterModeOut}, or
* {@code ParameterMetaData.parameterModeInOut}
* {@code ParameterMetaData.parameterModeUnknown}.
* @throws SQLException if a database access error occurs
* @since 1.4
*/

File diff suppressed because it is too large Load Diff

@ -26,26 +26,26 @@
package java.sql;
/**
* The mapping in the Java programming language of an SQL <code>REF</code>
* The mapping in the Java programming language of an SQL {@code REF}
* value, which is a reference to an SQL structured type value in the database.
* <P>
* SQL <code>REF</code> values are stored in a table that contains
* instances of a referenceable SQL structured type, and each <code>REF</code>
* SQL {@code REF} values are stored in a table that contains
* instances of a referenceable SQL structured type, and each {@code REF}
* value is a unique identifier for one instance in that table.
* An SQL <code>REF</code> value may be used in place of the
* An SQL {@code REF} value may be used in place of the
* SQL structured type it references, either as a column value in a
* table or an attribute value in a structured type.
* <P>
* Because an SQL <code>REF</code> value is a logical pointer to an
* SQL structured type, a <code>Ref</code> object is by default also a logical
* pointer. Thus, retrieving an SQL <code>REF</code> value as
* a <code>Ref</code> object does not materialize
* Because an SQL {@code REF} value is a logical pointer to an
* SQL structured type, a {@code Ref} object is by default also a logical
* pointer. Thus, retrieving an SQL {@code REF} value as
* a {@code Ref} object does not materialize
* the attributes of the structured type on the client.
* <P>
* A <code>Ref</code> object can be stored in the database using the
* <code>PreparedStatement.setRef</code> method.
* A {@code Ref} object can be stored in the database using the
* {@code PreparedStatement.setRef} method.
* <p>
* All methods on the <code>Ref</code> interface must be fully implemented if the
* All methods on the {@code Ref} interface must be fully implemented if the
* JDBC driver supports the data type.
*
* @see Struct
@ -55,7 +55,7 @@ public interface Ref {
/**
* Retrieves the fully-qualified SQL name of the SQL structured type that
* this <code>Ref</code> object references.
* this {@code Ref} object references.
*
* @return the fully-qualified SQL name of the referenced SQL structured type
* @throws SQLException if a database access error occurs
@ -69,13 +69,13 @@ public interface Ref {
* Retrieves the referenced object and maps it to a Java type
* using the given type map.
*
* @param map a <code>java.util.Map</code> object that contains
* @param map a {@code java.util.Map} object that contains
* the mapping to use (the fully-qualified name of the SQL
* structured type being referenced and the class object for
* <code>SQLData</code> implementation to which the SQL
* {@code SQLData} implementation to which the SQL
* structured type will be mapped)
* @return a Java <code>Object</code> that is the custom mapping for
* the SQL structured type to which this <code>Ref</code>
* @return a Java {@code Object} that is the custom mapping for
* the SQL structured type to which this {@code Ref}
* object refers
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -88,13 +88,13 @@ public interface Ref {
/**
* Retrieves the SQL structured type instance referenced by
* this <code>Ref</code> object. If the connection's type map has an entry
* this {@code Ref} object. If the connection's type map has an entry
* for the structured type, the instance will be custom mapped to
* the Java class indicated in the type map. Otherwise, the
* structured type instance will be mapped to a <code>Struct</code> object.
* structured type instance will be mapped to a {@code Struct} object.
*
* @return a Java <code>Object</code> that is the mapping for
* the SQL structured type to which this <code>Ref</code>
* @return a Java {@code Object} that is the mapping for
* the SQL structured type to which this {@code Ref}
* object refers
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -105,14 +105,14 @@ public interface Ref {
Object getObject() throws SQLException;
/**
* Sets the structured type value that this <code>Ref</code>
* object references to the given instance of <code>Object</code>.
* Sets the structured type value that this {@code Ref}
* object references to the given instance of {@code Object}.
* The driver converts this to an SQL structured type when it
* sends it to the database.
*
* @param value an <code>Object</code> representing the SQL
* @param value an {@code Object} representing the SQL
* structured type instance that this
* <code>Ref</code> object will reference
* {@code Ref} object will reference
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method

File diff suppressed because it is too large Load Diff

@ -27,11 +27,11 @@ package java.sql;
/**
* An object that can be used to get information about the types
* and properties of the columns in a <code>ResultSet</code> object.
* The following code fragment creates the <code>ResultSet</code> object rs,
* creates the <code>ResultSetMetaData</code> object rsmd, and uses rsmd
* and properties of the columns in a {@code ResultSet} object.
* The following code fragment creates the {@code ResultSet} object rs,
* creates the {@code ResultSetMetaData} object rsmd, and uses rsmd
* to find out how many columns rs has and whether the first column in rs
* can be used in a <code>WHERE</code> clause.
* can be used in a {@code WHERE} clause.
* <PRE>
*
* ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM TABLE2");
@ -47,7 +47,7 @@ package java.sql;
public interface ResultSetMetaData extends Wrapper {
/**
* Returns the number of columns in this <code>ResultSet</code> object.
* Returns the number of columns in this {@code ResultSet} object.
*
* @return the number of columns
* @throws SQLException if a database access error occurs
@ -58,7 +58,7 @@ public interface ResultSetMetaData extends Wrapper {
* Indicates whether the designated column is automatically numbered.
*
* @param column the first column is 1, the second is 2, ...
* @return <code>true</code> if so; <code>false</code> otherwise
* @return {@code true} if so; {@code false} otherwise
* @throws SQLException if a database access error occurs
*/
boolean isAutoIncrement(int column) throws SQLException;
@ -67,7 +67,7 @@ public interface ResultSetMetaData extends Wrapper {
* Indicates whether a column's case matters.
*
* @param column the first column is 1, the second is 2, ...
* @return <code>true</code> if so; <code>false</code> otherwise
* @return {@code true} if so; {@code false} otherwise
* @throws SQLException if a database access error occurs
*/
boolean isCaseSensitive(int column) throws SQLException;
@ -76,7 +76,7 @@ public interface ResultSetMetaData extends Wrapper {
* Indicates whether the designated column can be used in a where clause.
*
* @param column the first column is 1, the second is 2, ...
* @return <code>true</code> if so; <code>false</code> otherwise
* @return {@code true} if so; {@code false} otherwise
* @throws SQLException if a database access error occurs
*/
boolean isSearchable(int column) throws SQLException;
@ -85,7 +85,7 @@ public interface ResultSetMetaData extends Wrapper {
* Indicates whether the designated column is a cash value.
*
* @param column the first column is 1, the second is 2, ...
* @return <code>true</code> if so; <code>false</code> otherwise
* @return {@code true} if so; {@code false} otherwise
* @throws SQLException if a database access error occurs
*/
boolean isCurrency(int column) throws SQLException;
@ -94,21 +94,21 @@ public interface ResultSetMetaData extends Wrapper {
* Indicates the nullability of values in the designated column.
*
* @param column the first column is 1, the second is 2, ...
* @return the nullability status of the given column; one of <code>columnNoNulls</code>,
* <code>columnNullable</code> or <code>columnNullableUnknown</code>
* @return the nullability status of the given column; one of {@code columnNoNulls},
* {@code columnNullable} or {@code columnNullableUnknown}
* @throws SQLException if a database access error occurs
*/
int isNullable(int column) throws SQLException;
/**
* The constant indicating that a
* column does not allow <code>NULL</code> values.
* column does not allow {@code NULL} values.
*/
int columnNoNulls = 0;
/**
* The constant indicating that a
* column allows <code>NULL</code> values.
* column allows {@code NULL} values.
*/
int columnNullable = 1;
@ -122,7 +122,7 @@ public interface ResultSetMetaData extends Wrapper {
* Indicates whether values in the designated column are signed numbers.
*
* @param column the first column is 1, the second is 2, ...
* @return <code>true</code> if so; <code>false</code> otherwise
* @return {@code true} if so; {@code false} otherwise
* @throws SQLException if a database access error occurs
*/
boolean isSigned(int column) throws SQLException;
@ -139,10 +139,10 @@ public interface ResultSetMetaData extends Wrapper {
/**
* Gets the designated column's suggested title for use in printouts and
* displays. The suggested title is usually specified by the SQL <code>AS</code>
* clause. If a SQL <code>AS</code> is not specified, the value returned from
* <code>getColumnLabel</code> will be the same as the value returned by the
* <code>getColumnName</code> method.
* displays. The suggested title is usually specified by the SQL {@code AS}
* clause. If a SQL {@code AS} is not specified, the value returned from
* {@code getColumnLabel} will be the same as the value returned by the
* {@code getColumnName} method.
*
* @param column the first column is 1, the second is 2, ...
* @return the suggested column title
@ -235,7 +235,7 @@ public interface ResultSetMetaData extends Wrapper {
* Indicates whether the designated column is definitely not writable.
*
* @param column the first column is 1, the second is 2, ...
* @return <code>true</code> if so; <code>false</code> otherwise
* @return {@code true} if so; {@code false} otherwise
* @throws SQLException if a database access error occurs
*/
boolean isReadOnly(int column) throws SQLException;
@ -244,7 +244,7 @@ public interface ResultSetMetaData extends Wrapper {
* Indicates whether it is possible for a write on the designated column to succeed.
*
* @param column the first column is 1, the second is 2, ...
* @return <code>true</code> if so; <code>false</code> otherwise
* @return {@code true} if so; {@code false} otherwise
* @throws SQLException if a database access error occurs
*/
boolean isWritable(int column) throws SQLException;
@ -253,7 +253,7 @@ public interface ResultSetMetaData extends Wrapper {
* Indicates whether a write on the designated column will definitely succeed.
*
* @param column the first column is 1, the second is 2, ...
* @return <code>true</code> if so; <code>false</code> otherwise
* @return {@code true} if so; {@code false} otherwise
* @throws SQLException if a database access error occurs
*/
boolean isDefinitelyWritable(int column) throws SQLException;
@ -262,15 +262,15 @@ public interface ResultSetMetaData extends Wrapper {
/**
* <p>Returns the fully-qualified name of the Java class whose instances
* are manufactured if the method <code>ResultSet.getObject</code>
* are manufactured if the method {@code ResultSet.getObject}
* is called to retrieve a value
* from the column. <code>ResultSet.getObject</code> may return a subclass of the
* from the column. {@code ResultSet.getObject} may return a subclass of the
* class returned by this method.
*
* @param column the first column is 1, the second is 2, ...
* @return the fully-qualified name of the class in the Java programming
* language that would be used by the method
* <code>ResultSet.getObject</code> to retrieve the value in the specified
* {@code ResultSet.getObject} to retrieve the value in the specified
* column. This is the class name used for custom mapping.
* @throws SQLException if a database access error occurs
* @since 1.2

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2020, 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
@ -33,27 +33,27 @@ package java.sql;
* is logical or, in any respects, physical is determined by its originating data
* source.
* <p>
* Methods in the interfaces <code>ResultSet</code>, <code>CallableStatement</code>,
* and <code>PreparedStatement</code>, such as <code>getRowId</code> and <code>setRowId</code>
* allow a programmer to access a SQL <code>ROWID</code> value. The <code>RowId</code>
* Methods in the interfaces {@code ResultSet}, {@code CallableStatement},
* and {@code PreparedStatement}, such as {@code getRowId} and {@code setRowId}
* allow a programmer to access a SQL {@code ROWID} value. The {@code RowId}
* interface provides a method
* for representing the value of the <code>ROWID</code> as a byte array or as a
* <code>String</code>.
* for representing the value of the {@code ROWID} as a byte array or as a
* {@code String}.
* <p>
* The method <code>getRowIdLifetime</code> in the interface <code>DatabaseMetaData</code>,
* The method {@code getRowIdLifetime} in the interface {@code DatabaseMetaData},
* can be used
* to determine if a <code>RowId</code> object remains valid for the duration of the transaction in
* which the <code>RowId</code> was created, the duration of the session in which
* the <code>RowId</code> was created,
* to determine if a {@code RowId} object remains valid for the duration of the transaction in
* which the {@code RowId} was created, the duration of the session in which
* the {@code RowId} was created,
* or, effectively, for as long as its identified row is not deleted. In addition
* to specifying the duration of its valid lifetime outside its originating data
* source, <code>getRowIdLifetime</code> specifies the duration of a <code>ROWID</code>
* source, {@code getRowIdLifetime} specifies the duration of a {@code ROWID}
* value's valid lifetime
* within its originating data source. In this, it differs from a large object,
* because there is no limit on the valid lifetime of a large object within its
* originating data source.
* <p>
* All methods on the <code>RowId</code> interface must be fully implemented if the
* All methods on the {@code RowId} interface must be fully implemented if the
* JDBC driver supports the data type.
*
* @see java.sql.DatabaseMetaData
@ -62,13 +62,13 @@ package java.sql;
public interface RowId {
/**
* Compares this <code>RowId</code> to the specified object. The result is
* <code>true</code> if and only if the argument is not null and is a RowId
* Compares this {@code RowId} to the specified object. The result is
* {@code true} if and only if the argument is not null and is a RowId
* object that represents the same ROWID as this object.
* <p>
* It is important
* to consider both the origin and the valid lifetime of a <code>RowId</code>
* when comparing it to another <code>RowId</code>. If both are valid, and
* to consider both the origin and the valid lifetime of a {@code RowId}
* when comparing it to another {@code RowId}. If both are valid, and
* both are from the same table on the same data source, then if they are equal
* they identify
* the same row; if one or more is no longer guaranteed to be valid, or if
@ -76,16 +76,16 @@ public interface RowId {
* same data source, they may be equal but still
* not identify the same row.
*
* @param obj the <code>Object</code> to compare this <code>RowId</code> object
* @param obj the {@code Object} to compare this {@code RowId} object
* against.
* @return true if the <code>RowId</code>s are equal; false otherwise
* @return true if the {@code RowId}s are equal; false otherwise
* @since 1.6
*/
boolean equals(Object obj);
/**
* Returns an array of bytes representing the value of the SQL <code>ROWID</code>
* designated by this <code>java.sql.RowId</code> object.
* Returns an array of bytes representing the value of the SQL {@code ROWID}
* designated by this {@code java.sql.RowId} object.
*
* @return an array of bytes, whose length is determined by the driver supplying
* the connection, representing the value of the ROWID designated by this
@ -95,25 +95,25 @@ public interface RowId {
/**
* Returns a String representing the value of the SQL ROWID designated by this
* <code>java.sql.RowId</code> object.
* {@code java.sql.RowId} object.
* <p>
*Like <code>java.sql.Date.toString()</code>
* returns the contents of its DATE as the <code>String</code> "2004-03-17"
* rather than as DATE literal in SQL (which would have been the <code>String</code>
*Like {@code java.sql.Date.toString()}
* returns the contents of its DATE as the {@code String} "2004-03-17"
* rather than as DATE literal in SQL (which would have been the {@code String}
* DATE "2004-03-17"), toString()
* returns the contents of its ROWID in a form specific to the driver supplying
* the connection, and possibly not as a <code>ROWID</code> literal.
* the connection, and possibly not as a {@code ROWID} literal.
*
* @return a String whose format is determined by the driver supplying the
* connection, representing the value of the <code>ROWID</code> designated
* by this <code>java.sql.RowId</code> object.
* connection, representing the value of the {@code ROWID} designated
* by this {@code java.sql.RowId} object.
*/
String toString();
/**
* Returns a hash code value of this <code>RowId</code> object.
* Returns a hash code value of this {@code RowId} object.
*
* @return a hash code for the <code>RowId</code>
* @return a hash code for the {@code RowId}
*/
int hashCode();

@ -28,18 +28,18 @@ import java.util.Map;
/**
* The subclass of {@link SQLException} is thrown when one or more client info properties
* could not be set on a <code>Connection</code>. In addition to the information provided
* by <code>SQLException</code>, a <code>SQLClientInfoException</code> provides a list of client info
* could not be set on a {@code Connection}. In addition to the information provided
* by {@code SQLException}, a {@code SQLClientInfoException} provides a list of client info
* properties that were not set.
*
* Some databases do not allow multiple client info properties to be set
* atomically. For those databases, it is possible that some of the client
* info properties had been set even though the <code>Connection.setClientInfo</code>
* method threw an exception. An application can use the <code>getFailedProperties </code>
* info properties had been set even though the {@code Connection.setClientInfo}
* method threw an exception. An application can use the {@code getFailedProperties}
* method to retrieve a list of client info properties that were not set. The
* properties are identified by passing a
* <code>Map&lt;String,ClientInfoStatus&gt;</code> to
* the appropriate <code>SQLClientInfoException</code> constructor.
* {@code Map<String,ClientInfoStatus>} to
* the appropriate {@code SQLClientInfoException} constructor.
*
* @see ClientInfoStatus
* @see Connection#setClientInfo
@ -54,11 +54,11 @@ public class SQLClientInfoException extends SQLException {
private Map<String, ClientInfoStatus> failedProperties;
/**
* Constructs a <code>SQLClientInfoException</code> Object.
* The <code>reason</code>,
* <code>SQLState</code>, and failedProperties list are initialized to
* <code> null</code> and the vendor code is initialized to 0.
* The <code>cause</code> is not initialized, and may subsequently be
* Constructs a {@code SQLClientInfoException} Object.
* The {@code reason},
* {@code SQLState}, and failedProperties list are initialized to
* {@code null} and the vendor code is initialized to 0.
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -70,12 +70,12 @@ public class SQLClientInfoException extends SQLException {
}
/**
* Constructs a <code>SQLClientInfoException</code> object initialized with a
* given <code>failedProperties</code>.
* The <code>reason</code> and <code>SQLState</code> are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLClientInfoException} object initialized with a
* given {@code failedProperties}.
* The {@code reason} and {@code SQLState} are initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -84,7 +84,7 @@ public class SQLClientInfoException extends SQLException {
* contain the names of the client info
* properties that could not be set and
* the values contain one of the reason codes
* defined in <code>ClientInfoStatus</code>
* defined in {@code ClientInfoStatus}
*
* @since 1.6
*/
@ -94,20 +94,20 @@ public class SQLClientInfoException extends SQLException {
}
/**
* Constructs a <code>SQLClientInfoException</code> object initialized with
* a given <code>cause</code> and <code>failedProperties</code>.
* Constructs a {@code SQLClientInfoException} object initialized with
* a given {@code cause} and {@code failedProperties}.
*
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code> and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null} and the vendor code is initialized to 0.
*
* @param failedProperties A Map containing the property values that could not
* be set. The keys in the Map
* contain the names of the client info
* properties that could not be set and
* the values contain one of the reason codes
* defined in <code>ClientInfoStatus</code>
* @param cause the (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* defined in {@code ClientInfoStatus}
* @param cause the (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
*
* @since 1.6
@ -121,12 +121,12 @@ public class SQLClientInfoException extends SQLException {
}
/**
* Constructs a <code>SQLClientInfoException</code> object initialized with a
* given <code>reason</code> and <code>failedProperties</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLClientInfoException} object initialized with a
* given {@code reason} and {@code failedProperties}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -136,7 +136,7 @@ public class SQLClientInfoException extends SQLException {
* contain the names of the client info
* properties that could not be set and
* the values contain one of the reason codes
* defined in <code>ClientInfoStatus</code>
* defined in {@code ClientInfoStatus}
*
* @since 1.6
*/
@ -148,11 +148,11 @@ public class SQLClientInfoException extends SQLException {
}
/**
* Constructs a <code>SQLClientInfoException</code> object initialized with a
* given <code>reason</code>, <code>cause</code> and
* <code>failedProperties</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLClientInfoException} object initialized with a
* given {@code reason}, {@code cause} and
* {@code failedProperties}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
*
* @param reason a description of the exception
* @param failedProperties A Map containing the property values that could not
@ -160,8 +160,8 @@ public class SQLClientInfoException extends SQLException {
* contain the names of the client info
* properties that could not be set and
* the values contain one of the reason codes
* defined in <code>ClientInfoStatus</code>
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* defined in {@code ClientInfoStatus}
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
*
* @since 1.6
@ -176,10 +176,10 @@ public class SQLClientInfoException extends SQLException {
}
/**
* Constructs a <code>SQLClientInfoException</code> object initialized with a
* given <code>reason</code>, <code>SQLState</code> and
* <code>failedProperties</code>.
* The <code>cause</code> is not initialized, and may subsequently be
* Constructs a {@code SQLClientInfoException} object initialized with a
* given {@code reason}, {@code SQLState} and
* {@code failedProperties}.
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The vendor code
* is initialized to 0.
@ -191,7 +191,7 @@ public class SQLClientInfoException extends SQLException {
* contain the names of the client info
* properties that could not be set and
* the values contain one of the reason codes
* defined in <code>ClientInfoStatus</code>
* defined in {@code ClientInfoStatus}
*
* @since 1.6
*/
@ -204,9 +204,9 @@ public class SQLClientInfoException extends SQLException {
}
/**
* Constructs a <code>SQLClientInfoException</code> object initialized with a
* given <code>reason</code>, <code>SQLState</code>, <code>cause</code>
* and <code>failedProperties</code>. The vendor code is initialized to 0.
* Constructs a {@code SQLClientInfoException} object initialized with a
* given {@code reason}, {@code SQLState}, {@code cause}
* and {@code failedProperties}. The vendor code is initialized to 0.
*
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
@ -215,8 +215,8 @@ public class SQLClientInfoException extends SQLException {
* contain the names of the client info
* properties that could not be set and
* the values contain one of the reason codes
* defined in <code>ClientInfoStatus</code>
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* defined in {@code ClientInfoStatus}
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
*
* @since 1.6
@ -232,10 +232,10 @@ public class SQLClientInfoException extends SQLException {
}
/**
* Constructs a <code>SQLClientInfoException</code> object initialized with a
* given <code>reason</code>, <code>SQLState</code>,
* <code>vendorCode</code> and <code>failedProperties</code>.
* The <code>cause</code> is not initialized, and may subsequently be
* Constructs a {@code SQLClientInfoException} object initialized with a
* given {@code reason}, {@code SQLState},
* {@code vendorCode} and {@code failedProperties}.
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -247,7 +247,7 @@ public class SQLClientInfoException extends SQLException {
* contain the names of the client info
* properties that could not be set and
* the values contain one of the reason codes
* defined in <code>ClientInfoStatus</code>
* defined in {@code ClientInfoStatus}
*
* @since 1.6
*/
@ -261,10 +261,10 @@ public class SQLClientInfoException extends SQLException {
}
/**
* Constructs a <code>SQLClientInfoException</code> object initialized with a
* given <code>reason</code>, <code>SQLState</code>,
* <code>cause</code>, <code>vendorCode</code> and
* <code>failedProperties</code>.
* Constructs a {@code SQLClientInfoException} object initialized with a
* given {@code reason}, {@code SQLState},
* {@code cause}, {@code vendorCode} and
* {@code failedProperties}.
*
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
@ -274,8 +274,8 @@ public class SQLClientInfoException extends SQLException {
* contain the names of the client info
* properties that could not be set and
* the values contain one of the reason codes
* defined in <code>ClientInfoStatus</code>
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* defined in {@code ClientInfoStatus}
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
*
* @since 1.6
@ -295,7 +295,7 @@ public class SQLClientInfoException extends SQLException {
* Returns the list of client info properties that could not be set. The
* keys in the Map contain the names of the client info
* properties that could not be set and the values contain one of the
* reason codes defined in <code>ClientInfoStatus</code>
* reason codes defined in {@code ClientInfoStatus}
*
* @return Map list containing the client info properties that could
* not be set

@ -28,18 +28,18 @@ package java.sql;
/**
* The interface used for the custom mapping of an SQL user-defined type (UDT) to
* a class in the Java programming language. The class object for a class
* implementing the <code>SQLData</code> interface will be entered in the
* appropriate <code>Connection</code> object's type map along with the SQL
* implementing the {@code SQLData} interface will be entered in the
* appropriate {@code Connection} object's type map along with the SQL
* name of the UDT for which it is a custom mapping.
* <P>
* Typically, a <code>SQLData</code> implementation
* Typically, a {@code SQLData} implementation
* will define a field for each attribute of an SQL structured type or a
* single field for an SQL <code>DISTINCT</code> type. When the UDT is
* retrieved from a data source with the <code>ResultSet.getObject</code>
* single field for an SQL {@code DISTINCT} type. When the UDT is
* retrieved from a data source with the {@code ResultSet.getObject}
* method, it will be mapped as an instance of this class. A programmer
* can operate on this class instance just as on any other object in the
* Java programming language and then store any changes made to it by
* calling the <code>PreparedStatement.setObject</code> method,
* calling the {@code PreparedStatement.setObject} method,
* which will map it back to the SQL type.
* <p>
* It is expected that the implementation of the class for a custom
@ -47,17 +47,17 @@ package java.sql;
* programmer would simply supply the name of the SQL UDT, the name of
* the class to which it is being mapped, and the names of the fields to
* which each of the attributes of the UDT is to be mapped. The tool will use
* this information to implement the <code>SQLData.readSQL</code> and
* <code>SQLData.writeSQL</code> methods. The <code>readSQL</code> method
* calls the appropriate <code>SQLInput</code> methods to read
* each attribute from an <code>SQLInput</code> object, and the
* <code>writeSQL</code> method calls <code>SQLOutput</code> methods
* this information to implement the {@code SQLData.readSQL} and
* {@code SQLData.writeSQL} methods. The {@code readSQL} method
* calls the appropriate {@code SQLInput} methods to read
* each attribute from an {@code SQLInput} object, and the
* {@code writeSQL} method calls {@code SQLOutput} methods
* to write each attribute back to the data source via an
* <code>SQLOutput</code> object.
* {@code SQLOutput} object.
* <P>
* An application programmer will not normally call <code>SQLData</code> methods
* directly, and the <code>SQLInput</code> and <code>SQLOutput</code> methods
* are called internally by <code>SQLData</code> methods, not by application code.
* An application programmer will not normally call {@code SQLData} methods
* directly, and the {@code SQLInput} and {@code SQLOutput} methods
* are called internally by {@code SQLData} methods, not by application code.
*
* @since 1.2
*/
@ -68,9 +68,9 @@ public interface SQLData {
* name of the SQL user-defined type that this object represents.
* This method is called by the JDBC driver to get the name of the
* UDT instance that is being mapped to this instance of
* <code>SQLData</code>.
* {@code SQLData}.
*
* @return the type name that was passed to the method <code>readSQL</code>
* @return the type name that was passed to the method {@code readSQL}
* when this object was constructed and populated
* @throws SQLException if there is a database access error
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -88,20 +88,20 @@ public interface SQLData {
* by calling a method of the input stream to read each
* item, in the order that they appear in the SQL definition
* of the type.
* <LI>The method <code>readSQL</code> then
* <LI>The method {@code readSQL} then
* assigns the data to appropriate fields or
* elements (of this or other objects).
* Specifically, it must call the appropriate <i>reader</i> method
* (<code>SQLInput.readString</code>, <code>SQLInput.readBigDecimal</code>,
* ({@code SQLInput.readString}, {@code SQLInput.readBigDecimal},
* and so on) method(s) to do the following:
* for a distinct type, read its single data element;
* for a structured type, read a value for each attribute of the SQL type.
* </UL>
* The JDBC driver initializes the input stream with a type map
* before calling this method, which is used by the appropriate
* <code>SQLInput</code> reader method on the stream.
* {@code SQLInput} reader method on the stream.
*
* @param stream the <code>SQLInput</code> object from which to read the data for
* @param stream the {@code SQLInput} object from which to read the data for
* the value that is being custom mapped
* @param typeName the SQL type name of the value on the data stream
* @throws SQLException if there is a database access error
@ -120,12 +120,12 @@ public interface SQLData {
* to the given output stream. This is done by calling a
* method of the output stream to write each item, in the order that
* they appear in the SQL definition of the type.
* Specifically, it must call the appropriate <code>SQLOutput</code> writer
* method(s) (<code>writeInt</code>, <code>writeString</code>, and so on)
* Specifically, it must call the appropriate {@code SQLOutput} writer
* method(s) ({@code writeInt}, {@code writeString}, and so on)
* to do the following: for a Distinct Type, write its single data element;
* for a Structured Type, write a value for each attribute of the SQL type.
*
* @param stream the <code>SQLOutput</code> object to which to write the data for
* @param stream the {@code SQLOutput} object to which to write the data for
* the value that was custom mapped
* @throws SQLException if there is a database access error
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2020, 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
@ -32,17 +32,17 @@ package java.sql;
* division by 0, and invalid arguments to functions.
* <p>
* Please consult your driver vendor documentation for the vendor-specified
* conditions for which this <code>Exception</code> may be thrown.
* conditions for which this {@code Exception} may be thrown.
* @since 1.6
*/
public class SQLDataException extends SQLNonTransientException {
/**
* Constructs a <code>SQLDataException</code> object.
* The <code>reason</code>, <code>SQLState</code> are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLDataException} object.
* The {@code reason}, {@code SQLState} are initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -53,12 +53,12 @@ public class SQLDataException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLDataException</code> object with a given
* <code>reason</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLDataException} object with a given
* {@code reason}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -70,11 +70,11 @@ public class SQLDataException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLDataException</code> object with a given
* <code>reason</code> and <code>SQLState</code>. The
* Constructs a {@code SQLDataException} object with a given
* {@code reason} and {@code SQLState}. The
* vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -87,11 +87,11 @@ public class SQLDataException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLDataException</code> object with a given
* <code>reason</code>, <code>SQLState</code> and
* <code>vendorCode</code>.
* Constructs a {@code SQLDataException} object with a given
* {@code reason}, {@code SQLState} and
* {@code vendorCode}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -105,15 +105,15 @@ public class SQLDataException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLDataException</code> object with a given
* <code>cause</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* Constructs a {@code SQLDataException} object with a given
* {@code cause}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
*
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -122,13 +122,13 @@ public class SQLDataException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLDataException</code> object with a given
* <code>reason</code> and <code>cause</code>.
* The <code>SQLState</code> is initialized to <code>null</code>
* Constructs a {@code SQLDataException} object with a given
* {@code reason} and {@code cause}.
* The {@code SQLState} is initialized to {@code null}
* and the vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -137,13 +137,13 @@ public class SQLDataException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLDataException</code> object with a given
* <code>reason</code>, <code>SQLState</code> and <code>cause</code>.
* Constructs a {@code SQLDataException} object with a given
* {@code reason}, {@code SQLState} and {@code cause}.
* The vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -152,14 +152,14 @@ public class SQLDataException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLDataException</code> object with a given
* <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* and <code>cause</code>.
* Constructs a {@code SQLDataException} object with a given
* {@code reason}, {@code SQLState}, {@code vendorCode}
* and {@code cause}.
*
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode a database vendor-specific exception code
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/

@ -1,5 +1,5 @@
/*
* Copyright (c) 1996, 2014, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1996, 2020, 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
@ -33,21 +33,21 @@ import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
* <P>An exception that provides information on a database access
* error or other errors.
*
* <P>Each <code>SQLException</code> provides several kinds of information:
* <P>Each {@code SQLException} provides several kinds of information:
* <UL>
* <LI> a string describing the error. This is used as the Java Exception
* message, available via the method <code>getMessage</code>.
* message, available via the method {@code getMessage}.
* <LI> a "SQLstate" string, which follows either the XOPEN SQLstate conventions
* or the SQL:2003 conventions.
* The values of the SQLState string are described in the appropriate spec.
* The <code>DatabaseMetaData</code> method <code>getSQLStateType</code>
* The {@code DatabaseMetaData} method {@code getSQLStateType}
* can be used to discover whether the driver returns the XOPEN type or
* the SQL:2003 type.
* <LI> an integer error code that is specific to each vendor. Normally this will
* be the actual error code returned by the underlying database.
* <LI> a chain to a next Exception. This can be used to provide additional
* error information.
* <LI> the causal relationship, if any for this <code>SQLException</code>.
* <LI> the causal relationship, if any for this {@code SQLException}.
* </UL>
*
* @since 1.1
@ -56,11 +56,11 @@ public class SQLException extends java.lang.Exception
implements Iterable<Throwable> {
/**
* Constructs a <code>SQLException</code> object with a given
* <code>reason</code>, <code>SQLState</code> and
* <code>vendorCode</code>.
* Constructs a {@code SQLException} object with a given
* {@code reason}, {@code SQLState} and
* {@code vendorCode}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -83,10 +83,10 @@ public class SQLException extends java.lang.Exception
/**
* Constructs a <code>SQLException</code> object with a given
* <code>reason</code> and <code>SQLState</code>.
* Constructs a {@code SQLException} object with a given
* {@code reason} and {@code SQLState}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The vendor code
* is initialized to 0.
@ -107,11 +107,11 @@ public class SQLException extends java.lang.Exception
}
/**
* Constructs a <code>SQLException</code> object with a given
* <code>reason</code>. The <code>SQLState</code> is initialized to
* <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLException} object with a given
* {@code reason}. The {@code SQLState} is initialized to
* {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -129,11 +129,11 @@ public class SQLException extends java.lang.Exception
}
/**
* Constructs a <code>SQLException</code> object.
* The <code>reason</code>, <code>SQLState</code> are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLException} object.
* The {@code reason}, {@code SQLState} are initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -150,16 +150,16 @@ public class SQLException extends java.lang.Exception
}
/**
* Constructs a <code>SQLException</code> object with a given
* <code>cause</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* Constructs a {@code SQLException} object with a given
* {@code cause}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
*
* @param cause the underlying reason for this <code>SQLException</code>
* (which is saved for later retrieval by the <code>getCause()</code> method);
* @param cause the underlying reason for this {@code SQLException}
* (which is saved for later retrieval by the {@code getCause()} method);
* may be null indicating the cause is non-existent or unknown.
* @since 1.6
*/
@ -174,14 +174,14 @@ public class SQLException extends java.lang.Exception
}
/**
* Constructs a <code>SQLException</code> object with a given
* <code>reason</code> and <code>cause</code>.
* The <code>SQLState</code> is initialized to <code>null</code>
* Constructs a {@code SQLException} object with a given
* {@code reason} and {@code cause}.
* The {@code SQLState} is initialized to {@code null}
* and the vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param cause the underlying reason for this <code>SQLException</code>
* (which is saved for later retrieval by the <code>getCause()</code> method);
* @param cause the underlying reason for this {@code SQLException}
* (which is saved for later retrieval by the {@code getCause()} method);
* may be null indicating the cause is non-existent or unknown.
* @since 1.6
*/
@ -196,15 +196,15 @@ public class SQLException extends java.lang.Exception
}
/**
* Constructs a <code>SQLException</code> object with a given
* <code>reason</code>, <code>SQLState</code> and <code>cause</code>.
* Constructs a {@code SQLException} object with a given
* {@code reason}, {@code SQLState} and {@code cause}.
* The vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param sqlState an XOPEN or SQL:2003 code identifying the exception
* @param cause the underlying reason for this <code>SQLException</code>
* @param cause the underlying reason for this {@code SQLException}
* (which is saved for later retrieval by the
* <code>getCause()</code> method); may be null indicating
* {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -222,15 +222,15 @@ public class SQLException extends java.lang.Exception
}
/**
* Constructs a <code>SQLException</code> object with a given
* <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* and <code>cause</code>.
* Constructs a {@code SQLException} object with a given
* {@code reason}, {@code SQLState}, {@code vendorCode}
* and {@code cause}.
*
* @param reason a description of the exception
* @param sqlState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode a database vendor-specific exception code
* @param cause the underlying reason for this <code>SQLException</code>
* (which is saved for later retrieval by the <code>getCause()</code> method);
* @param cause the underlying reason for this {@code SQLException}
* (which is saved for later retrieval by the {@code getCause()} method);
* may be null indicating the cause is non-existent or unknown.
* @since 1.6
*/
@ -249,7 +249,7 @@ public class SQLException extends java.lang.Exception
}
/**
* Retrieves the SQLState for this <code>SQLException</code> object.
* Retrieves the SQLState for this {@code SQLException} object.
*
* @return the SQLState value
*/
@ -259,7 +259,7 @@ public class SQLException extends java.lang.Exception
/**
* Retrieves the vendor-specific exception code
* for this <code>SQLException</code> object.
* for this {@code SQLException} object.
*
* @return the vendor's error code
*/
@ -269,10 +269,10 @@ public class SQLException extends java.lang.Exception
/**
* Retrieves the exception chained to this
* <code>SQLException</code> object by setNextException(SQLException ex).
* {@code SQLException} object by setNextException(SQLException ex).
*
* @return the next <code>SQLException</code> object in the chain;
* <code>null</code> if there are none
* @return the next {@code SQLException} object in the chain;
* {@code null} if there are none
* @see #setNextException
*/
public SQLException getNextException() {
@ -280,10 +280,10 @@ public class SQLException extends java.lang.Exception
}
/**
* Adds an <code>SQLException</code> object to the end of the chain.
* Adds an {@code SQLException} object to the end of the chain.
*
* @param ex the new exception that will be added to the end of
* the <code>SQLException</code> chain
* the {@code SQLException} chain
* @see #getNextException
*/
public void setNextException(SQLException ex) {

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2020, 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
@ -43,11 +43,11 @@ package java.sql;
public class SQLFeatureNotSupportedException extends SQLNonTransientException {
/**
* Constructs a <code>SQLFeatureNotSupportedException</code> object.
* The <code>reason</code>, <code>SQLState</code> are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLFeatureNotSupportedException} object.
* The {@code reason}, {@code SQLState} are initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -58,12 +58,12 @@ public class SQLFeatureNotSupportedException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLFeatureNotSupportedException</code> object
* with a given <code>reason</code>. The <code>SQLState</code>
* is initialized to <code>null</code> and the vendor code is initialized
* Constructs a {@code SQLFeatureNotSupportedException} object
* with a given {@code reason}. The {@code SQLState}
* is initialized to {@code null} and the vendor code is initialized
* to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -75,10 +75,10 @@ public class SQLFeatureNotSupportedException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLFeatureNotSupportedException</code> object
* with a given <code>reason</code> and <code>SQLState</code>.
* Constructs a {@code SQLFeatureNotSupportedException} object
* with a given {@code reason} and {@code SQLState}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The vendor code
* is initialized to 0.
@ -92,11 +92,11 @@ public class SQLFeatureNotSupportedException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLFeatureNotSupportedException</code> object
* with a given <code>reason</code>, <code>SQLState</code> and
* <code>vendorCode</code>.
* Constructs a {@code SQLFeatureNotSupportedException} object
* with a given {@code reason}, {@code SQLState} and
* {@code vendorCode}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -110,15 +110,15 @@ public class SQLFeatureNotSupportedException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLFeatureNotSupportedException</code> object
* with a given <code>cause</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* Constructs a {@code SQLFeatureNotSupportedException} object
* with a given {@code cause}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
*
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -127,14 +127,14 @@ public class SQLFeatureNotSupportedException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLFeatureNotSupportedException</code> object
* Constructs a {@code SQLFeatureNotSupportedException} object
* with a given
* <code>reason</code> and <code>cause</code>.
* The <code>SQLState</code> is initialized to <code>null</code>
* {@code reason} and {@code cause}.
* The {@code SQLState} is initialized to {@code null}
* and the vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -143,14 +143,14 @@ public class SQLFeatureNotSupportedException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLFeatureNotSupportedException</code> object
* Constructs a {@code SQLFeatureNotSupportedException} object
* with a given
* <code>reason</code>, <code>SQLState</code> and <code>cause</code>.
* {@code reason}, {@code SQLState} and {@code cause}.
* The vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param cause the (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -159,15 +159,15 @@ public class SQLFeatureNotSupportedException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLFeatureNotSupportedException</code> object
* Constructs a {@code SQLFeatureNotSupportedException} object
* with a given
* <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* and <code>cause</code>.
* {@code reason}, {@code SQLState}, {@code vendorCode}
* and {@code cause}.
*
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode a database vendor-specific exception code
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/

@ -30,24 +30,24 @@ package java.sql;
* instance of an SQL structured type or an SQL distinct type.
* This interface, used only for custom mapping, is used by the driver
* behind the scenes, and a programmer never directly invokes
* <code>SQLInput</code> methods. The <i>reader</i> methods
* (<code>readLong</code>, <code>readBytes</code>, and so on)
* provide a way for an implementation of the <code>SQLData</code>
* interface to read the values in an <code>SQLInput</code> object.
* And as described in <code>SQLData</code>, calls to reader methods must
* {@code SQLInput} methods. The <i>reader</i> methods
* ({@code readLong}, {@code readBytes}, and so on)
* provide a way for an implementation of the {@code SQLData}
* interface to read the values in an {@code SQLInput} object.
* And as described in {@code SQLData}, calls to reader methods must
* be made in the order that their corresponding attributes appear in the
* SQL definition of the type.
* The method <code>wasNull</code> is used to determine whether
* the last value read was SQL <code>NULL</code>.
* <P>When the method <code>getObject</code> is called with an
* object of a class implementing the interface <code>SQLData</code>,
* the JDBC driver calls the method <code>SQLData.getSQLType</code>
* The method {@code wasNull} is used to determine whether
* the last value read was SQL {@code NULL}.
* <P>When the method {@code getObject} is called with an
* object of a class implementing the interface {@code SQLData},
* the JDBC driver calls the method {@code SQLData.getSQLType}
* to determine the SQL type of the user-defined type (UDT)
* being custom mapped. The driver
* creates an instance of <code>SQLInput</code>, populating it with the
* creates an instance of {@code SQLInput}, populating it with the
* attributes of the UDT. The driver then passes the input
* stream to the method <code>SQLData.readSQL</code>, which in turn
* calls the <code>SQLInput</code> reader methods
* stream to the method {@code SQLData.readSQL}, which in turn
* calls the {@code SQLInput} reader methods
* in its implementation for reading the
* attributes from the input stream.
* @since 1.2
@ -63,10 +63,10 @@ public interface SQLInput {
//================================================================
/**
* Reads the next attribute in the stream and returns it as a <code>String</code>
* Reads the next attribute in the stream and returns it as a {@code String}
* in the Java programming language.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>null</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code null}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -75,10 +75,10 @@ public interface SQLInput {
String readString() throws SQLException;
/**
* Reads the next attribute in the stream and returns it as a <code>boolean</code>
* Reads the next attribute in the stream and returns it as a {@code boolean}
* in the Java programming language.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>false</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code false}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -87,10 +87,10 @@ public interface SQLInput {
boolean readBoolean() throws SQLException;
/**
* Reads the next attribute in the stream and returns it as a <code>byte</code>
* Reads the next attribute in the stream and returns it as a {@code byte}
* in the Java programming language.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>0</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code 0}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -99,10 +99,10 @@ public interface SQLInput {
byte readByte() throws SQLException;
/**
* Reads the next attribute in the stream and returns it as a <code>short</code>
* Reads the next attribute in the stream and returns it as a {@code short}
* in the Java programming language.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>0</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code 0}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -111,10 +111,10 @@ public interface SQLInput {
short readShort() throws SQLException;
/**
* Reads the next attribute in the stream and returns it as an <code>int</code>
* Reads the next attribute in the stream and returns it as an {@code int}
* in the Java programming language.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>0</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code 0}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -123,10 +123,10 @@ public interface SQLInput {
int readInt() throws SQLException;
/**
* Reads the next attribute in the stream and returns it as a <code>long</code>
* Reads the next attribute in the stream and returns it as a {@code long}
* in the Java programming language.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>0</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code 0}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -135,10 +135,10 @@ public interface SQLInput {
long readLong() throws SQLException;
/**
* Reads the next attribute in the stream and returns it as a <code>float</code>
* Reads the next attribute in the stream and returns it as a {@code float}
* in the Java programming language.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>0</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code 0}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -147,10 +147,10 @@ public interface SQLInput {
float readFloat() throws SQLException;
/**
* Reads the next attribute in the stream and returns it as a <code>double</code>
* Reads the next attribute in the stream and returns it as a {@code double}
* in the Java programming language.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>0</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code 0}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -159,10 +159,10 @@ public interface SQLInput {
double readDouble() throws SQLException;
/**
* Reads the next attribute in the stream and returns it as a <code>java.math.BigDecimal</code>
* Reads the next attribute in the stream and returns it as a {@code java.math.BigDecimal}
* object in the Java programming language.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>null</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code null}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -174,7 +174,7 @@ public interface SQLInput {
* Reads the next attribute in the stream and returns it as an array of bytes
* in the Java programming language.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>null</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code null}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -183,9 +183,9 @@ public interface SQLInput {
byte[] readBytes() throws SQLException;
/**
* Reads the next attribute in the stream and returns it as a <code>java.sql.Date</code> object.
* Reads the next attribute in the stream and returns it as a {@code java.sql.Date} object.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>null</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code null}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -194,9 +194,9 @@ public interface SQLInput {
java.sql.Date readDate() throws SQLException;
/**
* Reads the next attribute in the stream and returns it as a <code>java.sql.Time</code> object.
* Reads the next attribute in the stream and returns it as a {@code java.sql.Time} object.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>null</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code null}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -205,9 +205,9 @@ public interface SQLInput {
java.sql.Time readTime() throws SQLException;
/**
* Reads the next attribute in the stream and returns it as a <code>java.sql.Timestamp</code> object.
* Reads the next attribute in the stream and returns it as a {@code java.sql.Timestamp} object.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>null</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code null}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -218,7 +218,7 @@ public interface SQLInput {
/**
* Reads the next attribute in the stream and returns it as a stream of Unicode characters.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>null</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code null}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -229,7 +229,7 @@ public interface SQLInput {
/**
* Reads the next attribute in the stream and returns it as a stream of ASCII characters.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>null</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code null}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -241,7 +241,7 @@ public interface SQLInput {
* Reads the next attribute in the stream and returns it as a stream of uninterpreted
* bytes.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>null</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code null}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -255,23 +255,23 @@ public interface SQLInput {
/**
* Reads the datum at the head of the stream and returns it as an
* <code>Object</code> in the Java programming language. The
* {@code Object} in the Java programming language. The
* actual type of the object returned is determined by the default type
* mapping, and any customizations present in this stream's type map.
*
* <P>A type map is registered with the stream by the JDBC driver before the
* stream is passed to the application.
*
* <P>When the datum at the head of the stream is an SQL <code>NULL</code>,
* the method returns <code>null</code>. If the datum is an SQL structured or distinct
* <P>When the datum at the head of the stream is an SQL {@code NULL},
* the method returns {@code null}. If the datum is an SQL structured or distinct
* type, it determines the SQL type of the datum at the head of the stream.
* If the stream's type map has an entry for that SQL type, the driver
* constructs an object of the appropriate class and calls the method
* <code>SQLData.readSQL</code> on that object, which reads additional data from the
* {@code SQLData.readSQL} on that object, which reads additional data from the
* stream, using the protocol described for that method.
*
* @return the datum at the head of the stream as an <code>Object</code> in the
* Java programming language;<code>null</code> if the datum is SQL <code>NULL</code>
* @return the datum at the head of the stream as an {@code Object} in the
* Java programming language;{@code null} if the datum is SQL {@code NULL}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -280,12 +280,12 @@ public interface SQLInput {
Object readObject() throws SQLException;
/**
* Reads an SQL <code>REF</code> value from the stream and returns it as a
* <code>Ref</code> object in the Java programming language.
* Reads an SQL {@code REF} value from the stream and returns it as a
* {@code Ref} object in the Java programming language.
*
* @return a <code>Ref</code> object representing the SQL <code>REF</code> value
* at the head of the stream; <code>null</code> if the value read is
* SQL <code>NULL</code>
* @return a {@code Ref} object representing the SQL {@code REF} value
* at the head of the stream; {@code null} if the value read is
* SQL {@code NULL}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -294,12 +294,12 @@ public interface SQLInput {
Ref readRef() throws SQLException;
/**
* Reads an SQL <code>BLOB</code> value from the stream and returns it as a
* <code>Blob</code> object in the Java programming language.
* Reads an SQL {@code BLOB} value from the stream and returns it as a
* {@code Blob} object in the Java programming language.
*
* @return a <code>Blob</code> object representing data of the SQL <code>BLOB</code> value
* at the head of the stream; <code>null</code> if the value read is
* SQL <code>NULL</code>
* @return a {@code Blob} object representing data of the SQL {@code BLOB} value
* at the head of the stream; {@code null} if the value read is
* SQL {@code NULL}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -308,12 +308,12 @@ public interface SQLInput {
Blob readBlob() throws SQLException;
/**
* Reads an SQL <code>CLOB</code> value from the stream and returns it as a
* <code>Clob</code> object in the Java programming language.
* Reads an SQL {@code CLOB} value from the stream and returns it as a
* {@code Clob} object in the Java programming language.
*
* @return a <code>Clob</code> object representing data of the SQL <code>CLOB</code> value
* at the head of the stream; <code>null</code> if the value read is
* SQL <code>NULL</code>
* @return a {@code Clob} object representing data of the SQL {@code CLOB} value
* at the head of the stream; {@code null} if the value read is
* SQL {@code NULL}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -322,12 +322,12 @@ public interface SQLInput {
Clob readClob() throws SQLException;
/**
* Reads an SQL <code>ARRAY</code> value from the stream and returns it as an
* <code>Array</code> object in the Java programming language.
* Reads an SQL {@code ARRAY} value from the stream and returns it as an
* {@code Array} object in the Java programming language.
*
* @return an <code>Array</code> object representing data of the SQL
* <code>ARRAY</code> value at the head of the stream; <code>null</code>
* if the value read is SQL <code>NULL</code>
* @return an {@code Array} object representing data of the SQL
* {@code ARRAY} value at the head of the stream; {@code null}
* if the value read is SQL {@code NULL}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -336,10 +336,10 @@ public interface SQLInput {
Array readArray() throws SQLException;
/**
* Retrieves whether the last value read was SQL <code>NULL</code>.
* Retrieves whether the last value read was SQL {@code NULL}.
*
* @return <code>true</code> if the most recently read SQL value was SQL
* <code>NULL</code>; <code>false</code> otherwise
* @return {@code true} if the most recently read SQL value was SQL
* {@code NULL}; {@code false} otherwise
* @throws SQLException if a database access error occurs
*
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -351,10 +351,10 @@ public interface SQLInput {
//---------------------------- JDBC 3.0 -------------------------
/**
* Reads an SQL <code>DATALINK</code> value from the stream and returns it as a
* <code>java.net.URL</code> object in the Java programming language.
* Reads an SQL {@code DATALINK} value from the stream and returns it as a
* {@code java.net.URL} object in the Java programming language.
*
* @return a <code>java.net.URL</code> object.
* @return a {@code java.net.URL} object.
* @throws SQLException if a database access error occurs,
* or if a URL is malformed
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -366,12 +366,12 @@ public interface SQLInput {
//---------------------------- JDBC 4.0 -------------------------
/**
* Reads an SQL <code>NCLOB</code> value from the stream and returns it as a
* <code>NClob</code> object in the Java programming language.
* Reads an SQL {@code NCLOB} value from the stream and returns it as a
* {@code NClob} object in the Java programming language.
*
* @return a <code>NClob</code> object representing data of the SQL <code>NCLOB</code> value
* at the head of the stream; <code>null</code> if the value read is
* SQL <code>NULL</code>
* @return a {@code NClob} object representing data of the SQL {@code NCLOB} value
* at the head of the stream; {@code null} if the value read is
* SQL {@code NULL}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -380,12 +380,12 @@ public interface SQLInput {
NClob readNClob() throws SQLException;
/**
* Reads the next attribute in the stream and returns it as a <code>String</code>
* Reads the next attribute in the stream and returns it as a {@code String}
* in the Java programming language. It is intended for use when
* accessing <code>NCHAR</code>,<code>NVARCHAR</code>
* and <code>LONGNVARCHAR</code> columns.
* accessing {@code NCHAR},{@code NVARCHAR}
* and {@code LONGNVARCHAR} columns.
*
* @return the attribute; if the value is SQL <code>NULL</code>, returns <code>null</code>
* @return the attribute; if the value is SQL {@code NULL}, returns {@code null}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -394,12 +394,12 @@ public interface SQLInput {
String readNString() throws SQLException;
/**
* Reads an SQL <code>XML</code> value from the stream and returns it as a
* <code>SQLXML</code> object in the Java programming language.
* Reads an SQL {@code XML} value from the stream and returns it as a
* {@code SQLXML} object in the Java programming language.
*
* @return a <code>SQLXML</code> object representing data of the SQL <code>XML</code> value
* at the head of the stream; <code>null</code> if the value read is
* SQL <code>NULL</code>
* @return a {@code SQLXML} object representing data of the SQL {@code XML} value
* at the head of the stream; {@code null} if the value read is
* SQL {@code NULL}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -408,12 +408,12 @@ public interface SQLInput {
SQLXML readSQLXML() throws SQLException;
/**
* Reads an SQL <code>ROWID</code> value from the stream and returns it as a
* <code>RowId</code> object in the Java programming language.
* Reads an SQL {@code ROWID} value from the stream and returns it as a
* {@code RowId} object in the Java programming language.
*
* @return a <code>RowId</code> object representing data of the SQL <code>ROWID</code> value
* at the head of the stream; <code>null</code> if the value read is
* SQL <code>NULL</code>
* @return a {@code RowId} object representing data of the SQL {@code ROWID} value
* at the head of the stream; {@code null} if the value read is
* SQL {@code NULL}
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2020, 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
@ -32,17 +32,17 @@ package java.sql;
* constraint (foreign key, primary key or unique key) has been violated.
* <p>
* Please consult your driver vendor documentation for the vendor-specified
* conditions for which this <code>Exception</code> may be thrown.
* conditions for which this {@code Exception} may be thrown.
* @since 1.6
*/
public class SQLIntegrityConstraintViolationException extends SQLNonTransientException {
/**
* Constructs a <code>SQLIntegrityConstraintViolationException</code> object.
* The <code>reason</code>, <code>SQLState</code> are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLIntegrityConstraintViolationException} object.
* The {@code reason}, {@code SQLState} are initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -53,12 +53,12 @@ public class SQLIntegrityConstraintViolationException extends SQLNonTransientExc
}
/**
* Constructs a <code>SQLIntegrityConstraintViolationException</code>
* with a given <code>reason</code>. The <code>SQLState</code>
* is initialized to <code>null</code> and the vendor code is initialized
* Constructs a {@code SQLIntegrityConstraintViolationException}
* with a given {@code reason}. The {@code SQLState}
* is initialized to {@code null} and the vendor code is initialized
* to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -70,10 +70,10 @@ public class SQLIntegrityConstraintViolationException extends SQLNonTransientExc
}
/**
* Constructs a <code>SQLIntegrityConstraintViolationException</code>
* object with a given <code>reason</code> and <code>SQLState</code>.
* Constructs a {@code SQLIntegrityConstraintViolationException}
* object with a given {@code reason} and {@code SQLState}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The vendor code
* is initialized to 0.
@ -87,11 +87,11 @@ public class SQLIntegrityConstraintViolationException extends SQLNonTransientExc
}
/**
* Constructs a <code>SQLIntegrityConstraintViolationException</code> object
* with a given <code>reason</code>, <code>SQLState</code> and
* <code>vendorCode</code>.
* Constructs a {@code SQLIntegrityConstraintViolationException} object
* with a given {@code reason}, {@code SQLState} and
* {@code vendorCode}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -105,15 +105,15 @@ public class SQLIntegrityConstraintViolationException extends SQLNonTransientExc
}
/**
* Constructs an <code>SQLIntegrityConstraintViolationException</code> object with
* a given <code>cause</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* Constructs an {@code SQLIntegrityConstraintViolationException} object with
* a given {@code cause}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
*
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -122,14 +122,14 @@ public class SQLIntegrityConstraintViolationException extends SQLNonTransientExc
}
/**
* Constructs a <code>SQLIntegrityConstraintViolationException</code> object
* Constructs a {@code SQLIntegrityConstraintViolationException} object
* with a given
* <code>reason</code> and <code>cause</code>.
* The <code>SQLState</code> is initialized to <code>null</code>
* {@code reason} and {@code cause}.
* The {@code SQLState} is initialized to {@code null}
* and the vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param cause the (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -138,14 +138,14 @@ public class SQLIntegrityConstraintViolationException extends SQLNonTransientExc
}
/**
* Constructs a <code>SQLIntegrityConstraintViolationException</code> object
* Constructs a {@code SQLIntegrityConstraintViolationException} object
* with a given
* <code>reason</code>, <code>SQLState</code> and <code>cause</code>.
* {@code reason}, {@code SQLState} and {@code cause}.
* The vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -154,15 +154,15 @@ public class SQLIntegrityConstraintViolationException extends SQLNonTransientExc
}
/**
* Constructs a <code>SQLIntegrityConstraintViolationException</code> object
* Constructs a {@code SQLIntegrityConstraintViolationException} object
* with a given
* <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* and <code>cause</code>.
* {@code reason}, {@code SQLState}, {@code vendorCode}
* and {@code cause}.
*
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode a database vendor-specific exception code
* @param cause the (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2020, 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
@ -32,17 +32,17 @@ package java.sql;
* are not valid.
* <p>
* Please consult your driver vendor documentation for the vendor-specified
* conditions for which this <code>Exception</code> may be thrown.
* conditions for which this {@code Exception} may be thrown.
* @since 1.6
*/
public class SQLInvalidAuthorizationSpecException extends SQLNonTransientException {
/**
* Constructs a <code>SQLInvalidAuthorizationSpecException</code> object.
* The <code>reason</code>, <code>SQLState</code> are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLInvalidAuthorizationSpecException} object.
* The {@code reason}, {@code SQLState} are initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -53,12 +53,12 @@ public class SQLInvalidAuthorizationSpecException extends SQLNonTransientExcepti
}
/**
* Constructs a <code>SQLInvalidAuthorizationSpecException</code> object
* with a given <code>reason</code>. The <code>SQLState</code>
* is initialized to <code>null</code> and the vendor code is initialized
* Constructs a {@code SQLInvalidAuthorizationSpecException} object
* with a given {@code reason}. The {@code SQLState}
* is initialized to {@code null} and the vendor code is initialized
* to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -70,10 +70,10 @@ public class SQLInvalidAuthorizationSpecException extends SQLNonTransientExcepti
}
/**
* Constructs a <code>SQLInvalidAuthorizationSpecException</code> object
* with a given <code>reason</code> and <code>SQLState</code>.
* Constructs a {@code SQLInvalidAuthorizationSpecException} object
* with a given {@code reason} and {@code SQLState}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The vendor code
* is initialized to 0.
@ -87,11 +87,11 @@ public class SQLInvalidAuthorizationSpecException extends SQLNonTransientExcepti
}
/**
* Constructs a <code>SQLInvalidAuthorizationSpecException</code> object
* with a given <code>reason</code>, <code>SQLState</code> and
* <code>vendorCode</code>.
* Constructs a {@code SQLInvalidAuthorizationSpecException} object
* with a given {@code reason}, {@code SQLState} and
* {@code vendorCode}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -105,15 +105,15 @@ public class SQLInvalidAuthorizationSpecException extends SQLNonTransientExcepti
}
/**
* Constructs a <code>SQLInvalidAuthorizationSpecException</code> object
* with a given <code>cause</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* Constructs a {@code SQLInvalidAuthorizationSpecException} object
* with a given {@code cause}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
*
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -122,14 +122,14 @@ public class SQLInvalidAuthorizationSpecException extends SQLNonTransientExcepti
}
/**
* Constructs a <code>SQLInvalidAuthorizationSpecException</code> object
* Constructs a {@code SQLInvalidAuthorizationSpecException} object
* with a given
* <code>reason</code> and <code>cause</code>.
* The <code>SQLState</code> is initialized to <code>null</code>
* {@code reason} and {@code cause}.
* The {@code SQLState} is initialized to {@code null}
* and the vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -138,14 +138,14 @@ public class SQLInvalidAuthorizationSpecException extends SQLNonTransientExcepti
}
/**
* Constructs a <code>SQLInvalidAuthorizationSpecException</code> object
* Constructs a {@code SQLInvalidAuthorizationSpecException} object
* with a given
* <code>reason</code>, <code>SQLState</code> and <code>cause</code>.
* {@code reason}, {@code SQLState} and {@code cause}.
* The vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -154,15 +154,15 @@ public class SQLInvalidAuthorizationSpecException extends SQLNonTransientExcepti
}
/**
* Constructs a <code>SQLInvalidAuthorizationSpecException</code> object
* Constructs a {@code SQLInvalidAuthorizationSpecException} object
* with a given
* <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* and <code>cause</code>.
* {@code reason}, {@code SQLState}, {@code vendorCode}
* and {@code cause}.
*
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode a database vendor-specific exception code
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2020, 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
@ -32,17 +32,17 @@ package java.sql;
* the operation is retried without the cause of the failure being corrected.
* <p>
* Please consult your driver vendor documentation for the vendor-specified
* conditions for which this <code>Exception</code> may be thrown.
* conditions for which this {@code Exception} may be thrown.
* @since 1.6
*/
public class SQLNonTransientConnectionException extends java.sql.SQLNonTransientException {
/**
* Constructs a <code>SQLNonTransientConnectionException</code> object.
* The <code>reason</code>, <code>SQLState</code> are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLNonTransientConnectionException} object.
* The {@code reason}, {@code SQLState} are initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -53,12 +53,12 @@ public class SQLNonTransientConnectionException extends java.sql.SQLNonTransient
}
/**
* Constructs a <code>SQLNonTransientConnectionException</code> object
* with a given <code>reason</code>. The <code>SQLState</code>
* is initialized to <code>null</code> and the vendor code is initialized
* Constructs a {@code SQLNonTransientConnectionException} object
* with a given {@code reason}. The {@code SQLState}
* is initialized to {@code null} and the vendor code is initialized
* to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -70,10 +70,10 @@ public class SQLNonTransientConnectionException extends java.sql.SQLNonTransient
}
/**
* Constructs a <code>SQLNonTransientConnectionException</code> object
* with a given <code>reason</code> and <code>SQLState</code>.
* Constructs a {@code SQLNonTransientConnectionException} object
* with a given {@code reason} and {@code SQLState}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The vendor code
* is initialized to 0.
@ -87,11 +87,11 @@ public class SQLNonTransientConnectionException extends java.sql.SQLNonTransient
}
/**
* Constructs a <code>SQLNonTransientConnectionException</code> object
* with a given <code>reason</code>, <code>SQLState</code> and
* <code>vendorCode</code>.
* Constructs a {@code SQLNonTransientConnectionException} object
* with a given {@code reason}, {@code SQLState} and
* {@code vendorCode}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -105,15 +105,15 @@ public class SQLNonTransientConnectionException extends java.sql.SQLNonTransient
}
/**
* Constructs a <code>SQLNonTransientConnectionException</code> object
* with a given <code>cause</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* Constructs a {@code SQLNonTransientConnectionException} object
* with a given {@code cause}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
*
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -122,14 +122,14 @@ public class SQLNonTransientConnectionException extends java.sql.SQLNonTransient
}
/**
* Constructs a <code>SQLTransientException</code> object
* Constructs a {@code SQLNonTransientConnectionException} object
* with a given
* <code>reason</code> and <code>cause</code>.
* The <code>SQLState</code> is initialized to <code>null</code>
* {@code reason} and {@code cause}.
* The {@code SQLState} is initialized to {@code null}
* and the vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -138,14 +138,14 @@ public class SQLNonTransientConnectionException extends java.sql.SQLNonTransient
}
/**
* Constructs a <code>SQLNonTransientConnectionException</code> object
* Constructs a {@code SQLNonTransientConnectionException} object
* with a given
* <code>reason</code>, <code>SQLState</code> and <code>cause</code>.
* {@code reason}, {@code SQLState} and {@code cause}.
* The vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param cause the (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -154,15 +154,15 @@ public class SQLNonTransientConnectionException extends java.sql.SQLNonTransient
}
/**
* Constructs a <code>SQLNonTransientConnectionException</code> object
* Constructs a {@code SQLNonTransientConnectionException} object
* with a given
* <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* and <code>cause</code>.
* {@code reason}, {@code SQLState}, {@code vendorCode}
* and {@code cause}.
*
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode a database vendor-specific exception code
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2020, 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
@ -27,7 +27,7 @@ package java.sql;
/**
* The subclass of {@link SQLException} thrown when an instance where a retry
* of the same operation would fail unless the cause of the <code>SQLException</code>
* of the same operation would fail unless the cause of the {@code SQLException}
* is corrected.
*
* @since 1.6
@ -35,11 +35,11 @@ package java.sql;
public class SQLNonTransientException extends java.sql.SQLException {
/**
* Constructs a <code>SQLNonTransientException</code> object.
* The <code>reason</code>, <code>SQLState</code> are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLNonTransientException} object.
* The {@code reason}, {@code SQLState} are initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -50,12 +50,12 @@ public class SQLNonTransientException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLNonTransientException</code> object
* with a given <code>reason</code>. The <code>SQLState</code>
* is initialized to <code>null</code> and the vendor code is initialized
* Constructs a {@code SQLNonTransientException} object
* with a given {@code reason}. The {@code SQLState}
* is initialized to {@code null} and the vendor code is initialized
* to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -67,10 +67,10 @@ public class SQLNonTransientException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLNonTransientException</code> object
* with a given <code>reason</code> and <code>SQLState</code>.
* Constructs a {@code SQLNonTransientException} object
* with a given {@code reason} and {@code SQLState}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The vendor code
* is initialized to 0.
@ -84,11 +84,11 @@ public class SQLNonTransientException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLNonTransientException</code> object
* with a given <code>reason</code>, <code>SQLState</code> and
* <code>vendorCode</code>.
* Constructs a {@code SQLNonTransientException} object
* with a given {@code reason}, {@code SQLState} and
* {@code vendorCode}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -102,15 +102,15 @@ public class SQLNonTransientException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLNonTransientException</code> object
* with a given <code>cause</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* Constructs a {@code SQLNonTransientException} object
* with a given {@code cause}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
*
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -119,14 +119,14 @@ public class SQLNonTransientException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLTransientException</code> object
* Constructs a {@code SQLNonTransientException} object
* with a given
* <code>reason</code> and <code>cause</code>.
* The <code>SQLState</code> is initialized to <code>null</code>
* {@code reason} and {@code cause}.
* The {@code SQLState} is initialized to {@code null}
* and the vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -136,14 +136,14 @@ public class SQLNonTransientException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLNonTransientException</code> object
* Constructs a {@code SQLNonTransientException} object
* with a given
* <code>reason</code>, <code>SQLState</code> and <code>cause</code>.
* {@code reason}, {@code SQLState} and {@code cause}.
* The vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -152,15 +152,15 @@ public class SQLNonTransientException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLNonTransientException</code> object
* Constructs a {@code SQLNonTransientException} object
* with a given
* <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* and <code>cause</code>.
* {@code reason}, {@code SQLState}, {@code vendorCode}
* and {@code cause}.
*
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode a database vendor-specific exception code
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/

@ -31,17 +31,17 @@ package java.sql;
* only for custom mapping, is used by the driver, and its
* methods are never directly invoked by a programmer.
* <p>When an object of a class implementing the interface
* <code>SQLData</code> is passed as an argument to an SQL statement, the
* JDBC driver calls the method <code>SQLData.getSQLType</code> to
* {@code SQLData} is passed as an argument to an SQL statement, the
* JDBC driver calls the method {@code SQLData.getSQLType} to
* determine the kind of SQL
* datum being passed to the database.
* The driver then creates an instance of <code>SQLOutput</code> and
* passes it to the method <code>SQLData.writeSQL</code>.
* The method <code>writeSQL</code> in turn calls the
* appropriate <code>SQLOutput</code> <i>writer</i> methods
* <code>writeBoolean</code>, <code>writeCharacterStream</code>, and so on)
* to write data from the <code>SQLData</code> object to
* the <code>SQLOutput</code> output stream as the
* The driver then creates an instance of {@code SQLOutput} and
* passes it to the method {@code SQLData.writeSQL}.
* The method {@code writeSQL} in turn calls the
* appropriate {@code SQLOutput} <i>writer</i> methods
* {@code writeBoolean}, {@code writeCharacterStream}, and so on)
* to write data from the {@code SQLData} object to
* the {@code SQLOutput} output stream as the
* representation of an SQL user-defined type.
* @since 1.2
*/
@ -55,7 +55,7 @@ package java.sql;
//================================================================
/**
* Writes the next attribute to the stream as a <code>String</code>
* Writes the next attribute to the stream as a {@code String}
* in the Java programming language.
*
* @param x the value to pass to the database
@ -68,7 +68,7 @@ package java.sql;
/**
* Writes the next attribute to the stream as a Java boolean.
* Writes the next attribute to the stream as a <code>String</code>
* Writes the next attribute to the stream as a {@code String}
* in the Java programming language.
*
* @param x the value to pass to the database
@ -81,7 +81,7 @@ package java.sql;
/**
* Writes the next attribute to the stream as a Java byte.
* Writes the next attribute to the stream as a <code>String</code>
* Writes the next attribute to the stream as a {@code String}
* in the Java programming language.
*
* @param x the value to pass to the database
@ -94,7 +94,7 @@ package java.sql;
/**
* Writes the next attribute to the stream as a Java short.
* Writes the next attribute to the stream as a <code>String</code>
* Writes the next attribute to the stream as a {@code String}
* in the Java programming language.
*
* @param x the value to pass to the database
@ -107,7 +107,7 @@ package java.sql;
/**
* Writes the next attribute to the stream as a Java int.
* Writes the next attribute to the stream as a <code>String</code>
* Writes the next attribute to the stream as a {@code String}
* in the Java programming language.
*
* @param x the value to pass to the database
@ -120,7 +120,7 @@ package java.sql;
/**
* Writes the next attribute to the stream as a Java long.
* Writes the next attribute to the stream as a <code>String</code>
* Writes the next attribute to the stream as a {@code String}
* in the Java programming language.
*
* @param x the value to pass to the database
@ -133,7 +133,7 @@ package java.sql;
/**
* Writes the next attribute to the stream as a Java float.
* Writes the next attribute to the stream as a <code>String</code>
* Writes the next attribute to the stream as a {@code String}
* in the Java programming language.
*
* @param x the value to pass to the database
@ -146,7 +146,7 @@ package java.sql;
/**
* Writes the next attribute to the stream as a Java double.
* Writes the next attribute to the stream as a <code>String</code>
* Writes the next attribute to the stream as a {@code String}
* in the Java programming language.
*
* @param x the value to pass to the database
@ -159,7 +159,7 @@ package java.sql;
/**
* Writes the next attribute to the stream as a java.math.BigDecimal object.
* Writes the next attribute to the stream as a <code>String</code>
* Writes the next attribute to the stream as a {@code String}
* in the Java programming language.
*
* @param x the value to pass to the database
@ -172,7 +172,7 @@ package java.sql;
/**
* Writes the next attribute to the stream as an array of bytes.
* Writes the next attribute to the stream as a <code>String</code>
* Writes the next attribute to the stream as a {@code String}
* in the Java programming language.
*
* @param x the value to pass to the database
@ -185,7 +185,7 @@ package java.sql;
/**
* Writes the next attribute to the stream as a java.sql.Date object.
* Writes the next attribute to the stream as a <code>java.sql.Date</code> object
* Writes the next attribute to the stream as a {@code java.sql.Date} object
* in the Java programming language.
*
* @param x the value to pass to the database
@ -198,7 +198,7 @@ package java.sql;
/**
* Writes the next attribute to the stream as a java.sql.Time object.
* Writes the next attribute to the stream as a <code>java.sql.Date</code> object
* Writes the next attribute to the stream as a {@code java.sql.Date} object
* in the Java programming language.
*
* @param x the value to pass to the database
@ -211,7 +211,7 @@ package java.sql;
/**
* Writes the next attribute to the stream as a java.sql.Timestamp object.
* Writes the next attribute to the stream as a <code>java.sql.Date</code> object
* Writes the next attribute to the stream as a {@code java.sql.Date} object
* in the Java programming language.
*
* @param x the value to pass to the database
@ -266,17 +266,17 @@ package java.sql;
/**
* Writes to the stream the data contained in the given
* <code>SQLData</code> object.
* When the <code>SQLData</code> object is <code>null</code>, this
* method writes an SQL <code>NULL</code> to the stream.
* Otherwise, it calls the <code>SQLData.writeSQL</code>
* {@code SQLData} object.
* When the {@code SQLData} object is {@code null}, this
* method writes an SQL {@code NULL} to the stream.
* Otherwise, it calls the {@code SQLData.writeSQL}
* method of the given object, which
* writes the object's attributes to the stream.
* The implementation of the method <code>SQLData.writeSQL</code>
* calls the appropriate <code>SQLOutput</code> writer method(s)
* The implementation of the method {@code SQLData.writeSQL}
* calls the appropriate {@code SQLOutput} writer method(s)
* for writing each of the object's attributes in order.
* The attributes must be read from an <code>SQLInput</code>
* input stream and written to an <code>SQLOutput</code>
* The attributes must be read from an {@code SQLInput}
* input stream and written to an {@code SQLOutput}
* output stream in the same order in which they were
* listed in the SQL definition of the user-defined type.
*
@ -290,10 +290,10 @@ package java.sql;
void writeObject(SQLData x) throws SQLException;
/**
* Writes an SQL <code>REF</code> value to the stream.
* Writes an SQL {@code REF} value to the stream.
*
* @param x a <code>Ref</code> object representing data of an SQL
* <code>REF</code> value
* @param x a {@code Ref} object representing data of an SQL
* {@code REF} value
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -302,10 +302,10 @@ package java.sql;
void writeRef(Ref x) throws SQLException;
/**
* Writes an SQL <code>BLOB</code> value to the stream.
* Writes an SQL {@code BLOB} value to the stream.
*
* @param x a <code>Blob</code> object representing data of an SQL
* <code>BLOB</code> value
* @param x a {@code Blob} object representing data of an SQL
* {@code BLOB} value
*
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -315,10 +315,10 @@ package java.sql;
void writeBlob(Blob x) throws SQLException;
/**
* Writes an SQL <code>CLOB</code> value to the stream.
* Writes an SQL {@code CLOB} value to the stream.
*
* @param x a <code>Clob</code> object representing data of an SQL
* <code>CLOB</code> value
* @param x a {@code Clob} object representing data of an SQL
* {@code CLOB} value
*
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -330,7 +330,7 @@ package java.sql;
/**
* Writes an SQL structured type value to the stream.
*
* @param x a <code>Struct</code> object representing data of an SQL
* @param x a {@code Struct} object representing data of an SQL
* structured type
*
* @throws SQLException if a database access error occurs
@ -341,10 +341,10 @@ package java.sql;
void writeStruct(Struct x) throws SQLException;
/**
* Writes an SQL <code>ARRAY</code> value to the stream.
* Writes an SQL {@code ARRAY} value to the stream.
*
* @param x an <code>Array</code> object representing data of an SQL
* <code>ARRAY</code> type
* @param x an {@code Array} object representing data of an SQL
* {@code ARRAY} type
*
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -356,9 +356,9 @@ package java.sql;
//--------------------------- JDBC 3.0 ------------------------
/**
* Writes a SQL <code>DATALINK</code> value to the stream.
* Writes a SQL {@code DATALINK} value to the stream.
*
* @param x a <code>java.net.URL</code> object representing the data
* @param x a {@code java.net.URL} object representing the data
* of SQL DATALINK type
*
* @throws SQLException if a database access error occurs
@ -371,12 +371,12 @@ package java.sql;
//--------------------------- JDBC 4.0 ------------------------
/**
* Writes the next attribute to the stream as a <code>String</code>
* Writes the next attribute to the stream as a {@code String}
* in the Java programming language. The driver converts this to a
* SQL <code>NCHAR</code> or
* <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
* SQL {@code NCHAR} or
* {@code NVARCHAR} or {@code LONGNVARCHAR} value
* (depending on the argument's
* size relative to the driver's limits on <code>NVARCHAR</code> values)
* size relative to the driver's limits on {@code NVARCHAR} values)
* when it sends it to the stream.
*
* @param x the value to pass to the database
@ -388,10 +388,10 @@ package java.sql;
void writeNString(String x) throws SQLException;
/**
* Writes an SQL <code>NCLOB</code> value to the stream.
* Writes an SQL {@code NCLOB} value to the stream.
*
* @param x a <code>NClob</code> object representing data of an SQL
* <code>NCLOB</code> value
* @param x a {@code NClob} object representing data of an SQL
* {@code NCLOB} value
*
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -402,10 +402,10 @@ package java.sql;
/**
* Writes an SQL <code>ROWID</code> value to the stream.
* Writes an SQL {@code ROWID} value to the stream.
*
* @param x a <code>RowId</code> object representing data of an SQL
* <code>ROWID</code> value
* @param x a {@code RowId} object representing data of an SQL
* {@code ROWID} value
*
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -416,15 +416,15 @@ package java.sql;
/**
* Writes an SQL <code>XML</code> value to the stream.
* Writes an SQL {@code XML} value to the stream.
*
* @param x a <code>SQLXML</code> object representing data of an SQL
* <code>XML</code> value
* @param x a {@code SQLXML} object representing data of an SQL
* {@code XML} value
*
* @throws SQLException if a database access error occurs,
* the <code>java.xml.transform.Result</code>,
* <code>Writer</code> or <code>OutputStream</code> has not been closed for the <code>SQLXML</code> object or
* if there is an error processing the XML value. The <code>getCause</code> method
* the {@code java.xml.transform.Result},
* {@code Writer} or {@code OutputStream} has not been closed for the {@code SQLXML} object or
* if there is an error processing the XML value. The {@code getCause} method
* of the exception may provide a more detailed exception, for example, if the
* stream does not contain valid XML.
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2020, 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
@ -29,31 +29,31 @@ package java.sql;
import java.security.*;
/**
* The permission for which the <code>SecurityManager</code> will check
* The permission for which the {@code SecurityManager} will check
* when code that is running an application with a
* <code>SecurityManager</code> enabled, calls the
* {@code SecurityManager} enabled, calls the
* {@code DriverManager.deregisterDriver} method,
* <code>DriverManager.setLogWriter</code> method,
* <code>DriverManager.setLogStream</code> (deprecated) method,
* {@code DriverManager.setLogWriter} method,
* {@code DriverManager.setLogStream} (deprecated) method,
* {@code SyncFactory.setJNDIContext} method,
* {@code SyncFactory.setLogger} method,
* {@code Connection.setNetworkTimeout} method,
* or the <code>Connection.abort</code> method.
* If there is no <code>SQLPermission</code> object, these methods
* throw a <code>java.lang.SecurityException</code> as a runtime exception.
* or the {@code Connection.abort} method.
* If there is no {@code SQLPermission} object, these methods
* throw a {@code java.lang.SecurityException} as a runtime exception.
* <P>
* A <code>SQLPermission</code> object contains
* A {@code SQLPermission} object contains
* a name (also referred to as a "target name") but no actions
* list; there is either a named permission or there is not.
* The target name is the name of the permission (see below). The
* naming convention follows the hierarchical property naming convention.
* In addition, an asterisk
* may appear at the end of the name, following a ".", or by itself, to
* signify a wildcard match. For example: <code>loadLibrary.*</code>
* and <code>*</code> signify a wildcard match,
* while <code>*loadLibrary</code> and <code>a*b</code> do not.
* signify a wildcard match. For example: {@code loadLibrary.*}
* and {@code *} signify a wildcard match,
* while {@code *loadLibrary} and {@code a*b} do not.
* <P>
* The following table lists all the possible <code>SQLPermission</code> target names.
* The following table lists all the possible {@code SQLPermission} target names.
* The table gives a description of what the permission allows
* and a discussion of the risks of granting code the permission.
*
@ -97,8 +97,8 @@ import java.security.*;
* <td>Allows the invocation of the {@code Connection} method
* {@code setNetworkTimeout}</td>
* <td>Permits an application to specify the maximum period a
* <code>Connection</code> or
* objects created from the <code>Connection</code>
* {@code Connection} or
* objects created from the {@code Connection}
* will wait for the database to reply to any one request.</td>
* <tr>
* <th scope="row">deregisterDriver</th>
@ -122,14 +122,14 @@ import java.security.*;
public final class SQLPermission extends BasicPermission {
/**
* Creates a new <code>SQLPermission</code> object with the specified name.
* The name is the symbolic name of the <code>SQLPermission</code>.
* Creates a new {@code SQLPermission} object with the specified name.
* The name is the symbolic name of the {@code SQLPermission}.
*
* @param name the name of this <code>SQLPermission</code> object, which must
* @param name the name of this {@code SQLPermission} object, which must
* be either {@code setLog}, {@code callAbort}, {@code setSyncFactory},
* {@code deregisterDriver}, or {@code setNetworkTimeout}
* @throws NullPointerException if <code>name</code> is <code>null</code>.
* @throws IllegalArgumentException if <code>name</code> is empty.
* @throws NullPointerException if {@code name} is {@code null}.
* @throws IllegalArgumentException if {@code name} is empty.
*/
@ -138,17 +138,17 @@ public final class SQLPermission extends BasicPermission {
}
/**
* Creates a new <code>SQLPermission</code> object with the specified name.
* The name is the symbolic name of the <code>SQLPermission</code>; the
* actions <code>String</code> is currently unused and should be
* <code>null</code>.
* Creates a new {@code SQLPermission} object with the specified name.
* The name is the symbolic name of the {@code SQLPermission}; the
* actions {@code String} is currently unused and should be
* {@code null}.
*
* @param name the name of this <code>SQLPermission</code> object, which must
* @param name the name of this {@code SQLPermission} object, which must
* be either {@code setLog}, {@code callAbort}, {@code setSyncFactory},
* {@code deregisterDriver}, or {@code setNetworkTimeout}
* @param actions should be <code>null</code>
* @throws NullPointerException if <code>name</code> is <code>null</code>.
* @throws IllegalArgumentException if <code>name</code> is empty.
* @param actions should be {@code null}
* @throws NullPointerException if {@code name} is {@code null}.
* @throws IllegalArgumentException if {@code name} is empty.
*/

@ -1,5 +1,5 @@
/*
* Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2006, 2020, 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
@ -38,11 +38,11 @@ package java.sql;
public class SQLRecoverableException extends java.sql.SQLException {
/**
* Constructs a <code>SQLRecoverableException</code> object.
* The <code>reason</code>, <code>SQLState</code> are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLRecoverableException} object.
* The {@code reason}, {@code SQLState} are initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -53,12 +53,12 @@ public class SQLRecoverableException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLRecoverableException</code> object
* with a given <code>reason</code>. The <code>SQLState</code>
* is initialized to <code>null</code> and the vendor code is initialized
* Constructs a {@code SQLRecoverableException} object
* with a given {@code reason}. The {@code SQLState}
* is initialized to {@code null} and the vendor code is initialized
* to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -70,10 +70,10 @@ public class SQLRecoverableException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLRecoverableException</code> object
* with a given <code>reason</code> and <code>SQLState</code>.
* Constructs a {@code SQLRecoverableException} object
* with a given {@code reason} and {@code SQLState}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The vendor code
* is initialized to 0.
@ -87,11 +87,11 @@ public class SQLRecoverableException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLRecoverableException</code> object
* with a given <code>reason</code>, <code>SQLState</code> and
* <code>vendorCode</code>.
* Constructs a {@code SQLRecoverableException} object
* with a given {@code reason}, {@code SQLState} and
* {@code vendorCode}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -105,15 +105,15 @@ public class SQLRecoverableException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLRecoverableException</code> object
* with a given <code>cause</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* Constructs a {@code SQLRecoverableException} object
* with a given {@code cause}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
*
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -122,14 +122,14 @@ public class SQLRecoverableException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLRecoverableException</code> object
* Constructs a {@code SQLRecoverableException} object
* with a given
* <code>reason</code> and <code>cause</code>.
* The <code>SQLState</code> is initialized to <code>null</code>
* {@code reason} and {@code cause}.
* The {@code SQLState} is initialized to {@code null}
* and the vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -138,14 +138,14 @@ public class SQLRecoverableException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLRecoverableException</code> object
* Constructs a {@code SQLRecoverableException} object
* with a given
* <code>reason</code>, <code>SQLState</code> and <code>cause</code>.
* {@code reason}, {@code SQLState} and {@code cause}.
* The vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -154,15 +154,15 @@ public class SQLRecoverableException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLRecoverableException</code> object
* Constructs a {@code SQLRecoverableException} object
* with a given
* <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* and <code>cause</code>.
* {@code reason}, {@code SQLState}, {@code vendorCode}
* and {@code cause}.
*
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode a database vendor-specific exception code
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2020, 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
@ -31,17 +31,17 @@ package java.sql;
* in-progress query has violated SQL syntax rules.
* <p>
* Please consult your driver vendor documentation for the vendor-specified
* conditions for which this <code>Exception</code> may be thrown.
* conditions for which this {@code Exception} may be thrown.
* @since 1.6
*/
public class SQLSyntaxErrorException extends SQLNonTransientException {
/**
* Constructs a <code>SQLSyntaxErrorException</code> object.
* The <code>reason</code>, <code>SQLState</code> are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLSyntaxErrorException} object.
* The {@code reason}, {@code SQLState} are initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -52,12 +52,12 @@ public class SQLSyntaxErrorException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLSyntaxErrorException</code> object
* with a given <code>reason</code>. The <code>SQLState</code>
* is initialized to <code>null</code> and the vendor code is initialized
* Constructs a {@code SQLSyntaxErrorException} object
* with a given {@code reason}. The {@code SQLState}
* is initialized to {@code null} and the vendor code is initialized
* to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -69,10 +69,10 @@ public class SQLSyntaxErrorException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLSyntaxErrorException</code> object
* with a given <code>reason</code> and <code>SQLState</code>.
* Constructs a {@code SQLSyntaxErrorException} object
* with a given {@code reason} and {@code SQLState}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The vendor code
* is initialized to 0.
@ -86,11 +86,11 @@ public class SQLSyntaxErrorException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLSyntaxErrorException</code> object
* with a given <code>reason</code>, <code>SQLState</code> and
* <code>vendorCode</code>.
* Constructs a {@code SQLSyntaxErrorException} object
* with a given {@code reason}, {@code SQLState} and
* {@code vendorCode}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -104,15 +104,15 @@ public class SQLSyntaxErrorException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLSyntaxErrorException</code> object
* with a given <code>cause</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* Constructs a {@code SQLSyntaxErrorException} object
* with a given {@code cause}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
*
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -121,14 +121,14 @@ public class SQLSyntaxErrorException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLSyntaxErrorException</code> object
* Constructs a {@code SQLSyntaxErrorException} object
* with a given
* <code>reason</code> and <code>cause</code>.
* The <code>SQLState</code> is initialized to <code>null</code>
* {@code reason} and {@code cause}.
* The {@code SQLState} is initialized to {@code null}
* and the vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -137,14 +137,14 @@ public class SQLSyntaxErrorException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLSyntaxErrorException</code> object
* Constructs a {@code SQLSyntaxErrorException} object
* with a given
* <code>reason</code>, <code>SQLState</code> and <code>cause</code>.
* {@code reason}, {@code SQLState} and {@code cause}.
* The vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param cause the (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -153,15 +153,15 @@ public class SQLSyntaxErrorException extends SQLNonTransientException {
}
/**
* Constructs a <code>SQLSyntaxErrorException</code> object
* Constructs a {@code SQLSyntaxErrorException} object
* with a given
* <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* and <code>cause</code>.
* {@code reason}, {@code SQLState}, {@code vendorCode}
* and {@code cause}.
*
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode a database vendor-specific exception code
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/

@ -1,5 +1,5 @@
/*
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1996, 2020, 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
@ -37,11 +37,11 @@ package java.sql;
public class SQLTimeoutException extends SQLTransientException {
/**
* Constructs a <code>SQLTimeoutException</code> object.
* The <code>reason</code>, <code>SQLState</code> are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLTimeoutException} object.
* The {@code reason}, {@code SQLState} are initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -52,12 +52,12 @@ public class SQLTimeoutException extends SQLTransientException {
}
/**
* Constructs a <code>SQLTimeoutException</code> object
* with a given <code>reason</code>. The <code>SQLState</code>
* is initialized to <code>null</code> and the vendor code is initialized
* Constructs a {@code SQLTimeoutException} object
* with a given {@code reason}. The {@code SQLState}
* is initialized to {@code null} and the vendor code is initialized
* to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -69,10 +69,10 @@ public class SQLTimeoutException extends SQLTransientException {
}
/**
* Constructs a <code>SQLTimeoutException</code> object
* with a given <code>reason</code> and <code>SQLState</code>.
* Constructs a {@code SQLTimeoutException} object
* with a given {@code reason} and {@code SQLState}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The vendor code
* is initialized to 0.
@ -86,11 +86,11 @@ public class SQLTimeoutException extends SQLTransientException {
}
/**
* Constructs a <code>SQLTimeoutException</code> object
* with a given <code>reason</code>, <code>SQLState</code> and
* <code>vendorCode</code>.
* Constructs a {@code SQLTimeoutException} object
* with a given {@code reason}, {@code SQLState} and
* {@code vendorCode}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -104,15 +104,15 @@ public class SQLTimeoutException extends SQLTransientException {
}
/**
* Constructs a <code>SQLTimeoutException</code> object
* with a given <code>cause</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* Constructs a {@code SQLTimeoutException} object
* with a given {@code cause}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
*
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -121,14 +121,14 @@ public class SQLTimeoutException extends SQLTransientException {
}
/**
* Constructs a <code>SQLTimeoutException</code> object
* Constructs a {@code SQLTimeoutException} object
* with a given
* <code>reason</code> and <code>cause</code>.
* The <code>SQLState</code> is initialized to <code>null</code>
* {@code reason} and {@code cause}.
* The {@code SQLState} is initialized to {@code null}
* and the vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -137,14 +137,14 @@ public class SQLTimeoutException extends SQLTransientException {
}
/**
* Constructs a <code>SQLTimeoutException</code> object
* Constructs a {@code SQLTimeoutException} object
* with a given
* <code>reason</code>, <code>SQLState</code> and <code>cause</code>.
* {@code reason}, {@code SQLState} and {@code cause}.
* The vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -153,15 +153,15 @@ public class SQLTimeoutException extends SQLTransientException {
}
/**
* Constructs a <code>SQLTimeoutException</code> object
* Constructs a {@code SQLTimeoutException} object
* with a given
* <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* and <code>cause</code>.
* {@code reason}, {@code SQLState}, {@code vendorCode}
* and {@code cause}.
*
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode a database vendor-specific exception code
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2020, 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
@ -32,16 +32,16 @@ package java.sql;
* of deadlock or other transaction serialization failures.
* <p>
* Please consult your driver vendor documentation for the vendor-specified
* conditions for which this <code>Exception</code> may be thrown.
* conditions for which this {@code Exception} may be thrown.
* @since 1.6
*/
public class SQLTransactionRollbackException extends SQLTransientException {
/**
* Constructs a <code>SQLTransactionRollbackException</code> object.
* The <code>reason</code>, <code>SQLState</code> are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLTransactionRollbackException} object.
* The {@code reason}, {@code SQLState} are initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -52,12 +52,12 @@ public class SQLTransactionRollbackException extends SQLTransientException {
}
/**
* Constructs a <code>SQLTransactionRollbackException</code> object
* with a given <code>reason</code>. The <code>SQLState</code>
* is initialized to <code>null</code> and the vendor code is initialized
* Constructs a {@code SQLTransactionRollbackException} object
* with a given {@code reason}. The {@code SQLState}
* is initialized to {@code null} and the vendor code is initialized
* to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -69,10 +69,10 @@ public class SQLTransactionRollbackException extends SQLTransientException {
}
/**
* Constructs a <code>SQLTransactionRollbackException</code> object
* with a given <code>reason</code> and <code>SQLState</code>.
* Constructs a {@code SQLTransactionRollbackException} object
* with a given {@code reason} and {@code SQLState}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The vendor code
* is initialized to 0.
@ -86,11 +86,11 @@ public class SQLTransactionRollbackException extends SQLTransientException {
}
/**
* Constructs a <code>SQLTransactionRollbackException</code> object
* with a given <code>reason</code>, <code>SQLState</code> and
* <code>vendorCode</code>.
* Constructs a {@code SQLTransactionRollbackException} object
* with a given {@code reason}, {@code SQLState} and
* {@code vendorCode}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -104,15 +104,15 @@ public class SQLTransactionRollbackException extends SQLTransientException {
}
/**
* Constructs a <code>SQLTransactionRollbackException</code> object
* with a given <code>cause</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* Constructs a {@code SQLTransactionRollbackException} object
* with a given {@code cause}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
*
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -121,14 +121,14 @@ public class SQLTransactionRollbackException extends SQLTransientException {
}
/**
* Constructs a <code>SQLTransactionRollbackException</code> object
* Constructs a {@code SQLTransactionRollbackException} object
* with a given
* <code>reason</code> and <code>cause</code>.
* The <code>SQLState</code> is initialized to <code>null</code>
* {@code reason} and {@code cause}.
* The {@code SQLState} is initialized to {@code null}
* and the vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -137,14 +137,14 @@ public class SQLTransactionRollbackException extends SQLTransientException {
}
/**
* Constructs a <code>SQLTransactionRollbackException</code> object
* Constructs a {@code SQLTransactionRollbackException} object
* with a given
* <code>reason</code>, <code>SQLState</code> and <code>cause</code>.
* {@code reason}, {@code SQLState} and {@code cause}.
* The vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -153,15 +153,15 @@ public class SQLTransactionRollbackException extends SQLTransientException {
}
/**
* Constructs a <code>SQLTransactionRollbackException</code> object
* Constructs a {@code SQLTransactionRollbackException} object
* with a given
* <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* and <code>cause</code>.
* {@code reason}, {@code SQLState}, {@code vendorCode}
* and {@code cause}.
*
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode a database vendor-specific exception code
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2020, 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
@ -32,17 +32,17 @@ package java.sql;
* the operation is retried without any application-level changes.
* <p>
* Please consult your driver vendor documentation for the vendor-specified
* conditions for which this <code>Exception</code> may be thrown.
* conditions for which this {@code Exception} may be thrown.
* @since 1.6
*/
public class SQLTransientConnectionException extends java.sql.SQLTransientException {
/**
* Constructs a <code>SQLTransientConnectionException</code> object.
* The <code>reason</code>, <code>SQLState</code> are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLTransientConnectionException} object.
* The {@code reason}, {@code SQLState} are initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -53,12 +53,12 @@ public class SQLTransientConnectionException extends java.sql.SQLTransientExcept
}
/**
* Constructs a <code>SQLTransientConnectionException</code> object
* with a given <code>reason</code>. The <code>SQLState</code>
* is initialized to <code>null</code> and the vendor code is initialized
* Constructs a {@code SQLTransientConnectionException} object
* with a given {@code reason}. The {@code SQLState}
* is initialized to {@code null} and the vendor code is initialized
* to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -70,10 +70,10 @@ public class SQLTransientConnectionException extends java.sql.SQLTransientExcept
}
/**
* Constructs a <code>SQLTransientConnectionException</code> object
* with a given <code>reason</code> and <code>SQLState</code>.
* Constructs a {@code SQLTransientConnectionException} object
* with a given {@code reason} and {@code SQLState}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The vendor code
* is initialized to 0.
@ -87,11 +87,11 @@ public class SQLTransientConnectionException extends java.sql.SQLTransientExcept
}
/**
* Constructs a <code>SQLTransientConnectionException</code> object
* with a given <code>reason</code>, <code>SQLState</code> and
* <code>vendorCode</code>.
* Constructs a {@code SQLTransientConnectionException} object
* with a given {@code reason}, {@code SQLState} and
* {@code vendorCode}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -105,15 +105,15 @@ public class SQLTransientConnectionException extends java.sql.SQLTransientExcept
}
/**
* Constructs a <code>SQLTransientConnectionException</code> object
* with a given <code>cause</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* Constructs a {@code SQLTransientConnectionException} object
* with a given {@code cause}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
*
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -122,14 +122,14 @@ public class SQLTransientConnectionException extends java.sql.SQLTransientExcept
}
/**
* Constructs a <code>SQLTransientConnectionException</code> object
* Constructs a {@code SQLTransientConnectionException} object
* with a given
* <code>reason</code> and <code>cause</code>.
* The <code>SQLState</code> is initialized to <code>null</code>
* {@code reason} and {@code cause}.
* The {@code SQLState} is initialized to {@code null}
* and the vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param cause the underlying reason for this <code>SQLException</code>(which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException}(which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -138,14 +138,14 @@ public class SQLTransientConnectionException extends java.sql.SQLTransientExcept
}
/**
* Constructs a <code>SQLTransientConnectionException</code> object
* Constructs a {@code SQLTransientConnectionException} object
* with a given
* <code>reason</code>, <code>SQLState</code> and <code>cause</code>.
* {@code reason}, {@code SQLState} and {@code cause}.
* The vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -154,15 +154,15 @@ public class SQLTransientConnectionException extends java.sql.SQLTransientExcept
}
/**
* Constructs a <code>SQLTransientConnectionException</code> object
* Constructs a {@code SQLTransientConnectionException} object
* with a given
* <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* and <code>cause</code>.
* {@code reason}, {@code SQLState}, {@code vendorCode}
* and {@code cause}.
*
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode a database vendor-specific exception code
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2020, 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
@ -35,11 +35,11 @@ package java.sql;
public class SQLTransientException extends java.sql.SQLException {
/**
* Constructs a <code>SQLTransientException</code> object.
* The <code>reason</code>, <code>SQLState</code> are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLTransientException} object.
* The {@code reason}, {@code SQLState} are initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -50,12 +50,12 @@ public class SQLTransientException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLTransientException</code> object
* with a given <code>reason</code>. The <code>SQLState</code>
* is initialized to <code>null</code> and the vendor code is initialized
* Constructs a {@code SQLTransientException} object
* with a given {@code reason}. The {@code SQLState}
* is initialized to {@code null} and the vendor code is initialized
* to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -67,10 +67,10 @@ public class SQLTransientException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLTransientException</code> object
* with a given <code>reason</code> and <code>SQLState</code>.
* Constructs a {@code SQLTransientException} object
* with a given {@code reason} and {@code SQLState}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The vendor code
* is initialized to 0.
@ -84,11 +84,11 @@ public class SQLTransientException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLTransientException</code> object
* with a given <code>reason</code>, <code>SQLState</code> and
* <code>vendorCode</code>.
* Constructs a {@code SQLTransientException} object
* with a given {@code reason}, {@code SQLState} and
* {@code vendorCode}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -102,15 +102,15 @@ public class SQLTransientException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLTransientException</code> object
* with a given <code>cause</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* Constructs a {@code SQLTransientException} object
* with a given {@code cause}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
*
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -119,14 +119,14 @@ public class SQLTransientException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLTransientException</code> object
* Constructs a {@code SQLTransientException} object
* with a given
* <code>reason</code> and <code>cause</code>.
* The <code>SQLState</code> is initialized to <code>null</code>
* {@code reason} and {@code cause}.
* The {@code SQLState} is initialized to {@code null}
* and the vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -135,14 +135,14 @@ public class SQLTransientException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLTransientException</code> object
* Constructs a {@code SQLTransientException} object
* with a given
* <code>reason</code>, <code>SQLState</code> and <code>cause</code>.
* {@code reason}, {@code SQLState} and {@code cause}.
* The vendor code is initialized to 0.
*
* @param reason a description of the exception.
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/
@ -151,15 +151,15 @@ public class SQLTransientException extends java.sql.SQLException {
}
/**
* Constructs a <code>SQLTransientException</code> object
* Constructs a {@code SQLTransientException} object
* with a given
* <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* and <code>cause</code>.
* {@code reason}, {@code SQLState}, {@code vendorCode}
* and {@code cause}.
*
* @param reason a description of the exception
* @param SQLState an XOPEN or SQL:2003 code identifying the exception
* @param vendorCode a database vendor-specific exception code
* @param cause the underlying reason for this <code>SQLException</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLException} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
* @since 1.6
*/

@ -1,5 +1,5 @@
/*
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1996, 2020, 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
@ -30,8 +30,8 @@ package java.sql;
* warnings. Warnings are silently chained to the object whose method
* caused it to be reported.
* <P>
* Warnings may be retrieved from <code>Connection</code>, <code>Statement</code>,
* and <code>ResultSet</code> objects. Trying to retrieve a warning on a
* Warnings may be retrieved from {@code Connection}, {@code Statement},
* and {@code ResultSet} objects. Trying to retrieve a warning on a
* connection after it has been closed will cause an exception to be thrown.
* Similarly, trying to retrieve a warning on a statement after it has been
* closed or on a result set after it has been closed will cause
@ -46,11 +46,11 @@ package java.sql;
public class SQLWarning extends SQLException {
/**
* Constructs a <code>SQLWarning</code> object
* with a given <code>reason</code>, <code>SQLState</code> and
* <code>vendorCode</code>.
* Constructs a {@code SQLWarning} object
* with a given {@code reason}, {@code SQLState} and
* {@code vendorCode}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -67,10 +67,10 @@ public class SQLWarning extends SQLException {
/**
* Constructs a <code>SQLWarning</code> object
* with a given <code>reason</code> and <code>SQLState</code>.
* Constructs a {@code SQLWarning} object
* with a given {@code reason} and {@code SQLState}.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method. The vendor code
* is initialized to 0.
@ -85,12 +85,12 @@ public class SQLWarning extends SQLException {
}
/**
* Constructs a <code>SQLWarning</code> object
* with a given <code>reason</code>. The <code>SQLState</code>
* is initialized to <code>null</code> and the vendor code is initialized
* Constructs a {@code SQLWarning} object
* with a given {@code reason}. The {@code SQLState}
* is initialized to {@code null} and the vendor code is initialized
* to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -102,11 +102,11 @@ public class SQLWarning extends SQLException {
}
/**
* Constructs a <code>SQLWarning</code> object.
* The <code>reason</code>, <code>SQLState</code> are initialized
* to <code>null</code> and the vendor code is initialized to 0.
* Constructs a {@code SQLWarning} object.
* The {@code reason}, {@code SQLState} are initialized
* to {@code null} and the vendor code is initialized to 0.
*
* The <code>cause</code> is not initialized, and may subsequently be
* The {@code cause} is not initialized, and may subsequently be
* initialized by a call to the
* {@link Throwable#initCause(java.lang.Throwable)} method.
*
@ -117,15 +117,15 @@ public class SQLWarning extends SQLException {
}
/**
* Constructs a <code>SQLWarning</code> object
* with a given <code>cause</code>.
* The <code>SQLState</code> is initialized
* to <code>null</code> and the vendor code is initialized to 0.
* The <code>reason</code> is initialized to <code>null</code> if
* <code>cause==null</code> or to <code>cause.toString()</code> if
* <code>cause!=null</code>.
* Constructs a {@code SQLWarning} object
* with a given {@code cause}.
* The {@code SQLState} is initialized
* to {@code null} and the vendor code is initialized to 0.
* The {@code reason} is initialized to {@code null} if
* {@code cause==null} or to {@code cause.toString()} if
* {@code cause!=null}.
*
* @param cause the underlying reason for this <code>SQLWarning</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLWarning} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
*/
public SQLWarning(Throwable cause) {
@ -134,15 +134,15 @@ public class SQLWarning extends SQLException {
}
/**
* Constructs a <code>SQLWarning</code> object
* Constructs a {@code SQLWarning} object
* with a given
* <code>reason</code> and <code>cause</code>.
* The <code>SQLState</code> is initialized to <code>null</code>
* {@code reason} and {@code cause}.
* The {@code SQLState} is initialized to {@code null}
* and the vendor code is initialized to 0.
*
* @param reason a description of the warning
* @param cause the underlying reason for this <code>SQLWarning</code>
* (which is saved for later retrieval by the <code>getCause()</code> method);
* @param cause the underlying reason for this {@code SQLWarning}
* (which is saved for later retrieval by the {@code getCause()} method);
* may be null indicating the cause is non-existent or unknown.
*/
public SQLWarning(String reason, Throwable cause) {
@ -151,14 +151,14 @@ public class SQLWarning extends SQLException {
}
/**
* Constructs a <code>SQLWarning</code> object
* Constructs a {@code SQLWarning} object
* with a given
* <code>reason</code>, <code>SQLState</code> and <code>cause</code>.
* {@code reason}, {@code SQLState} and {@code cause}.
* The vendor code is initialized to 0.
*
* @param reason a description of the warning
* @param SQLState an XOPEN or SQL:2003 code identifying the warning
* @param cause the underlying reason for this <code>SQLWarning</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLWarning} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
*/
public SQLWarning(String reason, String SQLState, Throwable cause) {
@ -168,15 +168,15 @@ public class SQLWarning extends SQLException {
}
/**
* Constructs a<code>SQLWarning</code> object
* Constructs a{@code SQLWarning} object
* with a given
* <code>reason</code>, <code>SQLState</code>, <code>vendorCode</code>
* and <code>cause</code>.
* {@code reason}, {@code SQLState}, {@code vendorCode}
* and {@code cause}.
*
* @param reason a description of the warning
* @param SQLState an XOPEN or SQL:2003 code identifying the warning
* @param vendorCode a database vendor-specific warning code
* @param cause the underlying reason for this <code>SQLWarning</code> (which is saved for later retrieval by the <code>getCause()</code> method); may be null indicating
* @param cause the underlying reason for this {@code SQLWarning} (which is saved for later retrieval by the {@code getCause()} method); may be null indicating
* the cause is non-existent or unknown.
*/
public SQLWarning(String reason, String SQLState, int vendorCode, Throwable cause) {
@ -187,10 +187,10 @@ public class SQLWarning extends SQLException {
}
/**
* Retrieves the warning chained to this <code>SQLWarning</code> object by
* <code>setNextWarning</code>.
* Retrieves the warning chained to this {@code SQLWarning} object by
* {@code setNextWarning}.
*
* @return the next <code>SQLException</code> in the chain; <code>null</code> if none
* @return the next {@code SQLException} in the chain; {@code null} if none
* @see #setNextWarning
*/
public SQLWarning getNextWarning() {
@ -205,9 +205,9 @@ public class SQLWarning extends SQLException {
}
/**
* Adds a <code>SQLWarning</code> object to the end of the chain.
* Adds a {@code SQLWarning} object to the end of the chain.
*
* @param w the new end of the <code>SQLException</code> chain
* @param w the new end of the {@code SQLException} chain
* @see #getNextWarning
*/
public void setNextWarning(SQLWarning w) {

@ -179,7 +179,7 @@ import javax.xml.transform.Source;
* Implementations may also change the state to not readable when this occurs.
*
* <p>
* All methods on the <code>SQLXML</code> interface must be fully implemented if the
* All methods on the {@code SQLXML} interface must be fully implemented if the
* JDBC driver supports the data type.
*
* @see javax.xml.parsers
@ -195,10 +195,10 @@ public interface SQLXML
* The SQL XML object becomes invalid and neither readable or writable
* when this method is called.
*
* After <code>free</code> has been called, any attempt to invoke a
* method other than <code>free</code> will result in a <code>SQLException</code>
* being thrown. If <code>free</code> is called multiple times, the subsequent
* calls to <code>free</code> are treated as a no-op.
* After {@code free} has been called, any attempt to invoke a
* method other than {@code free} will result in a {@code SQLException}
* being thrown. If {@code free} is called multiple times, the subsequent
* calls to {@code free} are treated as a no-op.
* @throws SQLException if there is an error freeing the XML value.
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
* this method

@ -28,7 +28,7 @@ package java.sql;
/**
* The representation of a savepoint, which is a point within
* the current transaction that can be referenced from the
* <code>Connection.rollback</code> method. When a transaction
* {@code Connection.rollback} method. When a transaction
* is rolled back to a savepoint all changes made after that
* savepoint are undone.
* <p>
@ -42,7 +42,7 @@ public interface Savepoint {
/**
* Retrieves the generated ID for the savepoint that this
* <code>Savepoint</code> object represents.
* {@code Savepoint} object represents.
* @return the numeric ID of this savepoint
* @throws SQLException if this is a named savepoint
* @since 1.4
@ -50,7 +50,7 @@ public interface Savepoint {
int getSavepointId() throws SQLException;
/**
* Retrieves the name of the savepoint that this <code>Savepoint</code>
* Retrieves the name of the savepoint that this {@code Savepoint}
* object represents.
* @return the name of this savepoint
* @throws SQLException if this is an un-named savepoint

File diff suppressed because it is too large Load Diff

@ -27,13 +27,13 @@ package java.sql;
/**
* <p>The standard mapping in the Java programming language for an SQL
* structured type. A <code>Struct</code> object contains a
* structured type. A {@code Struct} object contains a
* value for each attribute of the SQL structured type that
* it represents.
* By default, an instance of<code>Struct</code> is valid as long as the
* By default, an instance of{@code Struct} is valid as long as the
* application has a reference to it.
* <p>
* All methods on the <code>Struct</code> interface must be fully implemented if the
* All methods on the {@code Struct} interface must be fully implemented if the
* JDBC driver supports the data type.
* @since 1.2
*/
@ -42,10 +42,10 @@ public interface Struct {
/**
* Retrieves the SQL type name of the SQL structured type
* that this <code>Struct</code> object represents.
* that this {@code Struct} object represents.
*
* @return the fully-qualified type name of the SQL structured
* type for which this <code>Struct</code> object
* type for which this {@code Struct} object
* is the generic representation
* @throws SQLException if a database access error occurs
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support
@ -56,7 +56,7 @@ public interface Struct {
/**
* Produces the ordered values of the attributes of the SQL
* structured type that this <code>Struct</code> object represents.
* structured type that this {@code Struct} object represents.
* As individual attributes are processed, this method uses the type map
* associated with the
* connection for customizations of the type mappings.
@ -66,7 +66,7 @@ public interface Struct {
* the driver uses the standard mapping.
* <p>
* Conceptually, this method calls the method
* <code>getObject</code> on each attribute
* {@code getObject} on each attribute
* of the structured type and returns a Java array containing
* the result.
*
@ -80,7 +80,7 @@ public interface Struct {
/**
* Produces the ordered values of the attributes of the SQL
* structured type that this <code>Struct</code> object represents.
* structured type that this {@code Struct} object represents.
* As individual attributes are processed, this method uses the given type map
* for customizations of the type mappings.
* If there is no
@ -90,7 +90,7 @@ public interface Struct {
* uses the type map associated with the connection.
* <p>
* Conceptually, this method calls the method
* <code>getObject</code> on each attribute
* {@code getObject} on each attribute
* of the structured type and returns a Java array containing
* the result.
*

@ -29,8 +29,8 @@ import java.time.Instant;
import java.time.LocalTime;
/**
* <P>A thin wrapper around the <code>java.util.Date</code> class that allows the JDBC
* API to identify this as an SQL <code>TIME</code> value. The <code>Time</code>
* <P>A thin wrapper around the {@code java.util.Date} class that allows the JDBC
* API to identify this as an SQL {@code TIME} value. The {@code Time}
* class adds formatting and
* parsing operations to support the JDBC escape syntax for time
* values.
@ -42,12 +42,12 @@ import java.time.LocalTime;
public class Time extends java.util.Date {
/**
* Constructs a <code>Time</code> object initialized with the
* Constructs a {@code Time} object initialized with the
* given values for the hour, minute, and second.
* The driver sets the date components to January 1, 1970.
* Any method that attempts to access the date components of a
* <code>Time</code> object will throw a
* <code>java.lang.IllegalArgumentException</code>.
* {@code Time} object will throw a
* {@code java.lang.IllegalArgumentException}.
* <P>
* The result is undefined if a given argument is out of bounds.
*
@ -64,7 +64,7 @@ public class Time extends java.util.Date {
}
/**
* Constructs a <code>Time</code> object using a milliseconds time value.
* Constructs a {@code Time} object using a milliseconds time value.
*
* @param time milliseconds since January 1, 1970, 00:00:00 GMT;
* a negative number is milliseconds before
@ -75,7 +75,7 @@ public class Time extends java.util.Date {
}
/**
* Sets a <code>Time</code> object using a milliseconds time value.
* Sets a {@code Time} object using a milliseconds time value.
*
* @param time milliseconds since January 1, 1970, 00:00:00 GMT;
* a negative number is milliseconds before
@ -86,10 +86,10 @@ public class Time extends java.util.Date {
}
/**
* Converts a string in JDBC time escape format to a <code>Time</code> value.
* Converts a string in JDBC time escape format to a {@code Time} value.
*
* @param s time in format "hh:mm:ss"
* @return a corresponding <code>Time</code> object
* @return a corresponding {@code Time} object
*/
public static Time valueOf(String s) {
if (s == null) throw new java.lang.IllegalArgumentException();
@ -115,7 +115,7 @@ public class Time extends java.util.Date {
/**
* Formats a time in JDBC time escape format.
*
* @return a <code>String</code> in hh:mm:ss format
* @return a {@code String} in hh:mm:ss format
*/
@SuppressWarnings("deprecation")
public String toString () {
@ -136,7 +136,7 @@ public class Time extends java.util.Date {
// Override all the date operations inherited from java.util.Date;
/**
* This method is deprecated and should not be used because SQL <code>TIME</code>
* This method is deprecated and should not be used because SQL {@code TIME}
* values do not have a year component.
*
* @deprecated
@ -150,7 +150,7 @@ public class Time extends java.util.Date {
}
/**
* This method is deprecated and should not be used because SQL <code>TIME</code>
* This method is deprecated and should not be used because SQL {@code TIME}
* values do not have a month component.
*
* @deprecated
@ -164,7 +164,7 @@ public class Time extends java.util.Date {
}
/**
* This method is deprecated and should not be used because SQL <code>TIME</code>
* This method is deprecated and should not be used because SQL {@code TIME}
* values do not have a day component.
*
* @deprecated
@ -177,7 +177,7 @@ public class Time extends java.util.Date {
}
/**
* This method is deprecated and should not be used because SQL <code>TIME</code>
* This method is deprecated and should not be used because SQL {@code TIME}
* values do not have a date component.
*
* @deprecated
@ -191,7 +191,7 @@ public class Time extends java.util.Date {
}
/**
* This method is deprecated and should not be used because SQL <code>TIME</code>
* This method is deprecated and should not be used because SQL {@code TIME}
* values do not have a year component.
*
* @deprecated
@ -205,7 +205,7 @@ public class Time extends java.util.Date {
}
/**
* This method is deprecated and should not be used because SQL <code>TIME</code>
* This method is deprecated and should not be used because SQL {@code TIME}
* values do not have a month component.
*
* @deprecated
@ -219,7 +219,7 @@ public class Time extends java.util.Date {
}
/**
* This method is deprecated and should not be used because SQL <code>TIME</code>
* This method is deprecated and should not be used because SQL {@code TIME}
* values do not have a date component.
*
* @deprecated

@ -1,5 +1,5 @@
/*
* Copyright (c) 1996, 2014, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1996, 2020, 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
@ -38,49 +38,49 @@ public class Types {
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>BIT</code>.
* {@code BIT}.
*/
public final static int BIT = -7;
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>TINYINT</code>.
* {@code TINYINT}.
*/
public final static int TINYINT = -6;
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>SMALLINT</code>.
* {@code SMALLINT}.
*/
public final static int SMALLINT = 5;
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>INTEGER</code>.
* {@code INTEGER}.
*/
public final static int INTEGER = 4;
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>BIGINT</code>.
* {@code BIGINT}.
*/
public final static int BIGINT = -5;
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>FLOAT</code>.
* {@code FLOAT}.
*/
public final static int FLOAT = 6;
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>REAL</code>.
* {@code REAL}.
*/
public final static int REAL = 7;
@ -88,42 +88,42 @@ public class Types {
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>DOUBLE</code>.
* {@code DOUBLE}.
*/
public final static int DOUBLE = 8;
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>NUMERIC</code>.
* {@code NUMERIC}.
*/
public final static int NUMERIC = 2;
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>DECIMAL</code>.
* {@code DECIMAL}.
*/
public final static int DECIMAL = 3;
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>CHAR</code>.
* {@code CHAR}.
*/
public final static int CHAR = 1;
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>VARCHAR</code>.
* {@code VARCHAR}.
*/
public final static int VARCHAR = 12;
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>LONGVARCHAR</code>.
* {@code LONGVARCHAR}.
*/
public final static int LONGVARCHAR = -1;
@ -131,21 +131,21 @@ public class Types {
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>DATE</code>.
* {@code DATE}.
*/
public final static int DATE = 91;
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>TIME</code>.
* {@code TIME}.
*/
public final static int TIME = 92;
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>TIMESTAMP</code>.
* {@code TIMESTAMP}.
*/
public final static int TIMESTAMP = 93;
@ -153,28 +153,28 @@ public class Types {
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>BINARY</code>.
* {@code BINARY}.
*/
public final static int BINARY = -2;
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>VARBINARY</code>.
* {@code VARBINARY}.
*/
public final static int VARBINARY = -3;
/**
* <P>The constant in the Java programming language, sometimes referred
* to as a type code, that identifies the generic SQL type
* <code>LONGVARBINARY</code>.
* {@code LONGVARBINARY}.
*/
public final static int LONGVARBINARY = -4;
/**
* <P>The constant in the Java programming language
* that identifies the generic SQL value
* <code>NULL</code>.
* {@code NULL}.
*/
public final static int NULL = 0;
@ -182,7 +182,7 @@ public class Types {
* The constant in the Java programming language that indicates
* that the SQL type is database-specific and
* gets mapped to a Java object that can be accessed via
* the methods <code>getObject</code> and <code>setObject</code>.
* the methods {@code getObject} and {@code setObject}.
*/
public final static int OTHER = 1111;
@ -191,7 +191,7 @@ public class Types {
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type
* <code>JAVA_OBJECT</code>.
* {@code JAVA_OBJECT}.
* @since 1.2
*/
public final static int JAVA_OBJECT = 2000;
@ -199,7 +199,7 @@ public class Types {
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type
* <code>DISTINCT</code>.
* {@code DISTINCT}.
* @since 1.2
*/
public final static int DISTINCT = 2001;
@ -207,7 +207,7 @@ public class Types {
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type
* <code>STRUCT</code>.
* {@code STRUCT}.
* @since 1.2
*/
public final static int STRUCT = 2002;
@ -215,7 +215,7 @@ public class Types {
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type
* <code>ARRAY</code>.
* {@code ARRAY}.
* @since 1.2
*/
public final static int ARRAY = 2003;
@ -223,7 +223,7 @@ public class Types {
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type
* <code>BLOB</code>.
* {@code BLOB}.
* @since 1.2
*/
public final static int BLOB = 2004;
@ -231,7 +231,7 @@ public class Types {
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type
* <code>CLOB</code>.
* {@code CLOB}.
* @since 1.2
*/
public final static int CLOB = 2005;
@ -239,14 +239,14 @@ public class Types {
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type
* <code>REF</code>.
* {@code REF}.
* @since 1.2
*/
public final static int REF = 2006;
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type <code>DATALINK</code>.
* as a type code, that identifies the generic SQL type {@code DATALINK}.
*
* @since 1.4
*/
@ -254,7 +254,7 @@ public class Types {
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type <code>BOOLEAN</code>.
* as a type code, that identifies the generic SQL type {@code BOOLEAN}.
*
* @since 1.4
*/
@ -264,7 +264,7 @@ public class Types {
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type <code>ROWID</code>
* as a type code, that identifies the generic SQL type {@code ROWID}
*
* @since 1.6
*
@ -273,7 +273,7 @@ public class Types {
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type <code>NCHAR</code>
* as a type code, that identifies the generic SQL type {@code NCHAR}
*
* @since 1.6
*/
@ -281,7 +281,7 @@ public class Types {
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type <code>NVARCHAR</code>.
* as a type code, that identifies the generic SQL type {@code NVARCHAR}.
*
* @since 1.6
*/
@ -289,7 +289,7 @@ public class Types {
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type <code>LONGNVARCHAR</code>.
* as a type code, that identifies the generic SQL type {@code LONGNVARCHAR}.
*
* @since 1.6
*/
@ -297,7 +297,7 @@ public class Types {
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type <code>NCLOB</code>.
* as a type code, that identifies the generic SQL type {@code NCLOB}.
*
* @since 1.6
*/
@ -305,7 +305,7 @@ public class Types {
/**
* The constant in the Java programming language, sometimes referred to
* as a type code, that identifies the generic SQL type <code>XML</code>.
* as a type code, that identifies the generic SQL type {@code XML}.
*
* @since 1.6
*/

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2020, 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
@ -49,9 +49,9 @@ public interface Wrapper {
* or a proxy for the receiver. If the receiver is a wrapper
* and the wrapped object implements the interface then the result is the
* wrapped object or a proxy for the wrapped object. Otherwise return the
* the result of calling <code>unwrap</code> recursively on the wrapped object
* the result of calling {@code unwrap} recursively on the wrapped object
* or a proxy for that result. If the receiver is not a
* wrapper and does not implement the interface, then an <code>SQLException</code> is thrown.
* wrapper and does not implement the interface, then an {@code SQLException} is thrown.
*
* @param <T> the type of the class modeled by this Class object
* @param iface A Class defining an interface that the result must implement.
@ -64,11 +64,11 @@ public interface Wrapper {
/**
* Returns true if this either implements the interface argument or is directly or indirectly a wrapper
* for an object that does. Returns false otherwise. If this implements the interface then return true,
* else if this is a wrapper then return the result of recursively calling <code>isWrapperFor</code> on the wrapped
* else if this is a wrapper then return the result of recursively calling {@code isWrapperFor} on the wrapped
* object. If this does not implement the interface and is not a wrapper, return false.
* This method should be implemented as a low-cost operation compared to <code>unwrap</code> so that
* callers can use this method to avoid expensive <code>unwrap</code> calls that may fail. If this method
* returns true then calling <code>unwrap</code> with the same argument should succeed.
* This method should be implemented as a low-cost operation compared to {@code unwrap} so that
* callers can use this method to avoid expensive {@code unwrap} calls that may fail. If this method
* returns true then calling {@code unwrap} with the same argument should succeed.
*
* @param iface a Class defining an interface.
* @return true if this implements the interface or directly or indirectly wraps an object that does.

@ -31,15 +31,15 @@ import java.sql.ShardingKeyBuilder;
import java.util.logging.Logger;
/**
* Interface that defines the methods which are common between <code>DataSource</code>,
* <code>XADataSource</code> and <code>ConnectionPoolDataSource</code>.
* Interface that defines the methods which are common between {@code DataSource},
* {@code XADataSource} and {@code ConnectionPoolDataSource}.
*
* @since 1.6
*/
public interface CommonDataSource {
/**
* <p>Retrieves the log writer for this <code>DataSource</code>
* <p>Retrieves the log writer for this {@code DataSource}
* object.
*
* <p>The log writer is a character output stream to which all logging
@ -48,8 +48,8 @@ public interface CommonDataSource {
* object, messages printed by methods of other objects manufactured
* by this object, and so on. Messages printed to a data source
* specific log writer are not printed to the log writer associated
* with the <code>java.sql.DriverManager</code> class. When a
* <code>DataSource</code> object is
* with the {@code java.sql.DriverManager} class. When a
* {@code DataSource} object is
* created, the log writer is initially null; in other words, the
* default is for logging to be disabled.
*
@ -61,8 +61,8 @@ public interface CommonDataSource {
java.io.PrintWriter getLogWriter() throws SQLException;
/**
* <p>Sets the log writer for this <code>DataSource</code>
* object to the given <code>java.io.PrintWriter</code> object.
* <p>Sets the log writer for this {@code DataSource}
* object to the given {@code java.io.PrintWriter} object.
*
* <p>The log writer is a character output stream to which all logging
* and tracing messages for this data source will be
@ -70,8 +70,8 @@ public interface CommonDataSource {
* object, messages printed by methods of other objects manufactured
* by this object, and so on. Messages printed to a data source-
* specific log writer are not printed to the log writer associated
* with the <code>java.sql.DriverManager</code> class. When a
* <code>DataSource</code> object is created the log writer is
* with the {@code java.sql.DriverManager} class. When a
* {@code DataSource} object is created the log writer is
* initially null; in other words, the default is for logging to be
* disabled.
*
@ -86,7 +86,7 @@ public interface CommonDataSource {
* while attempting to connect to a database. A value of zero
* specifies that the timeout is the default system timeout
* if there is one; otherwise, it specifies that there is no timeout.
* When a <code>DataSource</code> object is created, the login timeout is
* When a {@code DataSource} object is created, the login timeout is
* initially zero.
*
* @param seconds the data source login time limit
@ -100,7 +100,7 @@ public interface CommonDataSource {
* while attempting to connect to a database. A value of zero
* means that the timeout is the default system timeout
* if there is one; otherwise, it means that there is no timeout.
* When a <code>DataSource</code> object is created, the login timeout is
* When a {@code DataSource} object is created, the login timeout is
* initially zero.
*
* @return the data source login time limit

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2006, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2020, 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
@ -28,14 +28,14 @@ package javax.sql;
import java.sql.SQLException;
/**
* <P>An <code>Event</code> object that provides information about the
* source of a connection-related event. <code>ConnectionEvent</code>
* <P>An {@code Event} object that provides information about the
* source of a connection-related event. {@code ConnectionEvent}
* objects are generated when an application closes a pooled connection
* and when an error occurs. The <code>ConnectionEvent</code> object
* and when an error occurs. The {@code ConnectionEvent} object
* contains two kinds of information:
* <UL>
* <LI>The pooled connection closed by the application
* <LI>In the case of an error event, the <code>SQLException</code>
* <LI>In the case of an error event, the {@code SQLException}
* about to be thrown to the application
* </UL>
*
@ -45,25 +45,25 @@ import java.sql.SQLException;
public class ConnectionEvent extends java.util.EventObject {
/**
* <P>Constructs a <code>ConnectionEvent</code> object initialized with
* the given <code>PooledConnection</code> object. <code>SQLException</code>
* defaults to <code>null</code>.
* <P>Constructs a {@code ConnectionEvent} object initialized with
* the given {@code PooledConnection} object. {@code SQLException}
* defaults to {@code null}.
*
* @param con the pooled connection that is the source of the event
* @throws IllegalArgumentException if <code>con</code> is null.
* @throws IllegalArgumentException if {@code con} is null.
*/
public ConnectionEvent(PooledConnection con) {
super(con);
}
/**
* <P>Constructs a <code>ConnectionEvent</code> object initialized with
* the given <code>PooledConnection</code> object and
* <code>SQLException</code> object.
* <P>Constructs a {@code ConnectionEvent} object initialized with
* the given {@code PooledConnection} object and
* {@code SQLException} object.
*
* @param con the pooled connection that is the source of the event
* @param ex the SQLException about to be thrown to the application
* @throws IllegalArgumentException if <code>con</code> is null.
* @throws IllegalArgumentException if {@code con} is null.
*/
public ConnectionEvent(PooledConnection con, SQLException ex) {
super(con);
@ -71,15 +71,15 @@ public class ConnectionEvent extends java.util.EventObject {
}
/**
* <P>Retrieves the <code>SQLException</code> for this
* <code>ConnectionEvent</code> object. May be <code>null</code>.
* <P>Retrieves the {@code SQLException} for this
* {@code ConnectionEvent} object. May be {@code null}.
*
* @return the SQLException about to be thrown or <code>null</code>
* @return the SQLException about to be thrown or {@code null}
*/
public SQLException getSQLException() { return ex; }
/**
* The <code>SQLException</code> that the driver will throw to the
* The {@code SQLException} that the driver will throw to the
* application when an error occurs and the pooled connection is no
* longer usable.
* @serial

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2001, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2020, 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
@ -28,22 +28,22 @@ package javax.sql;
/**
* <P>
* An object that registers to be notified of events generated by a
* <code>PooledConnection</code> object.
* {@code PooledConnection} object.
* <P>
* The <code>ConnectionEventListener</code> interface is implemented by a
* The {@code ConnectionEventListener} interface is implemented by a
* connection pooling component. A connection pooling component will
* usually be provided by a JDBC driver vendor or another system software
* vendor. A JDBC driver notifies a <code>ConnectionEventListener</code>
* vendor. A JDBC driver notifies a {@code ConnectionEventListener}
* object when an application is finished using a pooled connection with
* which the listener has registered. The notification
* occurs after the application calls the method <code>close</code> on
* its representation of a <code>PooledConnection</code> object. A
* <code>ConnectionEventListener</code> is also notified when a
* connection error occurs due to the fact that the <code>PooledConnection</code>
* occurs after the application calls the method {@code close} on
* its representation of a {@code PooledConnection} object. A
* {@code ConnectionEventListener} is also notified when a
* connection error occurs due to the fact that the {@code PooledConnection}
* is unfit for future use---the server has crashed, for example.
* The listener is notified by the JDBC driver just before the driver throws an
* <code>SQLException</code> to the application using the
* <code>PooledConnection</code> object.
* {@code SQLException} to the application using the
* {@code PooledConnection} object.
*
* @since 1.4
*/
@ -51,8 +51,8 @@ package javax.sql;
public interface ConnectionEventListener extends java.util.EventListener {
/**
* Notifies this <code>ConnectionEventListener</code> that
* the application has called the method <code>close</code> on its
* Notifies this {@code ConnectionEventListener} that
* the application has called the method {@code close} on its
* representation of a pooled connection.
*
* @param event an event object describing the source of
@ -61,14 +61,14 @@ public interface ConnectionEventListener extends java.util.EventListener {
void connectionClosed(ConnectionEvent event);
/**
* Notifies this <code>ConnectionEventListener</code> that
* Notifies this {@code ConnectionEventListener} that
* a fatal error has occurred and the pooled connection can
* no longer be used. The driver makes this notification just
* before it throws the application the <code>SQLException</code>
* contained in the given <code>ConnectionEvent</code> object.
* before it throws the application the {@code SQLException}
* contained in the given {@code ConnectionEvent} object.
*
* @param event an event object describing the source of
* the event and containing the <code>SQLException</code> that the
* the event and containing the {@code SQLException} that the
* driver is about to throw
*/
void connectionErrorOccurred(ConnectionEvent event);

@ -30,7 +30,7 @@ import java.sql.SQLFeatureNotSupportedException;
/**
* A factory for <code>PooledConnection</code>
* A factory for {@code PooledConnection}
* objects. An object that implements this interface will typically be
* registered with a naming service that is based on the
* Java Naming and Directory Interface
@ -45,9 +45,9 @@ public interface ConnectionPoolDataSource extends CommonDataSource {
* Attempts to establish a physical database connection that can
* be used as a pooled connection.
*
* @return a <code>PooledConnection</code> object that is a physical
* @return a {@code PooledConnection} object that is a physical
* connection to the database that this
* <code>ConnectionPoolDataSource</code> object represents
* {@code ConnectionPoolDataSource} object represents
* @throws SQLException if a database access error occurs
* @throws java.sql.SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -61,9 +61,9 @@ public interface ConnectionPoolDataSource extends CommonDataSource {
*
* @param user the database user on whose behalf the connection is being made
* @param password the user's password
* @return a <code>PooledConnection</code> object that is a physical
* @return a {@code PooledConnection} object that is a physical
* connection to the database that this
* <code>ConnectionPoolDataSource</code> object represents
* {@code ConnectionPoolDataSource} object represents
* @throws SQLException if a database access error occurs
* @throws java.sql.SQLFeatureNotSupportedException if the JDBC driver does not support
* this method

@ -30,40 +30,40 @@ import java.sql.SQLException;
/**
* An object that provides hooks for connection pool management.
* A <code>PooledConnection</code> object
* A {@code PooledConnection} object
* represents a physical connection to a data source. The connection
* can be recycled rather than being closed when an application is
* finished with it, thus reducing the number of connections that
* need to be made.
* <P>
* An application programmer does not use the <code>PooledConnection</code>
* An application programmer does not use the {@code PooledConnection}
* interface directly; rather, it is used by a middle tier infrastructure
* that manages the pooling of connections.
* <P>
* When an application calls the method <code>DataSource.getConnection</code>,
* it gets back a <code>Connection</code> object. If connection pooling is
* being done, that <code>Connection</code> object is actually a handle to
* a <code>PooledConnection</code> object, which is a physical connection.
* When an application calls the method {@code DataSource.getConnection},
* it gets back a {@code Connection} object. If connection pooling is
* being done, that {@code Connection} object is actually a handle to
* a {@code PooledConnection} object, which is a physical connection.
* <P>
* The connection pool manager, typically the application server, maintains
* a pool of <code>PooledConnection</code> objects. If there is a
* <code>PooledConnection</code> object available in the pool, the
* connection pool manager returns a <code>Connection</code> object that
* a pool of {@code PooledConnection} objects. If there is a
* {@code PooledConnection} object available in the pool, the
* connection pool manager returns a {@code Connection} object that
* is a handle to that physical connection.
* If no <code>PooledConnection</code> object is available, the
* connection pool manager calls the <code>ConnectionPoolDataSource</code>
* method <code>getPoolConnection</code> to create a new physical connection. The
* JDBC driver implementing <code>ConnectionPoolDataSource</code> creates a
* new <code>PooledConnection</code> object and returns a handle to it.
* If no {@code PooledConnection} object is available, the
* connection pool manager calls the {@code ConnectionPoolDataSource}
* method {@code getPoolConnection} to create a new physical connection. The
* JDBC driver implementing {@code ConnectionPoolDataSource} creates a
* new {@code PooledConnection} object and returns a handle to it.
* <P>
* When an application closes a connection, it calls the <code>Connection</code>
* method <code>close</code>. When connection pooling is being done,
* When an application closes a connection, it calls the {@code Connection}
* method {@code close}. When connection pooling is being done,
* the connection pool manager is notified because it has registered itself as
* a <code>ConnectionEventListener</code> object using the
* <code>ConnectionPool</code> method <code>addConnectionEventListener</code>.
* a {@code ConnectionEventListener} object using the
* {@code ConnectionPool} method {@code addConnectionEventListener}.
* The connection pool manager deactivates the handle to
* the <code>PooledConnection</code> object and returns the
* <code>PooledConnection</code> object to the pool of connections so that
* the {@code PooledConnection} object and returns the
* {@code PooledConnection} object to the pool of connections so that
* it can be used again. Thus, when an application closes its connection,
* the underlying physical connection is recycled rather than being closed.
* <p>
@ -78,20 +78,20 @@ import java.sql.SQLException;
* </ul>
* <p>
* The physical connection is not closed until the connection pool manager
* calls the <code>PooledConnection</code> method <code>close</code>.
* calls the {@code PooledConnection} method {@code close}.
* This method is generally called to have an orderly shutdown of the server or
* if a fatal error has made the connection unusable.
*
* <p>
* A connection pool manager is often also a statement pool manager, maintaining
* a pool of <code>PreparedStatement</code> objects.
* a pool of {@code PreparedStatement} objects.
* When an application closes a prepared statement, it calls the
* <code>PreparedStatement</code>
* method <code>close</code>. When <code>Statement</code> pooling is being done,
* {@code PreparedStatement}
* method {@code close}. When {@code Statement} pooling is being done,
* the pool manager is notified because it has registered itself as
* a <code>StatementEventListener</code> object using the
* <code>ConnectionPool</code> method <code>addStatementEventListener</code>.
* Thus, when an application closes its <code>PreparedStatement</code>,
* a {@code StatementEventListener} object using the
* {@code ConnectionPool} method {@code addStatementEventListener}.
* Thus, when an application closes its {@code PreparedStatement},
* the underlying prepared statement is recycled rather than being closed.
*
* @since 1.4
@ -100,16 +100,16 @@ import java.sql.SQLException;
public interface PooledConnection {
/**
* Creates and returns a <code>Connection</code> object that is a handle
* Creates and returns a {@code Connection} object that is a handle
* for the physical connection that
* this <code>PooledConnection</code> object represents.
* this {@code PooledConnection} object represents.
* The connection pool manager calls this method when an application has
* called the method <code>DataSource.getConnection</code> and there are
* no <code>PooledConnection</code> objects available. See the
* called the method {@code DataSource.getConnection} and there are
* no {@code PooledConnection} objects available. See the
* {@link PooledConnection interface description} for more information.
*
* @return a <code>Connection</code> object that is a handle to
* this <code>PooledConnection</code> object
* @return a {@code Connection} object that is a handle to
* this {@code PooledConnection} object
* @throws SQLException if a database access error occurs
* @throws java.sql.SQLFeatureNotSupportedException if the JDBC driver does not support
* this method
@ -118,7 +118,7 @@ public interface PooledConnection {
Connection getConnection() throws SQLException;
/**
* Closes the physical connection that this <code>PooledConnection</code>
* Closes the physical connection that this {@code PooledConnection}
* object represents. An application never calls this method directly;
* it is called by the connection pool module, or manager.
* <P>
@ -134,11 +134,11 @@ public interface PooledConnection {
/**
* Registers the given event listener so that it will be notified
* when an event occurs on this <code>PooledConnection</code> object.
* when an event occurs on this {@code PooledConnection} object.
*
* @param listener a component, usually the connection pool manager,
* that has implemented the
* <code>ConnectionEventListener</code> interface and wants to be
* {@code ConnectionEventListener} interface and wants to be
* notified when the connection is closed or has an error
* @see #removeConnectionEventListener
*/
@ -147,38 +147,38 @@ public interface PooledConnection {
/**
* Removes the given event listener from the list of components that
* will be notified when an event occurs on this
* <code>PooledConnection</code> object.
* {@code PooledConnection} object.
*
* @param listener a component, usually the connection pool manager,
* that has implemented the
* <code>ConnectionEventListener</code> interface and
* been registered with this <code>PooledConnection</code> object as
* {@code ConnectionEventListener} interface and
* been registered with this {@code PooledConnection} object as
* a listener
* @see #addConnectionEventListener
*/
void removeConnectionEventListener(ConnectionEventListener listener);
/**
* Registers a <code>StatementEventListener</code> with this <code>PooledConnection</code> object. Components that
* wish to be notified when <code>PreparedStatement</code>s created by the
* Registers a {@code StatementEventListener} with this {@code PooledConnection} object. Components that
* wish to be notified when {@code PreparedStatement}s created by the
* connection are closed or are detected to be invalid may use this method
* to register a <code>StatementEventListener</code> with this <code>PooledConnection</code> object.
* to register a {@code StatementEventListener} with this {@code PooledConnection} object.
*
* @param listener an component which implements the <code>StatementEventListener</code>
* interface that is to be registered with this <code>PooledConnection</code> object
* @param listener an component which implements the {@code StatementEventListener}
* interface that is to be registered with this {@code PooledConnection} object
*
* @since 1.6
*/
public void addStatementEventListener(StatementEventListener listener);
/**
* Removes the specified <code>StatementEventListener</code> from the list of
* Removes the specified {@code StatementEventListener} from the list of
* components that will be notified when the driver detects that a
* <code>PreparedStatement</code> has been closed or is invalid.
* {@code PreparedStatement} has been closed or is invalid.
*
* @param listener the component which implements the
* <code>StatementEventListener</code> interface that was previously
* registered with this <code>PooledConnection</code> object
* {@code StatementEventListener} interface that was previously
* registered with this {@code PooledConnection} object
*
* @since 1.6
*/

File diff suppressed because it is too large Load Diff

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2006, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2020, 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
@ -26,16 +26,16 @@
package javax.sql;
/**
* An <code>Event</code> object generated when an event occurs to a
* <code>RowSet</code> object. A <code>RowSetEvent</code> object is
* An {@code Event} object generated when an event occurs to a
* {@code RowSet} object. A {@code RowSetEvent} object is
* generated when a single row in a rowset is changed, the whole rowset
* is changed, or the rowset cursor moves.
* <P>
* When an event occurs on a <code>RowSet</code> object, one of the
* <code>RowSetListener</code> methods will be sent to all registered
* listeners to notify them of the event. An <code>Event</code> object
* is supplied to the <code>RowSetListener</code> method so that the
* listener can use it to find out which <code>RowSet</code> object is
* When an event occurs on a {@code RowSet} object, one of the
* {@code RowSetListener} methods will be sent to all registered
* listeners to notify them of the event. An {@code Event} object
* is supplied to the {@code RowSetListener} method so that the
* listener can use it to find out which {@code RowSet} object is
* the source of the event.
*
* @since 1.4
@ -44,12 +44,12 @@ package javax.sql;
public class RowSetEvent extends java.util.EventObject {
/**
* Constructs a <code>RowSetEvent</code> object initialized with the
* given <code>RowSet</code> object.
* Constructs a {@code RowSetEvent} object initialized with the
* given {@code RowSet} object.
*
* @param source the <code>RowSet</code> object whose data has changed or
* @param source the {@code RowSet} object whose data has changed or
* whose cursor has moved
* @throws IllegalArgumentException if <code>source</code> is null.
* @throws IllegalArgumentException if {@code source} is null.
*/
public RowSetEvent(RowSet source)
{ super(source); }

@ -28,9 +28,9 @@ package javax.sql;
import java.sql.*;
/**
* The interface that a <code>RowSet</code> object implements in order to
* present itself to a <code>RowSetReader</code> or <code>RowSetWriter</code>
* object. The <code>RowSetInternal</code> interface contains
* The interface that a {@code RowSet} object implements in order to
* present itself to a {@code RowSetReader} or {@code RowSetWriter}
* object. The {@code RowSetInternal} interface contains
* methods that let the reader or writer access and modify the internal
* state of the rowset.
*
@ -41,32 +41,32 @@ public interface RowSetInternal {
/**
* Retrieves the parameters that have been set for this
* <code>RowSet</code> object's command.
* {@code RowSet} object's command.
*
* @return an array of the current parameter values for this <code>RowSet</code>
* @return an array of the current parameter values for this {@code RowSet}
* object's command
* @throws SQLException if a database access error occurs
*/
Object[] getParams() throws SQLException;
/**
* Retrieves the <code>Connection</code> object that was passed to this
* <code>RowSet</code> object.
* Retrieves the {@code Connection} object that was passed to this
* {@code RowSet} object.
*
* @return the <code>Connection</code> object passed to the rowset
* or <code>null</code> if none was passed
* @return the {@code Connection} object passed to the rowset
* or {@code null} if none was passed
* @throws SQLException if a database access error occurs
*/
Connection getConnection() throws SQLException;
/**
* Sets the given <code>RowSetMetaData</code> object as the
* <code>RowSetMetaData</code> object for this <code>RowSet</code>
* object. The <code>RowSetReader</code> object associated with the rowset
* will use <code>RowSetMetaData</code> methods to set the values giving
* Sets the given {@code RowSetMetaData} object as the
* {@code RowSetMetaData} object for this {@code RowSet}
* object. The {@code RowSetReader} object associated with the rowset
* will use {@code RowSetMetaData} methods to set the values giving
* information about the rowset's columns.
*
* @param md the <code>RowSetMetaData</code> object that will be set with
* @param md the {@code RowSetMetaData} object that will be set with
* information about the rowset's columns
*
* @throws SQLException if a database access error occurs
@ -74,12 +74,12 @@ public interface RowSetInternal {
void setMetaData(RowSetMetaData md) throws SQLException;
/**
* Retrieves a <code>ResultSet</code> object containing the original
* value of this <code>RowSet</code> object.
* Retrieves a {@code ResultSet} object containing the original
* value of this {@code RowSet} object.
* <P>
* The cursor is positioned before the first row in the result set.
* Only rows contained in the result set returned by the method
* <code>getOriginal</code> are said to have an original value.
* {@code getOriginal} are said to have an original value.
*
* @return the original value of the rowset
* @throws SQLException if a database access error occurs
@ -87,12 +87,12 @@ public interface RowSetInternal {
public ResultSet getOriginal() throws SQLException;
/**
* Retrieves a <code>ResultSet</code> object containing the original value
* Retrieves a {@code ResultSet} object containing the original value
* of the current row only. If the current row has no original value,
* an empty result set is returned. If there is no current row,
* an exception is thrown.
*
* @return the original value of the current row as a <code>ResultSet</code>
* @return the original value of the current row as a {@code ResultSet}
* object
* @throws SQLException if a database access error occurs or this method
* is called while the cursor is on the insert row, before the

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2001, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2020, 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
@ -28,9 +28,9 @@ package javax.sql;
/**
* An interface that must be implemented by a
* component that wants to be notified when a significant
* event happens in the life of a <code>RowSet</code> object.
* event happens in the life of a {@code RowSet} object.
* A component becomes a listener by being registered with a
* <code>RowSet</code> object via the method <code>RowSet.addRowSetListener</code>.
* {@code RowSet} object via the method {@code RowSet.addRowSetListener}.
* How a registered component implements this interface determines what it does
* when it is notified of an event.
*
@ -40,38 +40,38 @@ package javax.sql;
public interface RowSetListener extends java.util.EventListener {
/**
* Notifies registered listeners that a <code>RowSet</code> object
* in the given <code>RowSetEvent</code> object has changed its entire contents.
* Notifies registered listeners that a {@code RowSet} object
* in the given {@code RowSetEvent} object has changed its entire contents.
* <P>
* The source of the event can be retrieved with the method
* <code>event.getSource</code>.
* {@code event.getSource}.
*
* @param event a <code>RowSetEvent</code> object that contains
* the <code>RowSet</code> object that is the source of the event
* @param event a {@code RowSetEvent} object that contains
* the {@code RowSet} object that is the source of the event
*/
void rowSetChanged(RowSetEvent event);
/**
* Notifies registered listeners that a <code>RowSet</code> object
* Notifies registered listeners that a {@code RowSet} object
* has had a change in one of its rows.
* <P>
* The source of the event can be retrieved with the method
* <code>event.getSource</code>.
* {@code event.getSource}.
*
* @param event a <code>RowSetEvent</code> object that contains
* the <code>RowSet</code> object that is the source of the event
* @param event a {@code RowSetEvent} object that contains
* the {@code RowSet} object that is the source of the event
*/
void rowChanged(RowSetEvent event);
/**
* Notifies registered listeners that a <code>RowSet</code> object's
* Notifies registered listeners that a {@code RowSet} object's
* cursor has moved.
* <P>
* The source of the event can be retrieved with the method
* <code>event.getSource</code>.
* {@code event.getSource}.
*
* @param event a <code>RowSetEvent</code> object that contains
* the <code>RowSet</code> object that is the source of the event
* @param event a {@code RowSetEvent} object that contains
* the {@code RowSet} object that is the source of the event
*/
void cursorMoved(RowSetEvent event);
}

@ -29,16 +29,16 @@ import java.sql.*;
/**
* An object that contains information about the columns in a
* <code>RowSet</code> object. This interface is
* an extension of the <code>ResultSetMetaData</code> interface with
* methods for setting the values in a <code>RowSetMetaData</code> object.
* When a <code>RowSetReader</code> object reads data into a <code>RowSet</code>
* object, it creates a <code>RowSetMetaData</code> object and initializes it
* using the methods in the <code>RowSetMetaData</code> interface. Then the
* reader passes the <code>RowSetMetaData</code> object to the rowset.
* {@code RowSet} object. This interface is
* an extension of the {@code ResultSetMetaData} interface with
* methods for setting the values in a {@code RowSetMetaData} object.
* When a {@code RowSetReader} object reads data into a {@code RowSet}
* object, it creates a {@code RowSetMetaData} object and initializes it
* using the methods in the {@code RowSetMetaData} interface. Then the
* reader passes the {@code RowSetMetaData} object to the rowset.
* <P>
* The methods in this interface are invoked internally when an application
* calls the method <code>RowSet.execute</code>; an application
* calls the method {@code RowSet.execute}; an application
* programmer would not use them directly.
*
* @since 1.4
@ -47,22 +47,22 @@ import java.sql.*;
public interface RowSetMetaData extends ResultSetMetaData {
/**
* Sets the number of columns in the <code>RowSet</code> object to
* Sets the number of columns in the {@code RowSet} object to
* the given number.
*
* @param columnCount the number of columns in the <code>RowSet</code> object
* @param columnCount the number of columns in the {@code RowSet} object
* @throws SQLException if a database access error occurs
*/
void setColumnCount(int columnCount) throws SQLException;
/**
* Sets whether the designated column is automatically numbered,
* The default is for a <code>RowSet</code> object's
* The default is for a {@code RowSet} object's
* columns not to be automatically numbered.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param property <code>true</code> if the column is automatically
* numbered; <code>false</code> if it is not
* @param property {@code true} if the column is automatically
* numbered; {@code false} if it is not
*
* @throws SQLException if a database access error occurs
*/
@ -70,11 +70,11 @@ public interface RowSetMetaData extends ResultSetMetaData {
/**
* Sets whether the designated column is case sensitive.
* The default is <code>false</code>.
* The default is {@code false}.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param property <code>true</code> if the column is case sensitive;
* <code>false</code> if it is not
* @param property {@code true} if the column is case sensitive;
* {@code false} if it is not
*
* @throws SQLException if a database access error occurs
*/
@ -82,11 +82,11 @@ public interface RowSetMetaData extends ResultSetMetaData {
/**
* Sets whether the designated column can be used in a where clause.
* The default is <code>false</code>.
* The default is {@code false}.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param property <code>true</code> if the column can be used in a
* <code>WHERE</code> clause; <code>false</code> if it cannot
* @param property {@code true} if the column can be used in a
* {@code WHERE} clause; {@code false} if it cannot
*
* @throws SQLException if a database access error occurs
*/
@ -94,11 +94,11 @@ public interface RowSetMetaData extends ResultSetMetaData {
/**
* Sets whether the designated column is a cash value.
* The default is <code>false</code>.
* The default is {@code false}.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param property <code>true</code> if the column is a cash value;
* <code>false</code> if it is not
* @param property {@code true} if the column is a cash value;
* {@code false} if it is not
*
* @throws SQLException if a database access error occurs
*/
@ -106,14 +106,14 @@ public interface RowSetMetaData extends ResultSetMetaData {
/**
* Sets whether the designated column's value can be set to
* <code>NULL</code>.
* The default is <code>ResultSetMetaData.columnNullableUnknown</code>
* {@code NULL}.
* The default is {@code ResultSetMetaData.columnNullableUnknown}
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param property one of the following constants:
* <code>ResultSetMetaData.columnNoNulls</code>,
* <code>ResultSetMetaData.columnNullable</code>, or
* <code>ResultSetMetaData.columnNullableUnknown</code>
* {@code ResultSetMetaData.columnNoNulls},
* {@code ResultSetMetaData.columnNullable}, or
* {@code ResultSetMetaData.columnNullableUnknown}
*
* @throws SQLException if a database access error occurs
*/
@ -121,11 +121,11 @@ public interface RowSetMetaData extends ResultSetMetaData {
/**
* Sets whether the designated column is a signed number.
* The default is <code>false</code>.
* The default is {@code false}.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param property <code>true</code> if the column is a signed number;
* <code>false</code> if it is not
* @param property {@code true} if the column is a signed number;
* {@code false} if it is not
*
* @throws SQLException if a database access error occurs
*/
@ -133,7 +133,7 @@ public interface RowSetMetaData extends ResultSetMetaData {
/**
* Sets the designated column's normal maximum width in chars to the
* given <code>int</code>.
* given {@code int}.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param size the normal maximum number of characters for
@ -145,7 +145,7 @@ public interface RowSetMetaData extends ResultSetMetaData {
/**
* Sets the suggested column title for use in printouts and
* displays, if any, to the given <code>String</code>.
* displays, if any, to the given {@code String}.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param label the column title
@ -154,7 +154,7 @@ public interface RowSetMetaData extends ResultSetMetaData {
void setColumnLabel(int columnIndex, String label) throws SQLException;
/**
* Sets the name of the designated column to the given <code>String</code>.
* Sets the name of the designated column to the given {@code String}.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param columnName the designated column's name
@ -164,7 +164,7 @@ public interface RowSetMetaData extends ResultSetMetaData {
/**
* Sets the name of the designated column's table's schema, if any, to
* the given <code>String</code>.
* the given {@code String}.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param schemaName the schema name
@ -174,7 +174,7 @@ public interface RowSetMetaData extends ResultSetMetaData {
/**
* Sets the designated column's number of decimal digits to the
* given <code>int</code>.
* given {@code int}.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param precision the total number of decimal digits
@ -184,7 +184,7 @@ public interface RowSetMetaData extends ResultSetMetaData {
/**
* Sets the designated column's number of digits to the
* right of the decimal point to the given <code>int</code>.
* right of the decimal point to the given {@code int}.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param scale the number of digits to right of decimal point
@ -194,7 +194,7 @@ public interface RowSetMetaData extends ResultSetMetaData {
/**
* Sets the designated column's table name, if any, to the given
* <code>String</code>.
* {@code String}.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param tableName the column's table name
@ -204,7 +204,7 @@ public interface RowSetMetaData extends ResultSetMetaData {
/**
* Sets the designated column's table's catalog name, if any, to the given
* <code>String</code>.
* {@code String}.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param catalogName the column's catalog name
@ -224,7 +224,7 @@ public interface RowSetMetaData extends ResultSetMetaData {
/**
* Sets the designated column's type name that is specific to the
* data source, if any, to the given <code>String</code>.
* data source, if any, to the given {@code String}.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param typeName data source specific type name.

@ -28,12 +28,12 @@ package javax.sql;
import java.sql.*;
/**
* The facility that a disconnected <code>RowSet</code> object calls on
* The facility that a disconnected {@code RowSet} object calls on
* to populate itself with rows of data. A reader (an object implementing the
* <code>RowSetReader</code> interface) may be registered with
* a <code>RowSet</code> object that supports the reader/writer paradigm.
* When the <code>RowSet</code> object's <code>execute</code> method is
* called, it in turn calls the reader's <code>readData</code> method.
* {@code RowSetReader} interface) may be registered with
* a {@code RowSet} object that supports the reader/writer paradigm.
* When the {@code RowSet} object's {@code execute} method is
* called, it in turn calls the reader's {@code readData} method.
*
* @since 1.4
*/
@ -41,30 +41,30 @@ import java.sql.*;
public interface RowSetReader {
/**
* Reads the new contents of the calling <code>RowSet</code> object.
* In order to call this method, a <code>RowSet</code>
* object must have implemented the <code>RowSetInternal</code> interface
* and registered this <code>RowSetReader</code> object as its reader.
* The <code>readData</code> method is invoked internally
* by the <code>RowSet.execute</code> method for rowsets that support the
* Reads the new contents of the calling {@code RowSet} object.
* In order to call this method, a {@code RowSet}
* object must have implemented the {@code RowSetInternal} interface
* and registered this {@code RowSetReader} object as its reader.
* The {@code readData} method is invoked internally
* by the {@code RowSet.execute} method for rowsets that support the
* reader/writer paradigm.
*
* <P>The <code>readData</code> method adds rows to the caller.
* <P>The {@code readData} method adds rows to the caller.
* It can be implemented in a wide variety of ways and can even
* populate the caller with rows from a nonrelational data source.
* In general, a reader may invoke any of the rowset's methods,
* with one exception. Calling the method <code>execute</code> will
* cause an <code>SQLException</code> to be thrown
* because <code>execute</code> may not be called recursively. Also,
* when a reader invokes <code>RowSet</code> methods, no listeners
* are notified; that is, no <code>RowSetEvent</code> objects are
* generated and no <code>RowSetListener</code> methods are invoked.
* with one exception. Calling the method {@code execute} will
* cause an {@code SQLException} to be thrown
* because {@code execute} may not be called recursively. Also,
* when a reader invokes {@code RowSet} methods, no listeners
* are notified; that is, no {@code RowSetEvent} objects are
* generated and no {@code RowSetListener} methods are invoked.
* This is true because listeners are already being notified by the method
* <code>execute</code>.
* {@code execute}.
*
* @param caller the <code>RowSet</code> object (1) that has implemented the
* <code>RowSetInternal</code> interface, (2) with which this reader is
* registered, and (3) whose <code>execute</code> method called this reader
* @param caller the {@code RowSet} object (1) that has implemented the
* {@code RowSetInternal} interface, (2) with which this reader is
* registered, and (3) whose {@code execute} method called this reader
* @throws SQLException if a database access error occurs or this method
* invokes the {@code RowSet.execute} method
*/

@ -28,13 +28,13 @@ package javax.sql;
import java.sql.*;
/**
* An object that implements the <code>RowSetWriter</code> interface,
* called a <i>writer</i>. A writer may be registered with a <code>RowSet</code>
* An object that implements the {@code RowSetWriter} interface,
* called a <i>writer</i>. A writer may be registered with a {@code RowSet}
* object that supports the reader/writer paradigm.
* <P>
* If a disconnected <code>RowSet</code> object modifies some of its data,
* If a disconnected {@code RowSet} object modifies some of its data,
* and it has a writer associated with it, it may be implemented so that it
* calls on the writer's <code>writeData</code> method internally
* calls on the writer's {@code writeData} method internally
* to write the updates back to the data source. In order to do this, the writer
* must first establish a connection with the rowset's data source.
* <P>
@ -49,13 +49,13 @@ import java.sql.*;
public interface RowSetWriter {
/**
* Writes the changes in this <code>RowSetWriter</code> object's
* Writes the changes in this {@code RowSetWriter} object's
* rowset back to the data source from which it got its data.
*
* @param caller the <code>RowSet</code> object (1) that has implemented the
* <code>RowSetInternal</code> interface, (2) with which this writer is
* @param caller the {@code RowSet} object (1) that has implemented the
* {@code RowSetInternal} interface, (2) with which this writer is
* registered, and (3) that called this method internally
* @return <code>true</code> if the modified data was written; <code>false</code>
* @return {@code true} if the modified data was written; {@code false}
* if not, which will be the case if there is a conflict
* @throws SQLException if a database access error occurs
*/

@ -33,9 +33,9 @@ import java.sql.SQLException;
import java.util.EventObject;
/**
* A <code>StatementEvent</code> is sent to all <code>StatementEventListener</code>s which were
* registered with a <code>PooledConnection</code>. This occurs when the driver determines that a
* <code>PreparedStatement</code> that is associated with the <code>PooledConnection</code> has been closed or the driver determines
* A {@code StatementEvent} is sent to all {@code StatementEventListener}s which were
* registered with a {@code PooledConnection}. This occurs when the driver determines that a
* {@code PreparedStatement} that is associated with the {@code PooledConnection} has been closed or the driver determines
* is invalid.
*
* @since 1.6
@ -55,15 +55,15 @@ public class StatementEvent extends EventObject {
private PreparedStatement statement;
/**
* Constructs a <code>StatementEvent</code> with the specified <code>PooledConnection</code> and
* <code>PreparedStatement</code>. The <code>SQLException</code> contained in the event defaults to
* Constructs a {@code StatementEvent} with the specified {@code PooledConnection} and
* {@code PreparedStatement}. The {@code SQLException} contained in the event defaults to
* null.
*
* @param con The <code>PooledConnection</code> that the closed or invalid
* <code>PreparedStatement</code>is associated with.
* @param statement The <code>PreparedStatement</code> that is being closed or is invalid
* @param con The {@code PooledConnection} that the closed or invalid
* {@code PreparedStatement}is associated with.
* @param statement The {@code PreparedStatement} that is being closed or is invalid
*
* @throws IllegalArgumentException if <code>con</code> is null.
* @throws IllegalArgumentException if {@code con} is null.
*
* @since 1.6
*/
@ -77,16 +77,16 @@ public class StatementEvent extends EventObject {
}
/**
* Constructs a <code>StatementEvent</code> with the specified <code>PooledConnection</code>,
* <code>PreparedStatement</code> and <code>SQLException</code>
* Constructs a {@code StatementEvent} with the specified {@code PooledConnection},
* {@code PreparedStatement} and {@code SQLException}
*
* @param con The <code>PooledConnection</code> that the closed or invalid <code>PreparedStatement</code>
* @param con The {@code PooledConnection} that the closed or invalid {@code PreparedStatement}
* is associated with.
* @param statement The <code>PreparedStatement</code> that is being closed or is invalid
* @param exception The <code>SQLException </code>the driver is about to throw to
* @param statement The {@code PreparedStatement} that is being closed or is invalid
* @param exception The {@code SQLException }the driver is about to throw to
* the application
*
* @throws IllegalArgumentException if <code>con</code> is null.
* @throws IllegalArgumentException if {@code con} is null.
*
* @since 1.6
*/
@ -101,9 +101,9 @@ public class StatementEvent extends EventObject {
}
/**
* Returns the <code>PreparedStatement</code> that is being closed or is invalid
* Returns the {@code PreparedStatement} that is being closed or is invalid
*
* @return The <code>PreparedStatement</code> that is being closed or is invalid
* @return The {@code PreparedStatement} that is being closed or is invalid
*
* @since 1.6
*/
@ -113,9 +113,9 @@ public class StatementEvent extends EventObject {
}
/**
* Returns the <code>SQLException</code> the driver is about to throw
* Returns the {@code SQLException} the driver is about to throw
*
* @return The <code>SQLException</code> the driver is about to throw
* @return The {@code SQLException} the driver is about to throw
*
* @since 1.6
*/

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2020, 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
@ -33,50 +33,50 @@ package javax.sql;
* that are in the Statement pool.
* <p>
* The JDBC 3.0 specification added the maxStatements
* <code>ConnectionPooledDataSource</code> property to provide a standard mechanism for
* enabling the pooling of <code>PreparedStatements</code>
* {@code ConnectionPooledDataSource} property to provide a standard mechanism for
* enabling the pooling of {@code PreparedStatements}
* and to specify the size of the statement
* pool. However, there was no way for a driver to notify an external
* statement pool when a <code>PreparedStatement</code> becomes invalid. For some databases, a
* statement pool when a {@code PreparedStatement} becomes invalid. For some databases, a
* statement becomes invalid if a DDL operation is performed that affects the
* table. For example an application may create a temporary table to do some work
* on the table and then destroy it. It may later recreate the same table when
* it is needed again. Some databases will invalidate any prepared statements
* that reference the temporary table when the table is dropped.
* <p>
* Similar to the methods defined in the <code>ConnectionEventListener</code> interface,
* the driver will call the <code>StatementEventListener.statementErrorOccurred</code>
* Similar to the methods defined in the {@code ConnectionEventListener} interface,
* the driver will call the {@code StatementEventListener.statementErrorOccurred}
* method prior to throwing any exceptions when it detects a statement is invalid.
* The driver will also call the <code>StatementEventListener.statementClosed</code>
* method when a <code>PreparedStatement</code> is closed.
* The driver will also call the {@code StatementEventListener.statementClosed}
* method when a {@code PreparedStatement} is closed.
* <p>
* Methods which allow a component to register a StatementEventListener with a
* <code>PooledConnection</code> have been added to the <code>PooledConnection</code> interface.
* {@code PooledConnection} have been added to the {@code PooledConnection} interface.
*
* @since 1.6
*/
public interface StatementEventListener extends java.util.EventListener{
/**
* The driver calls this method on all <code>StatementEventListener</code>s registered on the connection when it detects that a
* <code>PreparedStatement</code> is closed.
* The driver calls this method on all {@code StatementEventListener}s registered on the connection when it detects that a
* {@code PreparedStatement} is closed.
*
* @param event an event object describing the source of
* the event and that the <code>PreparedStatement</code> was closed.
* the event and that the {@code PreparedStatement} was closed.
* @since 1.6
*/
void statementClosed(StatementEvent event);
/**
* The driver calls this method on all <code>StatementEventListener</code>s
* The driver calls this method on all {@code StatementEventListener}s
* registered on the connection when it detects that a
* <code>PreparedStatement</code> is invalid. The driver calls this method
* just before it throws the <code>SQLException</code>,
* {@code PreparedStatement} is invalid. The driver calls this method
* just before it throws the {@code SQLException},
* contained in the given event, to the application.
*
* @param event an event object describing the source of the event,
* the statement that is invalid and the exception the
* driver is about to throw. The source of the event is
* the <code>PooledConnection</code> which the invalid <code>PreparedStatement</code>
* the {@code PooledConnection} which the invalid {@code PreparedStatement}
* is associated with.
*
* @since 1.6