1 Introduction

The following code fragment gives a basic example of these three steps:

Connection con = DriverManager.getConnection (
						"jdbc:odbc:wombat", "login", "password");
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table1");
while (rs.next()) {
	int x = getInt("a");
	String s = getString("b");
	float f = getFloat("c");
	}

1.1.2 JDBC Is a Low-level API and a Base for Higher-level API

1. an embedded SQL for Java (at least one vendor plans to build this), and
2. a direct mapping of relational database tables to Java classes (JavaSoft and others have announced plans to do this).

1.1.3 JDBC and ODBC

The answer is that you can use ODBC from Java, but this is best done with the help of JDBC in the form of the JDBC-ODBC Bridge. which we will cover shortly. The question now becomes, "Why do you need JDBC?" There are several answers to this question:

1. ODBC is not appropriate for direct use from Java because it uses a C interface. Calls from Java to native C code have a number of drawbacks in the security, implementation, robustness, and automatic portability of applications.
2. A literal translation of the ODBC C API into a Java API would not be desirable. For example, Java has no pointers, and ODBC makes copious use of them, including the notoriously error-prone generic pointer "void *". You can think of JDBC as ODBC translated into an object-oriented interface that is natural for Java programmers.
3. ODBC is hard to learn. It mixes simple and advanced features together, and it has complex options even for simple queries. JDBC, on the other hand, was designed for a wide range of programmers and keeps simple things simple.
4. A Java API like JDBC is needed in order to enable an "all-Java" solution. When ODBC is used, the ODBC driver manager and drivers must be manually installed on every client machine. When the JDBC driver is written completely in Java, however, JDBC code is automatically installable, portable, and secure on all Java platforms from network computers to mainframes.

1.1.4 Two-tier and Three-tier Models

In the two-tier model, a Java applet or application talks directly to the database. This requires a JDBC driver that can communicate with the particular database management system being accessed. A user's SQL statements are delivered to the database, and the results of those statements are sent back to the user. The database may be located on another machine to which the user is connected via a network. This is referred to as a client/server configuration, with the user's machine as the client, and the machine housing the database as the server. The network can be an intranet, which, for example, connects employees within a corporation, or it can be the Internet.

In the three-tier model, commands are sent to a "middle tier" of services, which then send SQL statements to the database. The database processes the SQL statements and sends the results back to the middle tier, which then sends them to the user. MIS directors find the three-tier model very attractive because the middle tier makes it possible to maintain control over access and the kinds of updates that can be made to corporate data. Another advantage is that when there is a middle tier, the user can employ an easy-to-use higher-level API which is translated by the middle tier into the appropriate low-level calls. Also, in many cases the three-tier architecture can provide performance advantages.

Until now the middle tier has typically been written in languages such as C or C++, which offer fast performance. However, with the introduction of optimizing compilers translating Java bytecode into efficient machine-specific code, it is becoming practical to implement the middle tier in Java. This is a big plus, making it possible to take advantage of Java's robustness, multi-threading, and security features.

1.1.5 SQL Conformance

One way the JDBC API deals with this problem is to allow any query string to be passed through to an underlying DBMS driver. This means that an application is free to use as much SQL functionality as desired, but it runs the risk of receiving an error on some DBMSs. In fact, an application query need not even be SQL, or it may be a specialized derivative of SQL designed for specific DBMSs (for document or image queries, for example).

A second way JDBC deals with problems of SQL conformance is to provide ODBC-style escape clauses, which are discussed in SQL Escape Syntax in Statement Objects on page 27. This escape syntax allows a programmer to use SQL functionality from within a JDBC program.

For complex applications, JDBC deals with SQL conformance in a third way. It provides descriptive information about the DBMS by means of DatabaseMetaData so that applications can adapt to the requirements and capabilities of each DBMS.

