Documentation Contents
[Top] [Prev] [Next] [Bottom]



Summary of New Features

NOTE: The material in this chapter is based on JDBCtm API Tutorial and Reference, Second Edition: Universal Data Access for the Javatm 2 Platform, published by Addison Wesley as part of the Java series, ISBN 0-201-43328-1.



This appendix summarizes the new features in the JDBC 2.1 core API.

A.1 Overview of JDBC 2.1 Core API Changes

The JDBC 2.1 core API includes the JDBC 1.0 API and adds enhancements and new functionality to it. These additions put the Java programming language at the forefront of database computing, providing both universal data access and improved performance.

Applications that use earlier versions of the JDBC API can be run using the Java 2 platform with no problem, in keeping with the goal of backward compatibility. However, an application that takes advantage of the new 2.0 features must be run with a driver that implements those features.



The new features in the JDBC 2.1 core API fall into two broad categories: support for new functionality and support for the SQL3 data types.


Support for new functionality


scrollable result sets

batch updates

programmatic inserts, deletes, and updates

other


performance hints

character streams for streams of internationalized Unicode characters

full precision for java.math.BigDecimal values

support for time zones in Date, Time, and Timestamp values





Support for advanced data types


new SQL data types (SQL3 types)

increased support for storing persistent objects in the Java programming language



In addition to making the retrieval, storage, and manipulation of data more convenient, the new features make JDBC applications more efficient. For example, batch updates can increase performance dramatically. The new interfaces Blob, Clob, and Array allow applications to operate on large amounts of data without having to materialize the data on the client, which can mean a significant savings in transfer time and the amount of memory needed. Also, new methods for setting the fetch size and fetch direction let a programmer fine tune an application for more efficient data retrieval and processing.



A.2 Summary of New Functionality

The JDBC 2.1 core API adds important new functionality. The following sections briefly explain each new area of functionality and summarize the supporting API.

A.2.1 Scrollable Result Sets

Scrollable result sets provide the ability to move the cursor forward and backward to a specified position or to a position relative to the current position. The following interfaces have new methods that support scrollable result sets.

ResultSet

methods for moving the cursor to a particular row or to a relative position (either forward or backward)

methods for ascertaining the current position of the cursor

constants indicating the scrollability of a result set

Connection

new versions of the methods for creating Statement, PreparedStatement, and CallableStatement objects that make the result sets they produce scrollable

DatabaseMetaData

method indicating whether the DBMS and driver support scrollable result sets

A.2.2 Batch Updates

The new batch update facility provides the ability to send multiple updates to the database to be executed as a batch rather than sending each update separately. The following interfaces add methods that support batch updates, and the exception BatchUpdateException is new.

Statement, PreparedStatement, and CallableStatement

methods for adding update statements to a batch, clearing all update statements, and executing a batch

DatabaseMetaData

method indicating whether the DBMS and driver support batch updates

BatchUpdateException

exception thrown when an error occurs in a batch update

A.2.3 Programmatic Updates

Programmatic updates provide the ability to make updates using the JDBC API rather than SQL statements. The following interfaces have new methods and constants that support programmatic updates.

ResultSet

an updateXXX method for updating each data type

methods for inserting, deleting, or updating a row

methods indicating whether a row was inserted, deleted, or updated

method for cancelling a row update

constants indicating the updatability of a result set

DatabaseMetaData

methods indicating the visibility of changes to a result set

methods indicating whether a result set detects inserts, deletes, or updates

method indicating whether the DBMS and driver support updatable result sets

A.2.4 Other New Features

The JDBC 2.1 core API provides various other new features, which are summarized in the following list.

Performance enhancements-new methods that allow a programmer to fine tune the retrieval of rows from the database. These methods provide the ability to specify (1) the number of result set rows fetched from the database when more rows are needed and (2) the direction in which rows are fetched from the database.

ResultSet methods for getting and setting the current fetch size and fetch direction

Statement, PreparedStatement, and CallableStatement methods for getting and setting the default fetch size and default fetch direction that result sets generated by executing a query will have when they are first created

Character streams-new methods that allow character data to be retrieved or sent to the database as a stream of internationalized Unicode characters. These methods replace the deprecated getUnicodeStream and setUnicodeStream methods.

ResultSet.getCharacterStream

CallableStatement.getCharacterStream

PreparedStatement.setCharacterStream

Full precision for java.math.BigDecimal values-new versions of themethods that retrieve a java.math.BigDecimal value with full precision. Unlike the deprecated versions they replace, these new versions do not take a specified precision.

ResultSet.getBigDecimal

CallableStatement.getBigDecimal

Support for time zones-methods with new versions that take a Calendar object as a parameter, which allows the driver to use a specified time zone rather than the default when calculating a value for a date, time, or timestamp

ResultSet.getDate

ResultSet.getTime

ResultSet.getTimestamp

CallableStatement.getDate

CallableStatement.getTime

CallableStatement.getTimestamp

PreparedStatement.setDate

PreparedStatement.setTime

PreparedStatement.setTimestamp

A.3 Support for Advanced Data Types

The JDBC 2.1 core API adds support for using advanced data types, making it as easy to use them as it is to use simple data types. This support includes the ability to store, retrieve, and update even the new SQL data types that are essentially objects, blurring the distinction between object databases and relational databases. The next four sections ("What Are the SQL3 Data Types?" on page 120, "Summary of Support for the SQL3 Data Types" on page 121, "Mapping of the New SQL3 Types" on page 122, and "SQL Locators" on page 123) describe how the JDBC 2.0 core API provides support for these advanced data types.

