JDBC Driver Manager

The JDBC DriverManager class defines objects which can connect Java applications to a JDBC driver.
DriverManager has traditionally been the backbone of the JDBC architecture. It is quite small and simple.

This is a very important class. Its main purpose is to provide a means of managing the different types of
JDBC database driver. On running an application, it is the DriverManager's responsibility to load all the
drivers found in the system property jdbc. drivers. For example, this is where the driver for the Oracle
database may be defined. This is not to say that a new driver cannot be explicitly stated in a program at
runtime which is not included in jdbc.drivers. When opening a connection to a database it is the
DriverManager' s role to choose the most appropriate driver from the previously loaded drivers.

The JDBC API defines the Java interfaces and classes that programmers use to connect to databases and
send queries. A JDBC driver implements these interfaces and classes for a particular DBMS vendor.

A Java program that uses the JDBC API loads the specified driver for a particular DBMS before it
actually connects to a database. The JDBC DriverManager class then sends all JDBC API calls to the
loaded driver.
JDBC Driver

This topic defines the Java(TM) Database Connectivity (JDBC) driver types. Driver types are used to
categorize the technology used to connect to the database. A JDBC driver vendor uses these types to
describe how their product operates. Some JDBC  driver types are better suited for some applications than
others.

Types of JDBC drivers

This topic defines the Java(TM) Database Connectivity (JDBC) driver types. Driver types are used to
categorize the technology used to connect to the database. A JDBC driver vendor uses these types to
describe how their product operates. Some JDBC driver types are better suited for some applications than
others.

    There are  four types of JDBC drivers known as:                       

 JDBC-ODBC bridge plus ODBC driver, also called Type 1.
 Native-API, partly Java driver, also called Type 2.
 JDBC-Net, pure Java driver, also called Type 3.
 Native-protocol, pure Java driver, also called Type 4.
Type 1 Driver- the JDBC-ODBC bridge

The JDBC type 1 driver, also known as the JDBC-ODBC bridge is a database driver implementation that
employs the ODBC driver to connect to the database. The driver converts JDBC method calls into ODBC
function calls. The bridge is usually used when there is no pure-Java driver available for a particular
database.

The driver is implemented in the sun.jdbc.odbc.JdbcOdbcDriver class and comes with the Java 2 SDK,
Standard Edition. The driver is platform-dependent as it makes use of ODBC which in turn depends on
native libraries of the operating system. Also, using this driver has got other dependencies such as ODBC
must be installed on the computer having the driver and the database which is being connected to must
support an ODBC driver. Hence the use of this driver is discouraged if the alternative of a pure-Java
driver is available.

Type 1 is the simplest of all but platform specific i.e only to Microsoft platform.

A JDBC-ODBC bridge provides JDBC API access via one or more ODBC drivers. Note that some ODBC
native code and in many  cases native database client code must be loaded on each client machine that
uses this type of driver. Hence, this kind of  driver is generally most appropriate when automatic
installation and downloading of a Java technology application is not important. For information on the
JDBC-ODBC bridge driver provided by Sun, see JDBC-ODBC Bridge Driver.

Type 1 drivers are "bridge" drivers. They use another technology such as Open Database Connectivity
(ODBC) to communicate  with a database. This is an advantage because ODBC drivers exist for many
Relational Database Management System (RDBMS) platforms. The Java Native Interface (JNI) is used to
call ODBC functions from the JDBC driver.

A Type 1 driver needs to have the bridge driver installed and configured before JDBC can be used with it.
This can be a serious drawback for a production application. Type 1 drivers cannot be used in an applet
since applets cannot load native code.

Functions:
1.  Translates query obtained by JDBC into corresponding ODBC query, which is then handled by the
ODBC driver. 
2.  Sun provides a JDBC-ODBC Bridge driver. sun.jdbc.odbc.JdbcOdbcDriver. This driver is native
code and not Java, and is closed
 source.
3. Client -> JDBC Driver -> ODBC Driver -> Database
4. There is some overhead associated with the translation work to go from JDBC to ODBC.
Advantages:

Almost any database for which ODBC driver is installed, can be accessed.

Disadvantages:
1. Performance overhead since the calls have to go through the JDBC overhead bridge to the ODBC
driver, then to the native database connectivity interface.
2. The ODBC driver needs to be installed on the client machine.
3. Considering the client-side software needed, this might not be suitable for applets.
Type 2 Driver - the Native-API Driver

The JDBC type 2 driver, also known as the Native-API driver is a database driver implementation that
uses the client-side libraries of the database. The driver converts JDBC method calls into native calls of
the database API.

The type 2 driver is not written entirely in Java as it interfaces with non-Java code that makes the final
database calls.
The driver is compiled for use with the particular operating system. For platform interoperability, the
Type 4 driver, being
a full-Java implementation, is preferred over this driver.

A native-API partly Java technology-enabled 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.

However the type 2 driver provides more functionality and performance than the type 1 driver as it does
not have the overhead of the additional ODBC function calls.

Type 2 drivers use a native API to communicate with a database system. Java native methods are used to
invoke the API functions that perform database operations. Type 2 drivers are generally faster than Type
1 drivers.

Type 2 drivers need native binary code installed and configured to work. A Type 2 driver also uses the
JNI. You cannot use a Type 2 driver in an applet since applets cannot load native code. A Type 2 JDBC
driver may require some Database Management System (DBMS) networking software to be installed.

The Developer Kit for Java JDBC driver is a Type 2 JDBC driver.

Functions:
1. This type of driver converts JDBC calls into calls to the client API for that database.
2. Client -> JDBC Driver -> Vendor Client DB Library -> Database
Advantage

Better performance than Type 1 since no jdbc to odbc translation is needed.

Disadvantages
1. The vendor client library needs to be installed on the client machine.
2. Cannot be used in internet due the client side software needed.
3. Not all databases give the client side library.
Type 3 driver - the Network-Protocol Driver

The JDBC type 3 driver, also known as the network-protocol driver is a database driver implementation
which makes use of a middle-tier between the calling program and the database. The middle-tier
(application server) converts JDBC calls directly or indirectly into the vendor-specific database protocol.
This differs from the type 4 driver in that the protocol conversion logic resides not at the client, but in the
middle-tier. However, like type 4 drivers, the type 3 driver is written entirely in Java.
The same driver can be used for multiple databases. It depends on the number of databases the
middleware has been configured to support. The type 3 driver is platform-independent as the platform-
related differences are taken care by the middleware. Also, making use of the middleware provides
additional advantages of security and firewall access.
A net-protocol fully Java technology-enabled driver translates JDBC API 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 all of its Java technology-based clients to many different databases. The specific protocol used
depends on the vendor. In general, this is the most flexible JDBC API 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 technology-based drivers to    
their existing database middleware products.
These drivers use a networking protocol and middleware to communicate with a server. The server then
translates the protocol to DBMS function calls specific to DBMS.
Type 3 JDBC drivers are the most flexible JDBC solution because they do not require any native binary
code on the client. A Type 3 driver does not need any client installation.

Functions:
1. Follows a three tier communication approach.
2. Can interface to multiple databases - Not vendor specific.
3. The JDBC Client driver written in java, communicates with a middleware-net-server using a
database independent  protocol, and then this net server translates this request into database
commands for that database.
4. Thus the client driver to middleware communication is database independent.
5. Client -> JDBC Driver -> Middleware-Net Server -> Any Database
Advantages
1. Since the communication between client and the middleware server is database independent, there is
no need for the vendor db library on the client machine. Also the client to middleware need'nt be
changed for a new database.
2. The Middleware Server (Can be a full fledged J2EE Application server) can provide typical
middleware services like caching (connections, query results, and so on), load balancing, logging,
auditing etc..
3. eg. for the above include jdbc driver features in Weblogic.
 4. Can be used in internet since there is no client side software needed.