Because the JDBC API will be used as a base API for developing higher-level database access tools and APIs, it also has to address the problem of conformance for anything built on it. The designation "JDBC COMPLIANT^TM" was created to set a standard level of JDBC functionality on which users can rely. In order to use this designation, a driver must support at least ANSI SQL-2 Entry Level. (ANSI SQL-2 refers to the standards adopted by the American National Standards Institute in 1992. Entry Level refers to a specific list of SQL capabilities.) Driver developers can ascertain that their drivers meet these standards by using the test suite available with the JDBC API.

The "JDBC COMPLIANT^TM" designation indicates that a vendor's JDBC implementation has passed the conformance tests provided by JavaSoft. These conformance tests check for the existence of all of the classes and methods defined in the JDBC API, and check as much as possible that the SQL Entry Level functionality is available. Such tests are not exhaustive, of course, and JavaSoft is not currently branding vendor implementations, but this compliance definition provides some degree of confidence in a JDBC implementation. With wider and wider acceptance of the JDBC API by database vendors, connectivity vendors, Internet service vendors, and application writers, JDBC is quickly becoming the standard for Java database access.

The JDBC API is a natural choice for Java developers because it offers easy database access for Java applications and applets. Because JDBC brings together Java and databases, the remainder of this chapter gives a brief overview of each.

1.2 JDBC Products

http://splash.javasoft.com/jdbc/

For more information on database products, or if the address above does not work, the JavaSoft web page can be found at:

http://java.sun.com/

1.2.1 JavaSoft Framework

• the JDBC driver manager,
  
  
• the JDBC driver test suite, and
  
  
• the JDBC-ODBC bridge.
  
  

The JDBC driver test suite provides some confidence that JDBC drivers will run your program. It tests that a JDBC driver implements all of the JDBC classes and methods and that it provides the Entry Level SQL functionality required for JDBC compliance.

The JDBC-ODBC bridge allows ODBC drivers to be used as JDBC drivers. It was implemented as a way to get JDBC off the ground quickly, and long term will provide a way to access some of the less popular DBMSs if JDBC drivers are not implemented.

1.2.2 JDBC Driver Types

1. JDBC-ODBC bridge plus ODBC driver: The JavaSoft bridge product provides JDBC access via ODBC drivers. Note that ODBC binary code and in many cases database client code must be loaded on each client machine that uses this driver. As a result, this kind of driver is most appropriate on a corporate network where client installations are not a major problem, or for application server code written in Java in a 3-tier architecture.
2. Native-API partly-Java driver: This kind of driver converts JDBC calls into calls on the client API for Oracle, Sybase, Informix, DB2, or other DBMS. Note that, like the bridge driver, this style of driver requires that some binary code be loaded on each client machine.
3. JDBC-Net all-Java driver: This driver translates JDBC calls into a DBMS-independent net protocol which is then translated to a DBMS protocol by a server. This net server middleware is able to connect its all-Java clients to many different databases. The specific protocol used depends on the vendor. In general, this is the most flexible JDBC alternative. It is likely that all vendors of this solution will provide products suitable for Intranet use. In order for these products to also support Internet access, they must handle the additional requirements for security, access through firewalls, etc., that the Web imposes. Several vendors are adding JDBC drivers to their existing database middleware products.
4. Native-protocol all-Java driver: This kind of driver converts JDBC calls into the network protcol used by DBMSs directly. This allows a direct call from the client machine to the DBMS server and is a practical solution for Intranet access. Since many of these protocols are proprietary, the database vendors themselves will be the primary source. Several database vendors have these in progress.

1.2.3 Obtaining JDBC Drivers

To get the latest information on drivers, check the JDBC web page mentioned earlier. The first vendors with Category 3 drivers available were SCO, Open Horizon, Visigenic, and WebLogic. The leading vendor in ODBC drivers is Intersolv; JavaSoft did the JDBC-ODBC Bridge and JDBC Driver Test Suite work with Intersolv.

1.2.4 Other Products

JavaSoft or a standards group may attempt to standardize on a network protocol that is DBMS-independent. In that case JavaSoft could bundle the "client side" implementing the protocol with the JDK (Java Developer's Kit), and various vendors could provide the server side: