JDBC 4.0 and Oracle JDeveloper for J2EE Development

The DriverManager class is used to obtain a connection with a database. A JDBC driver is required to be loaded before obtaining a connection with the database. In JDBC 3.0, a JDBC driver can be loaded either by specifying it in the jdbc.drivers system property, or by using the Class.forName() method. We require invoking the Class.forName() method by loading the Oracle JDBC driver, oracle.jdbc.OracleDriver, using JDBC 3.0.

Class.forName("oracle.jdbc.OracleDriver");

In JDBC 4.0 specifications, the DriverManager class has added support to getConnection() and getDrivers() methods, for the Java SE (Service Provider) mechanism. By using these methods, JDBC drivers may be loaded automatically. The Class.forName() method is not required to be invoked. Loading drivers using the Java SE Service Provider mechanism will be discussed in the Automatic SQL Driver Loading section.

A JDBC connection is represented by a java.sql.Connection object, and may be obtained from a DriverManager by calling the overloaded static getConnection() methods. The getConnection() method is listed in following table:

For example, a connection with the Oracle database may be obtained as shown below:

String url="jdbc:oracle:thin:@localhost:1521:ORCL";
Connection connection = DriverManager.getConnection(url, "oe", "pw");

The Connection interface represents a connection with the database. SQL statements may be run in a connection session by using a Statement object. A Connection object is in auto-commit mode, by default. In the auto-commit mode, changes are committed to the database after an SQL statement is executed. The auto-commit mode can be modified by calling the setAutoCommit(boolean autoCommit) method. For example, auto-commit may be set to false :

connection.setAutoCommit(false);

If auto-commit is set to false, it would be required to commit changes by calling the commit() method:

connection.commit();

A Connection object can be set to read-only by calling the setReadOnly() method:

connection.setReadOnly(true);

If a Connection object is not required, close the connection by calling the close() method:

connection.close();

The following table discusses the methods in JDBC 4.0 that have been added to the Connection interface.

A transaction is a group of one or more statements run as a unit. If the default value of auto-commit is set to true, then each Statement that would be run represents a transaction. After each statement is run, changes to the database are made with the auto-commit set to true. Set the auto-commit to false, if a developer requires a group of statements to be run together. Changes to the database are not made till each of the statement has run. If auto-commit is set to false, the changes to the database are committed with the commit() method. The commit() method commits the SQL statements run after the previous commit to the database was made. The group of statements run between two consecutive commits to the database represents a transaction. The rollback() method rolls back the changes made in the current transaction. A transaction may be required to be rolled back, if an error or a SQLException is generated.

connection.rollback();

While one transaction is modifying a database table, another transaction could be reading from the same table. The type of read can be dirty-read, a non-repeatable read, or a phantom read. A dirty-read occurs when a row has been modified by a transaction, but has not been committed, and is being read by a different transaction. If the transaction that modifies the row rolls back the transaction, then the value retrieved by the second transaction would be erroneous. A non-repeatable transaction occurs when one transaction reads a row while the other transaction modifies it. The first transaction re-reads the row obtaining a different value. A phantom read occurs when one transaction retrieves a result set with a WHERE condition, while the other transaction adds a row that meets the WHERE condition. The first transaction re-runs to generate a result set that has an additional row. The default transaction level can be obtained with the getTransactionLevel() method:

int transactionLevel=connection. getTransactionIsolation();

The different transaction isolation levels are listed in following table:

The transaction isolation level can be set with the setTransactionIsolation(int level) method:

connection.setTransactionIsolation(level);

Savepoint is a new interface in JDBC 3.0 specification. A Savepoint is a point within a transaction up to which the changes made in the transaction are rolled back, if the transaction is rolled back with the rollback() method. All changes before the savepoint are implemented when a transaction is rolled back. A savepoint is set with the overloaded setSavepoint() method:

Savepoint savepoint=connection.setSavepoint();
Savepoint savepoint=connection.setSavepoint("savepointName");

The getSavepointId() method returns the savepoint id, and the getSavepointName() method returns the savepoint name.

The Statement interface runs SQL statements in a database and returns the result sets. A Statement object is obtained from a Connection object with the overloaded createStatement() method. Before enumerating the different createStatement() methods, we will discuss about the result set type, result set concurrency, and result set holdability. There are three result set types:

The TYPE_FORWARD_ONLY result set is not scrollable. Its cursor moves only in the forward direction. The rows in the result set satisfies the query, either at the time when the query is executed, or when the rows are retrieved.

The TYPE_SCROLL_INSENSITIVE result set is scrollable. The rows in the result set do not reflect the changes made in the database. The rows in the result set satisfy the query, either at the time when the query is executed, or when the rows are retrieved.

The TYPE_SCROLL_SENSITIVE result set is scrollable, and reflects the changes made to the database while the result set is open.

Result set concurrency specifies the level of updatability. There are two concurrency levels:

CONCUR_READ_ONLY is the default concurrency level. The CONCUR_READ_ONLY concurrency specifies a result set that is not updatable, and CONCUR_UPDATABLE concurrency specifies a result set that is updatable.

Holdability specifies that the result set objects are to be kept open when the commit() method is invoked. There are two holdability values:

If HOLD_CURSORS_OVER_COMMIT is specified, the result set objects (that is cursors) are kept open after the commit() method is called. If CLOSE_CURSORS_AT_COMMIT is specified, the result set objects are closed at the commit() method.

The different createStatement() methods, which are used to create a Statement object from a Connection object are discussed in following table:

Different execute() methods are available to run an SQL statement that may return multiple results. The execute(String sqlStatement) method runs an SQL statement and returns a boolean, which indicates whether the first result is a ResultSet object, or an update count. If true is returned, the first result is a ResultSet object. If false is returned, the first result is an update count. If the first result is a ResultSet object, then the ResultSet object can be obtained with the getResultSet() method. If the first result is an update count, then the update count can be obtained with the getUpdateCount() method:

Statement stmt=connection.createStatement();
boolean resultType=stmt.execute("SQL Statement");
if(resultType==true)
ResultSet resultSet=stmt.getResultSet();
else
int updateCount=stmt.getUpdateCount();

Multiple results can be returned by the execute() method. To obtain additional results, invoke the getMoreResults() method. The return value of the getMoreResults() method is similar to that of the execute() method. JDBC 3.0 introduced the getMoreResults(int) method to specify whether the current result set should be closed before opening a new result set. The getMoreResults(int) method parameter value can be CLOSE_ALL_RESULTS, CLOSE_CURRENT_RESULT, or KEEP_CURRENT_RESULT. If the parameter value is CLOSE_ALL_RESULTS, then all the previously opened ResultSet objects would be closed. If the value is CLOSE_CURRENT_RESULT, only the current ResultSet object is closed. If the value is KEEP_CURRENT_RESULT, the current ResultSet object is not closed.

The setQueryTimeout(int) method specifies the timeout, in seconds, for a Statement object to execute. The executeQuery(String sql) executes an SQL query and returns a single ResultSet object. The executeUpdate(String sql) method executes an SQL statement, which is either a DML (INSERT, UPDATE, or DELETE) statement or a DDL statement. If the SQL string is a DML statement, the executeUpate(String) method returns the number of rows modified. If the SQL string is a DDL statement, the method returns the value, "0". SQL statements can also be run in a batch with the executeBatch() method. Add SQL commands to run a batch with the addBatch(String sql) method:

stmt.addBatch("SQL command");
stmt.executeBatch();

The executeBatch() method returns an int[] value of update counts. The batch SQL commands can be cleared with the clearBatch() method. If a Statement object is not being used, it is closed automatically. It is recommended to close the Statement object with the close() method:

stmt.close();

When a Statement object is closed, the database and the JDBC resources associated with that object are also closed. Further, the ResultSet object associated with the Statement object is also closed.