In addition to being able to store objects defined in SQL as values in a database table, programmers writing Java applications can also store objects defined in the Java programming language as values in a database table. The section "Support for Storing Java Objects" on page 123 describes this capability.

Note that a driver is not required to implement functionality that its DBMS does not support, so not all drivers necessarily implement the functionality described here. DatabaseMetaData methods such as getTypeInfo, getColumns, and getUDTs may be called to get information about which data types a driver supports.

A.3.1 What Are the SQL3 Data Types?

This section briefly describes the new SQL3 data types. Their mapping to types in the Java programming language is described in section A.3.3 on page 122.



The SQL3 data types can be categorized as follows:



New built-in types-types for storing large objects. These are in addition to the standard built-in data types, such as CHAR, FLOAT, DATE, and so on.

BLOB (Binary Large Object)

CLOB (Character Large Object)

Constructed types-types based on a given base type

REF(structured type)-a reference to the specified SQL structured type

ARRAY[n]-an array of n elements that are all one data type

User-defined types (UDTs)-new types created with the SQL commandþCREATE TYPE

Distinct type-a new type based on the representation of a single built-in type

Structured type-a new type containing multiple attributes, each of which may be either a built-in or a user-defined data type

Locator types-types that are logical pointers to data that resides on the database server

LOCATOR(structured type)

LOCATOR(array)

LOCATOR(blob)

LOCATOR(clob)

A.3.2 Summary of Support for the SQL3 Data Types

The JDBC 2.1 core API supports the new SQL 3 data types by means of the following new interfaces, methods, and fields.

New interfaces for the new data types. The SQL3 types are mapped by the following new JDBC 2.1 core API interfaces:

java.sql.Array

java.sql.Blob

java.sql.Clob

java.sql.Ref

java.sql.Struct

New interfaces that support customizing the mapping of UDTs (SQL structured and distinct types) into classes in the Java programming language

SQLData

SQLInput

SQLOutput

New methods added to existing interfaces in order to retrieve, store, and update the new SQL3 types

new getXXX methods in the ResultSet interface to retrieve SQL3 type column values from a result set

new getXXX methods in the CallableStatement interface to retrieve SQL3 type values in output parameters

new setXXX methods in the PreparedStatement interface to set a SQL3 type column value

new updateXXX methods in the ResultSet interface to update values programmatically

New methods in the DatabaseMetaData and ResultSetMetaData interfaces for getting metadata about the new data types

New fields (constants) added to the class java.sql.Types to support the new data types and persistent storage

DISTINCT

STRUCT

ARRAY

BLOB

CLOB

REF

JAVA_OBJECT

A.3.3 Mapping of the New SQL3 Types

The JDBC 2.1 core API does not try to replicate the SQL3 types exactly; rather, its goal is to map them to types in the Java programming language so that they retain their functionality and are convenient to use. For example, SQL3 has what are called locator types, which are used on a client to designate data that is stored on a database server. Locators can be very useful for dealing with data that is large because they allow the data to be manipulated without having to be materialized on the client machine. SQL3 includes locators for the types ARRAY, BLOB, CLOB and structured types. The JDBC 2.1 core API does not include locators for these types directly (and not at all for structured types) but rather provides interfaces that are implemented such that the driver and DBMS use the appropriate locators behind the scenes. The result is that a developer using the JDBC API to access an SQL ARRAY, BLOB, or CLOB value need not even be aware of locators. See section A.3.4 on page 123 for more information about locators.

In the JDBC 2.1 core API, the following SQL3 types are mapped to interfaces in the Java programming language:

ARRAY-mapped to java.sql.Array

BLOB-mapped to java.sql.Blob

CLOB-mapped to java.sql.Clob

REF-mapped to java.sql.Ref

an SQL structured type-mapped to java.sql.Struct

Distinct types are not mapped to an interface because they are based on a single built-in type and thus can simply be mapped to the standard mapping for that built-in type. For example, the following is an SQL statement that creates the new type MONEY.

CREATE TYPE MONEY AS NUMERIC(10, 2)

This new UDT is based on the data type NUMERIC, which maps to java.math.BigDecimal, so the type MONEY maps to java.math.BigDecimal. This means that a value of type MONEY would be retrieved with the method getBigDecimal, stored with the method setBigDecimal, and updated with the method updateBigDecimal.

A.3.4 SQL Locators

An SQL LOCATOR is a logical pointer to data that resides on a database server. It typically refers to data that is too large to materialize on the client, such as images or audio. Locators exist only in a client environment, and their existence is transient. A standard implementation of the JDBC 2.1 core API will use locators internally for instances of the Blob, Clob, and Array interfaces. This means that Blob, Clob, and Array objects contain a locator that points to the data on the server rather than containing the data itself. Programmers operating on Blob, Clob, and Array instances are actually operating on the database objects they represent. This ability to operate on large database objects without bringing their data to the client is a major plus in performance.

Note that the JDBC 2.1 core API does not call for using the SQL LOCATOR(structured type). In a standard implementation, a Struct object contains the data of the structured type that it maps and is not implemented internally as a locator, as are Blob, Clob, and Array objects.

A.3.5 Support for Storing Java Objects

The JDBC API has always supported persistent storage of objects defined in the Java programming language through the methods getObject and setObject. But, of course, persistent storage of Java objects does not actually occur unless a DBMS also supports it. Up to this point, support was limited, but a new generation of DBMSs that recognize Java objects as a data type is emerging. In these DBMSs, termed Java relational DBMSs, an instance of a Java class can be stored as a column value in a database table.



[Top] [Prev] [Next] [Bottom]








Copyright © 1995-2010 Sun Microsystems, Inc. All Rights Reserved. Please send comments using this Feedback page.

Java Technology