JDBC 3.0 version there is number of properties defined for the ConnectionPoolDataSource. These properties can be used to describe how the PooledConnection objects created by DataSource objects should be pooled.
Difference between JDBC 3.0 & JDBC 4.0
Features of JDBC 3.0
- Reusabilty of prepared statements by
- In this version there is number of properties
defined for the ConnectionPoolDataSource. These properties can be
used to describe how the PooledConnection objects created by DataSource
objects should be pooled.
- A new concept has been added to this API is of savepoints:
One of the useful new features is transactional savepoints. With JDBC 3.0,
the transactional model is now more flexible. Now you can start a
transaction , insert several rows in it and then create a savepoint. This
savepoint serves as a bookmark. The application can rollback to the
savepoint and then commit the group of inserts as if the updates have never
been attempted. For eg:
int rowcount=st.executeUpdate("insert into employee
int rowcoutn=st.executeUpdate("insert into salary values(20000.0);
Savepoint sv=connection.setSavePoint("savepoint"); //create save
point for inserts
int rowcount=st.executeUpdate("delete from employee");
connection.rollback(sv); //discard the delete statement but keeps the
connection.commit(); //inserts are now permanent
- Retrieval of parameter metadata.
- It has added a means of retrieving values from
columns containing automatically generated values.
- Added a new data type i.e. java.sql.BOOLEAN.
- Passing parameters to CallableStatement.
- The data in the Blob and Clob can be
altered: JDBC 3.0 introduces a standard mechanism for updating BLOB
and CLOB data.
- DatabaseMetaData API has been added.
- It allows stored procedure parameters to be called
Features of JDBC 4
JDBC 4 is a major new release with a strong focus
ease-of-use and programmer productivity. JDBC 4's key priority is to make
it easier for developers to work directly with the JDBC API. The new features
availble in J2SE 1.5 added ease-of-development features in JDBC 4
In addition to ease-of-use, JDBC 4 introduces several
SQL 203 features, like Java specific mapping for the new XML SQL type. Now in
JDBC 4 every PreparedStatement is poolable by default.
- Auto- loading of JDBC driver class: In
JDBC 4 invoking the getConnection() on DriverManager will
automatically load a driver. Upon loading the driver, an instance of the
driver is created and the registerDriver() method is invoked to make
that driver available to clients.
- Connection management enhancements: In jdbc
it may happen that a Connection is lying idle or not closed in a pool, then
it became stale over time. This will led to the connection pool run out of
resources due to stale connection. We know that the stale connection doesn't
mean that a connection is closed. Now in JDBC 4 Connection class we have
provided one method isValid(), which allows a client to query the
database driver if a connection is still valid. As database is a shared
resource, so many application can access the same data store. To maintain
all the records of the client is a difficult task, now in JDBC 4 an
application can associate metadata with a database connection via the setClientInfo()
method, which takes a name/value pair, or a Properties object.
- Support for RowId data type: JDBC
introduces support for ROWID, a data type that had been in use in
database products even before it became part of the SQL.
- SQL exception handling enhancements: JDBC 4
addresses the error handling beautifully. As databases are often remotely
accessible resources, problems such as network failures is common and it can
cause exceptions when executing a database operation. SQL statements
can also cause exceptions. Prior to JDBC 4, most JDBC operations generated a
- SQL XML support:
- DataSet implementation of SQL using Annotations: The
JDBC 4.0 specification leverages annotations to allow developers to
associate a SQL query with a Java class without a need to write a lot of
code to achieve this association.