In JDBC 4.0, the new methods discussed in following table have been added to the Statement interface:

A ResultSet is a table of data, which is a database result set. The result set types, concurrency and holdability were discussed in the previous section. A ResultSet object can be created to scroll, update, and keep the cursors open, when a commit is done:

Statement stmt=connection.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.HOLD_CURSORS_OVER_COMMIT);
ResultSet rs=stmt.execute("sql");

A ResultSet has a cursor, which points to the current row. Initially, the cursor points before the first row. The next() method moves the cursor to the next row. The previous() method shifts the cursor to the previous row. The ResultSet interface provides different methods to position the cursor. If the ResultSet is scrollable, then the result set type is TYPE_SCROLL_INSENSITIVE, or TYPE_SCROLL_SENSITIVE and the cursor can be shifted to a specified position. Some of the methods to position a ResultSet cursor are listed in following table:

For an updatable result set, the method moveToInsertRow() moves the cursor to the insert row, which is a buffer, to insert a new row. The cursor can be shifted back to the current row with the method, moveToCurrentRow(). The ResultSet interface has methods, which are used to obtain the position of the cursor, and are listed in following table:

The ResultSet column values are obtained with the help of getter methods. The ResultSet interface has a 'getter' method for each of the Java data types that map to the database data type. If the database data type is mappable to the Java data type, the Java data type is returned. A getter method with a column index position and column name are included for each of the data types. The getter method with the column index position is more efficient. An int column value is retrieved with the index position, and a String column value is retrieved with the column name as follows:

ResultSet rs;
Int intColumnValue=rs.getInt(1);
String stringColumnValue=rs.getString("column name");

The ResultSet interface has updater methods to update column values in a row. An 'updater' method is included for each of the Java data types that map to the database data type. If the ResultSet is updatable, then the column values in a row can be updated, or a new row can be added. To update a row, move the cursor to the row to be updated. For example, shift the cursor to the tenth row. Update a column value with an updater method. For example, update a String column, column1 to the value col1val. Also update the row in the database:

rs.absolue(10);
rs.updateString("column1", "col1val");
rs.updateRow();

The method updateRow() updates the database. To add a new row, shift the cursor to the insert row with the moveToInsertRow() method. Add column values with the updater methods, and insert a row in the database with the insertRow() method. Shift the cursor to the current row with the moveToCurrentRow() method:

rs.moveToInsertRow();
rs.updateString(1, "JDBC4.0");
rs.updateInt(2,16);
rs.updateBoolean(3, true);
rs.insertRow();
rs.moveToCurrentRow();

The current row in a ResultSet can be deleted with the deleteRow() method. A ResultSet object is automatically closed and the associated resources are released when the Statement object that had created the ResultSet object is being closed. However, it is recommended to close the ResultSet object using the close() method.

rs.close();

In JDBC 4.0, the methods discussed in following table have been added to the ResultSet interface:

The updateObject() method in the ResultSet interface has been modified to support the new data types, NClob and SQLXML in JDBC 4.0. The updater methods in the table do not update the underlying database. To update the database, the insertRow() or updateRow() method is required to be invoked.

A PreparedStatement object represents a precompiled SQL statement. The PreparedStatement interface extends the Statement interface. The precompiled SQL statement has IN parameters for which values are being set with the setter methods of the PreparedStatement interface. A 'setter' method is included for each of the Java data types that map to a SQL data type. The JDBC driver converts the Java data type to an SQL data type. The IN parameter values are set with parameter index. For example, update a Catalog table with the following definition using PreparedStatement :

CatalogId NUMBER
Journal VARCHAR(255)
Publisher VARCHAR(255)
Title VARCHAR(255)
Author VARCHAR(255)

Set Publisher column value to Oracle Publishing, and Journal column values to Oracle Magazine, where CatalogId is 1, referred to the code below:

PreparedStatement pstmt = connection.prepareStatement("UPDATE CATALOG SET Journal=? AND Publisher=? WHERE CatalogId=?");
pstmt.setString(1, "Oracle Magazine");
pstmt.setString(2, "Oracle Publishing");
pstmt.setInt(3, 1);
pstmt.executeUpdate();

If the database supports statement pooling, PreparedStatement objects are pooled by default. In JDBC 4.0, the methods discussed in the following table have been added to the PreparedStatement interface:

Different RDBMS databases in combination with the database-specific JDBC drivers usually support, and implement features differently. It also supports different SQL data types. An application that is used with different databases would be required to obtain database-specific information. For example, an application could be required to retrieve information about all the SQL data types, which are being supported with a database. An application that implements batch updates would be required to find out if a database supports batch updates. The DatabaseMetaData interface represents the database metadata. The database metadata is obtained from the Connection object:

DatabaseMetaData metadata = currentConnection.getMetaData();

The SQL data type supported by a database can be obtained using the getTypeInfo() method:

ResultSet resultSet=metadata.getTypeInfo();

To find out if a database supports batch update, invoke the supportsBatchUpdates() method:

metadata.supportsBatchUpdates();

To find out if a database supports transactions, invoke the supportsTransactions() method, and to find out if a database supports savepoints, invoke the supportsSavepoints() method:

metadata.supportsTransactions();
metadata.supportsSavepoints();

Support for a ResultSet type can be checked using the supportsResultSetType() method, while support for a concurrency type, in combination with a result set type, can be checked with the supportsResultSetConcurrency() method. Support for a result set holdability can be checked with the supportsResultSetHoldability() method:

metadata.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE);
metadata.supportsResultSetConcurrency(ResultSet. TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
metadata.supportsResultSetHoldability(ResultSet. CLOSE_CURSORS_AT_COMMIT);

The database metadata also includes information about the different SQL clauses supported by the database. Support for the GROUP BY clause is checked with the supportsGroupBy() method; support for SELECT FOR UPDATE is checked with the supportsSelectForUpdate() method; support for UNION clause is checked with the supportsUnion() method; support for ALTER TABLE with add column is checked with the supportsAlterTableWithAddColumn() method; and support for mixed case SQL identifiers is checked with the storesMixedCaseIdentifiers() method. Also, the maximum number of columns that can be specified in a SELECT statement is obtained with the getMaxColumnsInSelect() method.

The database metadata also provides information about the JDBC driver and the database. The database product name, the database major version, the driver major version, the driver name, the driver version, and the JDBC major version supported by the driver are obtained as follows:

String database=metadata.getDatabaseProductName();
int databaseMajorVersion=metadata.getDatabaseMajorVersion();
int driverMajorVersion=metadata.getDriverMajorVersion();
String driverName=metadata.getDriverName();
int driverVersion=metadata.getDriverVersion();
int jdbcMajorVersion=metadata.getJDBCMajorVersion();

Metadata about a database table is obtained with the getTables(String catalog,String schemaPattern,String tableNamePattern,String[] types) method. The parameter, catalog, is a catalog name in the database. SchemaPattern is the Schema pattern. TableNamePattern is the table name pattern and the types represents the table type. Table types include TABLE, VIEW, SYSTEM TABLE, GLOBAL TEMPERORY, LOCAL TEMPERORY, ALIAS, and SYNONYM. Obtain all the tables of type, TABLE:

String[] names = {"TABLE"};
ResultSet tables = metadata.getTables(null,"%", "%", names);

Obtain the table name and table schema from the table's metadata:

while (tables.next()) {
String tableName = tables.getString("TABLE_NAME");
String tableSchema = tables.getString("TABLE_SCHEM");
}

Metadata about the columns can be obtained with the getColumns(String catalog,String schemaPattern,String tableNamePattern,String columnNamePattern) method. Obtain the column's metadata for the table name obtained from the table's metadata:

ResultSet columns = metadata.getColumns(null, "%", tableName, "%");

Obtain the column name, column type, column size, and column nullable:

while (columns.next()) {
String columnName = columns.getString("COLUMN_NAME");
String datatype = columns.getString("TYPE_NAME");
int datasize = columns.getInt("COLUMN_SIZE");
int nullable = columns.getInt("NULLABLE");
}

The procedures in the database can be obtained from the getProcedures(String catalog,String schemaPattern, String procedureNamePattern) method:

ResultSet procedures=metadata.getProcedures(null,"%", "%");

Obtain the procedure name, procedure type, and procedure schema:

while (procedures.next())
{
String procedureName = procedures.getString("PROCEDURE_NAME");
String procedureSchema = procedures.getString("PROCEDURE_SCHEM");
String procedureType = procedures.getString("PROCEDURE_TYPE");
}

In JDBC 4.0, the methods discussed in the following table have been added to the DatabaseMetaData interface:

The getSchemas() method in the DatabaseMetaData interface has been overloaded to support a catalog name and a schema pattern.

SQLException is the main Exception that is generated in a JDBC application. The detail of an SQL exception can be obtained from an SQLException object using the SQLException methods, some of which are discussed in following table:

When an SQLException occurs, it is likely that one or more SQLExceptions chained to it, have also occurred. The chained exceptions can be retrieved by invoking the getNextException() method recursively, until the method returns null. The cause of an SQLException can be retrieved using the getCause() method. The chained causes can be also be retrieved by invoking the getCause() method recursively, until the value, null, is returned.

If SQLException is generated output the exception message using the getMessage() method, output the exception causes using the getCause() method recursively, and retrieve exceptions chained to the exception using the getNextException() method recursively:

catch(SQLException e)
{
while(e != null)
{
System.out.println("SQLException Message:" + e.getMessage());
Throwable t = e.getCause();
while(t != null)
{
System.out.println("SQLException Cause:" + t);
t = t.getCause();
}
e = e.getNextException();
}
}

Some of the subclasses in the SQLException class are listed in following table:

JDBC 4.0 has added support for categorization of SQLExceptions and enhanced support for chained SQLExceptions, which we will discuss in a later section.

JDBC 4.0 specification was made available in December 2006. Most databases provide at least a partial support for the JDBC 4.0 specification, in their JDBC drivers. JDBC 4.0 specification is implemented in JDK 6.0. Some of the new features of JDBC 4.0 specification, and the database support for JDBC 4.0 specification are discussed in the following sections.

Class.forName("oracle.jdbc.OracleDriver");

oracle.jdbc.OracleDriver

Enumeration<Driver> drivers=DriverManager.getDrivers();

String url="jdbc:oracle:thin:@localhost:1521:ORCL";
Connection connection = DriverManager.getConnection(url,"oe", "pw");

DatabaseMetaData metadata= connection.getMetaData();

ResultSet rs=metadata.getTypeInfo();

System.out.println("TYPE_NAME:"+rs.getString("TYPE_NAME"));

TYPE_NAME: XML

import java.sql.*;
import javax.xml.stream.*;

SQLXML sqlXML=connection.createSQLXML();

StAXResult staxResult = sqlXML.setResult(StAXResult.class);
XMLStreamWriter xmlStreamWriter = staxResult.getXMLStreamWriter();

xmlStreamWriter.writeStartDocument("UTF-8","1.0");

xmlStreamWriter.writeStartElement("catalog");

xmlStreamWriter.writeEndElement();

xmlStreamWriter.writeEndDocument();

SAXResult saxResult = sqlXML.setResult(SAXResult.class);
ContentHandler contentHandler= saxResult.getHandler();

contentHandler.startDocument();

AttributesImpl.AttributesImpl() attrs=new AttributesImpl();
attrs.addAttribute("","","journal","StringType","OracleMagazine");
contentHandler.startElement("","","catalog",attrs);

contentHandler.endElement("","","catalog");
contentHandler.endDocument();

Writer writer= sqlXML.setCharacterStream();
BufferedReader bufferedReader = new BufferedReader(new FileReader(new File("C:/catalog.xml")));
String line= null;
while((line = bufferedReader.readLine() != null) {
writer.write(line);
}

sqlXML.setString("xmlString");

Statement stmt=connection.createStatement();

stmt.executeUpdate("CREATE Table Catalog(CatalogId int, Catalog XML)");

PreparedStatement statement=connection.prepareStatement("INSERT INTO CATALOG(catalogId, catalog) VALUES(?,?)");

stmt.setInt(1, 1);
stmt.setSQLXML(2, sqlXML);

stmt.executeUpdate();

PreparedStatement stmt=connection.prepareStatement("SELECT * FROM CATALOG WHERE catalogId=?");

stmt.setInt(1, 1);

ResultSet rs=stmt.executeQuery();

SQLXML sqlXML=rs.getSQLXML("Catalog");

System.out.println(sqlXML.getString());

InputStream binaryStream = sqlXML.getBinaryStream();
XMLInputFactory factory = XMLInputFactory.newInstance();
XMLStreamReader xmlStreamReader = factory.createXMLStreamReader(binaryStream);

while(xmlStreamReader.hasNext())
{
int parseEvent=xmlStreamReader.next();
}

System.out.println("Element Local Name: "+xmlStreamReader.getLocalName());
System.out.println("Element Prefix: "+xmlStreamReader.getPrefix());
System.out.println("Element Namespace:"+xmlStreamReader.getNamespaceURI());

for(int i=0; i<xmlStreamReader.getAttributeCount();i++){
System.out.println("Attribute Prefix:"+xmlStreamReader.getAttributePrefix(i));
System.out.println("Attribute Namespace:"+xmlStreamReader.getAttributeNamespace(i));
System.out.println("Attribute Local Name:"+xmlStreamReader.getAttributeLocalName(i));
System.out.println("Attribute Value:"+xmlStreamReader.getAttributeValue(i));
SQL 2003 XML data type supportXML document data, accessing}

String url="jdbc:oracle:thin:@localhost:1521:ORCL";
Connection connection = DriverManager.getConnection(url,"oe", "pw");
String sql="INSERT INTO CATALOG(catalogId, journal) VALUES(?,?)"
java.sql.PreparedStatement stmt = connection.prepareStatement(sql);
Class class = Class.forName("oracle.jdbc.OraclePreparedStatement");
if(stmt.isWrapperFor(class))
{
OraclePreparedStatement ops = (OraclePreparedStatement)stmt.unwrap(class);
ops.defineColumnType(2, oracle.jdbc.OracleTypes.VARCHAR,4000);
}

catch(SQLException sqlException)
{
for(Throwable e : sqlException )
{
System.out.println("Error encountered: " + e);
}
}

if(!conn.isClosed())
if(!conn.isValid())
conn.close();

if(stmt.isPoolable())
stmt.setPoolable(true);

Statement stmt = conn.createStatement();
Class class = Class.forName("oracle.jdbc.OracleStatement");
if(stmt.isWrapperFor(class))
{
OracleStatement oracleStmt = (OracleStatement)stmt.unwrap(class);
oracleStmt.defineColumnType(1, Types.NUMBER);
}

java.sql.RowId rowid=rs.getRowId();

String url="jdbc:oracle:thin:@localhost:1521:ORCL";
Connection connection = DriverManager.getConnection(url,"oe", "pw");
Blob aBlob = connection.createBlob();

OutputStream outputStream=aBlob.setBinaryStream(1);

pstmt.setBlob(2,aBlob);

rs.updateBlob(3,aBlob);

Blob blob=rs.getBlob(2);

InputStream inputStream = aBlob.getBinaryStream(200, 100);

aBlob.free();

We will connect with a database using a JDBC 4.0 driver. We will use Java DB as the example database. Java DB is Sun's version of the open-source Apache Derby database. Java DB is a lightweight (only 2MB), yet fully transactional, secure, and standards-based component. It also supports the SQL, JDBC, and Java EE standards. Java DB is a 100% Java technology database, and since Java is portable across platforms, Java DB can be run on any platform and its applications can be migrated to other open standard databases. Java DB is packaged with JDK 6. Therefore, all that is required to install Java DB is to install JDK 6. We connect with Java DB database using the JDBC 4.0 driver. Create a Java application, JDBCConnection.java, in a directory, C:/JavaDB, and add the directory to the CLASSPATH system environment variable. Java DB can be started in the embedded mode or as network server. Embedded mode is used to connect to the Java DB from a Java application running in the same JVM as the Java DB database. Java DB as a network server is used to connect with the database from different JVMs across the network. We will start Java DB in embedded mode from the JDBCConnection.java application. We will load the JDBC 4.0 driver automatically using the Java SE Service Provider mechanism. For automatic loading of the JDBC driver, we need to add the Java DB JDBC 4.0 driver JAR file, C:/Program Files/Sun/JavaDB/lib/derby.jar to the CLASSPATH variable. Java DB provides a batch script, setEmbeddedCP.bat in the bin directory to set the CLASSPATH for the embedded mode. Run the setEmbeddedCP script from the directory from which the JDBCConnection.java application is to be run as follows:

"C:\Program Files\Sun\JavaDB\bin\setEmbeddedCP.bat"

JAR file, derby.jar is added to the CLASSPATH. The derby.jar file includes a directory structure, META-INF/services/, and a file, java.sql.Driver, in the services directory. The java.sql.Driver file specifies the following JDBC driver class for the Java DB that is to be loaded automatically using the Java SE Service Provider mechanism:

org.apache.derby.jdbc.AutoloadedDriver

In the JDBCConnection.java application, specify the connection URL for the Java DB database. Create a new database instance by specifying the database name, demodb, and the create attribute as, true:

String url="jdbc:derby:demodb;create=true";

Connect with the Java DB database using the getConnection() method of the DriverManager class:

Connection conn = DriverManager.getConnection(url);

The DriverManager automatically loads the JDBC 4.0 driver class, org.apache.derby.jdbc.AutoloadedDriver, which is specified in the java.sql.Driver file using the Java SE Service Provider mechanism. The JDBC driver is not required to be loaded using the Class.forName() method using a JDBC 3.0 driver. The JDBCConnection.java application is listed below:

import java.sql.*;
public class JDBCConnection
{
public void connectToDatabase()
{
try
{
String url="jdbc:derby:demodb;create=true";
Connection conn = DriverManager.getConnection(url);
System.out.println("Connection Established");
}
catch (SQLException e)
{
System.out.println(e.getMessage());
}
}
public static void main(String[] argv)
{
JDBCConnection jdbc = new JDBCConnection();
jdbc.connectToDatabase();
}
}

Other Relational Database Management Systems (RDBMS) databases provide a JDBC 4.0 driver that can be connected using the JDBC 4.0 driver, as discussed for the Java DB database. The connection URLs, and JDBC 4.0 drivers for some of the commonly used databases are discussed in following table:

In this chapter, you have been introduced to the JDBC API and the new features in JDBC 4.0 specification. The DriverManager class is used to connect with a database. The Connection interface represents a database connection. The Savepoint interface represents a savepoint in a transaction. This is the point up to which the changes would be rolled back, if the transaction is rolled back. The Statement interface is used to run static SQL statements. The ResultSet interface represents the result set table generated by running SQL statements on a database. The PreparedStatement represents a compiled SQL statement that can be run more than once with different parameters. The DatabaseMetadata interface represents the database metadata, such as, table name, schema name, column name, and column type. The SQLException class represents the database access error or other SQL errors. JDBC 4.0 specification provides some new features to facilitate the development of JDBC applications. Support for new SQL data types has been added. The new features include, automatic SQL Driver loading, SQL: 2003 XML Data Type support, support for wrapper pattern, enhancements in SQLException, and enhanced connection management.