What Is SQLException Chaining in Font

Print PDF417 in Font What Is SQLException Chaining

Each SQLException provides chain information, and you can use chains to provide additional error information. A JDBC problem can stem from various problems (such as a driver is not loadable, a database is not available, a table does not exist, and so on). The SQLException class has a method, getNextException(), that returns either the next exception or null when all exceptions have been retrieved. Obtaining multiple exceptions this way is termed chaining. The SQLException class has two methods that provide further information: a method to get (or chain) additional exceptions and a method to set an additional exception. SQLException.getSQLState() returns a SQLState identifier based on the XOPEN SQL specification. A SQLState string follows either the XOPEN SQLState conventions or the SQL-99 conventions. The values of the SQLState string are described in the appropriate specifications. You can use the

DatabaseMetaData.getSQLStateType() method to discover whether the driver returns the XOPEN type or the SQL-99 type. Your database-specific reference manuals should list some of these. SQLException.getErrorCode() retrieves the vendor-specific error code. (It retrieves the vendorspecific exception code for this SQLException object.) SQLException.getNextException() retrieves the next SQLException or null if there are no more exceptions. Many things can go wrong between your client program and the database. This method allows you to track all problems that occur. (Also, the setNextException() method allows the programmer to add a SQLException to the chain.) Typical catch code would look similar to the following: try { // some database/JDBC work } catch (SQLException se) { // // se is the first exception, you may handle this and get // the other chained exceptions; // // in most of the situations, this exception is sufficient and // there might not be any need for chained exceptions (this will // depend on the requirements of the project) // while (se != null) { // get the next exception from the chain and handle the exception System.out.println("SQL Exception:" + se.getMessage()); System.out.println("SQL State: " + se.getSQLState()); System.out.println("Vendor specific Error Code: " + se.getErrorCode()); se = se.getNextException(); // this is chaining // // handle the se (if necessary) // } }

If you are debugging your database application and you want to be aware of every little thing that goes wrong within the database, you might use a printSQLExceptions() method such as the following one (please note that this method is for debugging purposes only; in a production environment, you would not call such a method): void printSQLExceptions(SQLException e) { while (e != null) { System.out.println("SQLException: " + e.getMessage()); System.out.println("SQL State: " + e.getSQLState()); System.out.println("Vendor specific Error Code: " + e.getErrorCode()); e = e.getNextException(); } } You can then use the printSQLExceptions() method as follows: ResultSet rs = null; Statement stmt = null; Connection conn = null; try {

conn = getConnection(); stmt = conn.createStatement(); rs = stmt.executeQuery("SELECT id, name FROM EMPLOYEES"); ... } catch(SQLException e) { printSQLExceptions(e); // handle the exception } finally { // clean up and close the database/JDBC resources }

The SQLWarning class is an exception that provides information about database access warnings. SQLWarning is a class that extends the SQLException class but is not thrown like other exceptions. Warnings are silently chained to the object whose method caused the warning to be reported. To get the SQLWarning exception, the programmer must specifically ask for warnings. SQLWarning indicates that something not exactly right occurred but its effect was not severe enough to end processing. In general, if SQLException is not caught, it will halt the program, but SQLWarning does not warrant halting the entire program. Warnings may be retrieved from the java.sql.Connection, java.sql.Statement, and java.sql.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 an exception to be thrown. Note that closing a statement also closes the result set that it might have produced. The SQLWarning class has two methods: SQLWarning getNextWarning(): Retrieves the warning chained to this SQLWarning object (returns the next SQLException in the chain and returns null if none) void setNextWarning(SQLWarning w): Adds a SQLWarning object (denoted by w) to the end of the chain Table 10-3 lists the java.sql.SQLWarning constructors, and Table 10-4 lists the java.sql.SQLWarning methods. Table 10-3. java.sql.SQLWarning Constructors