5. At client side a single driver can handle any database.(It works provided the middlware supports that
database!!)
Disadvantages
1. Requires database-specific coding to be done in the middle tier.
2.  An extra layer added may result in a time-bottleneck. But typically this is overcome by providing
efficient middleware
    services described above.
Type 4 - the Native-Protocol Driver

The JDBC type 4 driver, also known as the native-protocol driver is a database driver implementation that
converts JDBC calls directly into the vendor-specific database protocol.

The type 4 driver is written completely in Java and is hence platform independent. It is installed inside the
Java Virtual Machine of the client. It provides better performance over the type 1 and 2 drivers as it does
not have the overhead of conversion of calls into ODBC or database API calls. Unlike the type 1 and 2
drivers, it does not need associated software to work.

A native-protocol fully Java technology-enabled driver converts JDBC technology calls into the network
protocol 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 for this style of driver. Several database vendors have
these in progress.

As the database protocol is vendor-specific, separate drivers, usually vendor-supplied, need to be used to
connect to the database.

A Type 4 driver uses Java to implement a DBMS vendor networking protocol. Since the protocols are
usually proprietary, DBMS vendors are generally the only companies providing a Type 4 JDBC driver.

Type 4 drivers are all Java drivers. This means that there is no client installation or configuration.
However, a Type 4 driver may not be suitable for some applications if the underlying protocol does not
handle issues such as security and network connectivity well.

The IBM Toolbox for Java JDBC driver is a Type 4 JDBC driver, indicating that the API is a pure Java
networking protocol driver.

Functions
1. Type 4 drivers are entirely written in Java that communicate directly with a vendor's database
through socket connections. No translation or middleware layers, are required, improving
performance.
2. The driver converts JDBC calls into the vendor-specific database protocol so that client applications
can communicate directly with the database server.
3. Completely implemented in Java to achieve platform independence.
4. e.g include the widely used Oracle thin driver - oracle.jdbc.driver. OracleDriver which connect to
jdbc:oracle:thin URL format.
5. Client Machine -> Native protocol JDBC Driver -> Database server
Advantages

These drivers don't translate the requests into db request to ODBC or pass it to client api for the db, nor do
they need a middleware layer for request indirection. Thus the performance is considerably improved.

Disadvantage

At client side, a separate driver is needed for each database.

The JDBC API is the industry standard for database-independent connectivity between
the Java programming language and a wide range of databases. The JDBC APIprovides a call-level API for
SQL-based database access. JDBC technology allows you to use the Java programming language to exploit
"Write Once, Run Anywhere" capabilities for applications that require access to enterprise data.
 
JDBC API Overview

The JDBC API makes it possible to do three things:

 Establish a connection with a database or access any tabular data source

 Send SQL statements
 Process the results

 
JDBC Architecture

The JDBC API contains two major sets of interfaces: the first is the JDBC API for application writers, and the
second is the lower-level JDBC driver API for driver writers. JDBC technology drivers fit into one of four
categories. Applications and applets can access databases via the JDBC API using pure Java JDBC
technology-based drivers, as shown in this figure: 

 Left side, Type 4: Direct-to-Database Pure Java Driver

This style of driver converts JDBC calls into the network protocol used directly by DBMSs, allowing a direct
call from the client machine to the DBMS server and providing a practical solution for intranet access. 

Right side, Type 3: Pure Java Driver for Database Middleware

This style of driver translates JDBC calls into the middleware vendor's protocol, which is then translated to
a DBMS protocol by a middleware server. The middleware provides connectivity to many different
databases. 

The graphic below illustrates JDBC connectivity using ODBC drivers and existing database client libraries. 

 
Left side, Type 1: JDBC-ODBC Bridge plus ODBC Driver
This combination provides JDBC access via ODBC drivers. ODBC binary code -- and in many cases, database
client code -- must be loaded on each client machine that uses a JDBC-ODBC Bridge. Sun provides a JDBC-
ODBC Bridge driver, which is appropriate for experimental use and for situations in which no other driver is
available. 

Right side, Type 2: A native API partly Java technology-enabled driver

This type 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 driverrequires that some binary code be loaded on
each client machine. 

For comparison of driver types, please see the article published in Computerworld.

 
Partnering for Progress

Sun worked with an array of companies in the industry to create and rapidly establish the JDBC API as the
industry-standard, open interface for Java applications to access databases.
 
Industry Momentum

Leading database, middleware and tool vendors have been building support for JDBC technology into many
new products. This ensures that customers can build portableJava applications while choosing from a wide
range of competitive products for the solution best suited to their needs. See the Industry Support page for
a list of companies that are shipping products with support for JDBC technology.
 
Advantages of JDBC Technology

Leverage Existing Enterprise Data

With JDBC technology, businesses are not locked in any proprietary architecture, and can continue to use
their installed databases and access information easily -- even if it is stored on different database
management systems. 

Simplified Enterprise Development

The combination of the Java API and the JDBC API makes application development easy and economical.
JDBC hides the complexity of many data access tasks, doing most of the "heavy lifting"for the programmer
behind the scenes. The JDBC API is simple to learn, easy to deploy, and inexpensive to maintain. 

Zero Configuration for Network Computers

With the JDBC API, no configuration is required on the client side. With a driver written in
the Java programming language, all the information needed to make a connection is completely defined by
the JDBC URL or by a DataSource object registered with a JavaNaming and Directory Interface (JNDI)
naming service. Zero configuration for clients supports the network computing paradigm and centralizes
software maintenance.
 
Key Features

Full Access to Metadata

The JDBC API provides metadata access that enables the development of sophisticated applications that
need to understand the underlying facilities and capabilities of a specific database connection. 

No Installation
A pure JDBC technology-based driver does not require special installation; it is automatically downloaded
as part of the applet that makes the JDBC calls. 
Database Connection Identified by URL
JDBC technology exploits the advantages of Internet-standard URLs to identify database connections. The
JDBC API includes an even better way to identify and connect to a data source, using a DataSource object,
that makes code even more portable and easier to maintain. 

In addition to this important advantage, DataSource objects can provide connection pooling and
distributed transactions, essential for enterprise database computing. This functionality is provided
transparently to the programmer. 

Included in the Java Platform
As a core part of the Java 2 Platform, the JDBC API is available anywhere that the platform is. This means
that your applications can truly write database applications once and access data anywhere. The
JDBC API is included in both the Java 2 Platform, Standard Edition (J2SE) and the Java 2 Platform,
Enterprise Edition (J2EE), providing server-side functionality for industrial strength scalability. 

An example of a J2EE based architecture that includes a JDBC implementation: 

Requirements

 Software: The Java 2 Platform (either the Java 2 SDK, Standard Edition, or theJava 2 SDK, Enterprise
Edition), an SQL database, and a JDBC technology-baseddriver for that database.
 Hardware: Same as for the Java 2 Platform.

Introduction to the JDBC 

       
Introduction

This article introduce you with JDBC and shows you how to our search engine with database. 
What is JDBC?
Java Database Connectivity or JDBC for short is set of Java API's that enables the developers to create platform
and database independent applications in java. The biggest advantage of programming in Java is its platform
independence. An application written to access the MS Access database on Win 95/Win NT platform can work on
Linux against Oracle database, only by changing the name of driver, provided none of the database calls it makes are
vendor specific.

What are JDBC Drivers?

JDBC Drivers are set of classes that enables the Java application to communicate with databases. Java.sql that
ships with JDK contains various classes for using relational databases. But these classes do not provide any
implementation, only the behaviors are defined. The actual implementations are done in third-party drivers. Third party
vendors implements the java.sql.Driver interface in their database driver. A list of currently available JDBC drivers
can be found at http://java.sun.com/products/jdbc/jdbc.drivers.html

JDBC Drivers Types

Sun has defined four JDBC driver types. These are:

1. Type 1: JDBC-ODBC Bridge Driver
The first type of JDBC driver is JDBC-ODBC Bridge which provide JDBC access to any ODBC complaint
databases through ODBC drivers. Sun's JDBC-ODBC bridge is example of type 1 driver.
2. Type 2: Native -API Partly - Java Driver
Type 2 drivers are developed using native code libraries, which were originally designed for accessing the
database through C/C++. Here a thin code of Java wrap around the native code and converts JDBC
commands to DBMS-specific native calls.
3. Type 3: JDBC-Net Pure Java Driver
Type 3 drivers are a three-tier solutions. This type of driver communicates to a middleware component which
in turn connects to database and provide database connectivity.
4. Type 4: Native-Protocol Pure Java Driver
Type 4 drivers are entirely written in Java that communicate directly with vendor's database through socket
connection. Here no translation or middleware layer, are required which improves performance tremendously.

JDBC Fundamentals
 The java program can access the database using JDBC. the seven steps that are needed to access database are
1. Import the package
2. Load and register the driver
3. Establish the Connection
4. Create a Statement object
5. Execute a query
6. Process the result
7. Close the connection
Step1: Import java.sql package
          The important classes and interfaces of JDBC are available in the java.sql package . So inorder to access
the databases it must be imported in our application.
 import java.sql.*;
Step 2: Loading and registering the driver
           In order to access database it must have the particular driver for that database. In Java we have to inform
the Drive Manager about the required driver this is done with the help of the method forName(String str) available
in  the class named Class
Class.forName(“path with driver name”);
          In an application the user can register more than one driver. The statement used to load and register the
JDBC-ODBC bridge driver is
                    Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
Step 3: Establishing the connection
           Establishing connection means making a connection to access RDBMS through JDBC driver. The connection
can be established with the help of getConnection() method available in DriverManager class. The established
connection is then set to new connection object.
Connection cn=DriverManager.getConnetion (“jdbc:odbc:DSN”, ”administrator”, “password”);
            Where DSN-Data Source Name
   When the statement is executed the connection is set to the Connection object cn. For example to connect the
ODBC data source named mydata via JDBC –ODBC bridge the statement is
          Connection cn= DriverManager.getConnection (“jdbc:odbc:mydata”);
Step 4: Creating the statement
        A Statement object is used for executing a static SQL statement and obtaining the results produced by it.
The createStatement() method is used to create statements using the established connection.
The methods used for creating the statements are
 Statement createStatement()
Returns a new Statement object.Used for general queries
 PreparedStatement prepareStatement(String sql)
Returns a new PreparedStatement object.For a statement called multiple times with different values
(precompiled to reduce parsing time)
 CallableStatement prepareCall(String sql)
Returns a new CallableStatement object for stored procedures
Step 5: Executing the Query
          After making connection to the database we are ready to execute the SQL statements. The  various
methods available in Statement object to execute the query are
 ResultSet executeQuery(String)
           Execute a SQL statement that returns a single ResultSet. After executing the SQL statements the
requested data is stored in the ResultSet object.
 int executeUpdate(String)
          Execute a SQL INSERT, UPDATE or DELETE statement. Returns the number of rows changed.
 boolean execute(String)
           Execute a SQL statement that may return multiple results.
Step 6: Retrieving the result.
          A ResultSet provides access to a table of data generated by executing a Statement.Only one ResultSet per
Statement can be open at once.The table rows are retrieved in sequence. A ResultSet maintains a cursor pointing
to its current row of data. The 'next' method moves the cursor to the next row.
Methods:
 public boolean first()
Moves the cursor to the first row in this ResultSet object.
 public boolean last()
Moves the cursor to the last row in this ResultSet object.
 public boolean next()
Moves the cursor down one row from its current position.
The methods used to retrieve the values from the current row
 Type getType(int columnIndex)
Returns the given field as the given type. Fields indexed starting at 1 (not 0)
 Type getType(String columnName)
Returns the data at the specified column
In the above methods the Type should be replaced by the valid datatypes such as Boolean, String, Int,
Long, Float etc as getString(Column name), getInt(column index) etc.
Step 7: Closing the connection and statement
          When the client request is completed we have to close the created objects of Connection and Statement
using close() method.
st.close();
cn.close();