import java.sql.*; The star ( * ) indicates that all of the classes in the package java.sql are to be imported.

1. Loading a database driver,

In this step of the jdbc connection process, we load the driver class by calling Class.forName() with the Driver class name as an argument. Once loaded, the Driver class creates an instance of itself. A client can connect to Database Server through JDBC Driver. Since most of the Database servers support ODBC driver therefore JDBC-ODBC Bridge driver is commonly used.
The return type of the Class.forName (String ClassName) method is “Class”. Class is a class in
java.lang package.

try {
	Class.forName(”sun.jdbc.odbc.JdbcOdbcDriver”);
       //Or any other driver
}
catch(Exception x){
	System.out.println( “Unable to load
       the driver class!” );
}

2. Creating a oracle jdbc Connection

JDBC URL Syntax::    jdbc: <subprotocol>: <subname>

JDBC URL Example:: jdbc: <subprotocol>: <subname>•Each driver has its own subprotocol
•Each subprotocol has its own syntax for the source. We’re using the jdbc odbc subprotocol, so the DriverManager knows to use the sun.jdbc.odbc.JdbcOdbcDriver.

try{
 Connection dbConnection=DriverManager.
 getConnection(url,”loginName”,”Password”)
}
catch( SQLException x ){
	System.out.println( “Couldn’t get connection!” );
}

3. Creating a jdbc Statement object,

Once a connection is obtained we can interact with the database. Connection interface defines methods for interacting with the database via the established connection. To execute SQL statements, you need to instantiate a Statement object from your connection object by using the createStatement() method.

Statement statement = dbConnection.createStatement();

A statement object is used to send and execute SQL statements to a database.

Three kinds of Statements

Statement: Execute simple sql queries without parameters.
Statement createStatement()
Creates an SQL Statement object.

Prepared Statement: Execute precompiled sql queries with or without parameters.
PreparedStatement prepareStatement(String sql)
returns a new PreparedStatement object. PreparedStatement objects are precompiled
SQL statements.

Callable Statement: Execute a call to a database stored procedure.
CallableStatement prepareCall(String sql)
returns a new CallableStatement object. CallableStatement objects are SQL stored procedure call statements.

4. Executing a SQL statement with the Statement object, and returning a jdbc resultSet.

Statement interface defines methods that are used to interact with database via the execution of SQL statements. The Statement class has three methods for executing statements:
executeQuery(), executeUpdate(), and execute(). For a SELECT statement, the method to use is executeQuery . For statements that create or modify tables, the method to use is executeUpdate. Note: Statements that create a table, alter a table, or drop a table are all examples of DDL
statements and are executed with the method executeUpdate. execute() executes an SQL
statement that is written as String object.

ResultSet provides access to a table of data generated by executing a Statement. The table rows are retrieved in sequence. A ResultSet maintains a cursor pointing to its current row of data. The next() method is used to successively step through the rows of the tabular results.

ResultSetMetaData Interface holds information on the types and properties of the columns in a ResultSet. It is constructed from the Connection object.

	static Connection con = null;
	public static void main(String[] args) throws Exception {
	    Connection con = getOracleJDBCConnection();
	    if(con!= null){
	       System.out.println(”Got Connection.”);
	       DatabaseMetaData meta = con.getMetaData();
	       System.out.println(”Driver Name : “+
               meta.getDriverName());
	       System.out.println(”Driver Version :
               “+meta.getDriverVersion());

	    }else{
		    System.out.println(”Could not Get Connection”);
	    }
	}

	public static Connection getOracleJDBCConnection(){

		try {
			Class.forName(”sun.jdbc.odbc.JdbcOdbcDriver”);	

		} catch(java.lang.ClassNotFoundException e) {
			System.err.print(”ClassNotFoundException: “);
			System.err.println(e.getMessage());
		}

		try {
		   con = DriverManager.getConnection(url, userid,
                   password);
		} catch(SQLException ex) {
			System.err.println(”SQLException: ” +
                        ex.getMessage());
		}

		return con;
	}

}

In order to connect to a database, you need to perform some initialization first. Your JDBC driver has to be loaded by the Java Virtual Machine classloader, and your application needs to check to see that the driver was successfully loaded. We’ll be using the ODBC bridge driver, but if your database vendor supplies a JDBC driver, feel free to use it instead.

// Attempt to load database driver
try
{
	// Load Sun's jdbc-odbc driver
	Class.forName("sun.jdbc.odbc.JdbcOdbcDriver").newInstance();
}
catch (ClassNotFoundException cnfe) // driver not found
{
	System.err.println ("Unable to load database driver");
	System.err.println ("Details : " + cnfe);
	System.exit(0);
}

We try to load the JdbcOdbcDriver class, and then catch the ClassNotFoundException if it is thrown. This is important, because the application might be run on a non-Sun virtual machine that doesn’t include the ODBC bridge, such as Microsoft’s JVM. If this occurs, the driver won’t be installed, and our application should exit gracefully.

Once our driver is loaded, we can connect to the database. We’ll connect via the driver manager class, which selects the appropriate driver for the database we specify. In this case, we’ll only be using an ODBC database, but in more complex applications, we might wish to use different drivers to connect to multiple databases. We identify our database through a URL. No, we’re not doing anything on the web in this example – a URL just helps to identify our database.

A JDBC URL starts with “jdbc:” This indicates the protocol (JDBC). We also specify our database in the URL. As an example, here’s the URL for an ODBC datasource called ‘demo’. Our final URL looks like this :

jdbc:odbc:demo

To connect to the database, we create a string representation of the database. We take the name of the datasource from the command line, and attempt to connect as user “dba”, whose password is “sql”.

// Create a URL that identifies database
String url = "jdbc:odbc:" + args[0];

// Now attempt to create a database connection
Connection db_connection =
	DriverManager.getConnection (url, "dba", "sql");

As you can see, connecting to a database doesn’t take much code.

Executing database queries

In JDBC, we use a statement object to execute queries. A statement object is responsible for sending the SQL statement, and returning a set of results, if needed, from the query. Statement objects support two main types of statements – an update statement that is normally used for operations which don’t generate a response, and a query statement that returns data.

// Create a statement to send SQL
Statement db_statement = db_connection.createStatement();

Once you have an instance of a statement object, you can call its executeUpdate and executeQuery methods. To illustrate the executeUpdate command, we’ll create a table that stores information about employees. We’ll keep things simple and limit it to name and employee ID.

// Create a simple table, which stores an employee ID and name
db_statement.executeUpdate
   ("create table employee { int id, char(50) name };");

// Insert an employee, so the table contains data
db_statement.executeUpdate
   ("insert into employee values (1, 'John Doe');");

// Commit changes
db_connection.commit();

Now that there’s data in the table, we can execute queries. The response to a query will be returned by the executeQuery method as a ResultSet object. ResultSet objects store the last response to a query for a given statement object. Instances of ResultSet have methods following the pattern of getXX where XX is the name of a data type. Such data types include numbers (bytes, ints, shorts, longs, doubles, big-decimals), as well as strings, booleans, timestamps and binary data.

// Execute query
ResultSet result = db_statement.executeQuery
	("select * from employee");

// While more rows exist, print them
while (result.next() )
{
	// Use the getInt method to obtain emp. id
	System.out.println ("ID : " + result.getInt("ID"));

	// Use the getString method to obtain emp. name
	System.out.println ("Name : " + result.getString("Name"));
	System.out.println ();
}

Putting it all together

To show you just how JDBC applications work, I’ve put together a simple demonstration, that allows users to insert new employees into the system, and to obtain a list. The demonstration uses ODBC to connect to an Access database, which can be downloaded along with the source code.

Running the sample application is quite straightforward. First, you’ll need to create an ODBC datasource for the access database. Next, using JDK1.1 or higher, run the JDBCDemo application, and pass the datasource name as a parameter.

	java JDBCDEMO demo

The demonstration application presents you with a menu, containing three options. Choosing the first operation allows you to add a new employee, using the SQL insert statement. Choosing the second option displays all employees in the system, using the SQL select statement. Finally, the third option closes the database connection and exits.

Menu

1. Add new employee
2. Show all employees
3. Exit
Choice : 1
ID : 3
Name : Bill Gates

Menu

1. Add new employee
2. Show all employees
3. Exit
Choice : 2
ID : 1
Name : David Reilly

ID : 2
Name : John Doe

ID : 3
Name : Bill Gates

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.

1. MERANT DataDirect provides JDBC driver technology through n-tier, server-based data connectivity and high-performance, DBMS-independent JDBC middleware.
   
2. MM MySQL JDBC DRIVERS – 100% pure java driver for MySQL and is distributed under the GNU LGPL.
   
3. The mSQL JDBC Driver-A pure-java JDBC driver for mSQL was created and is being maintained by George Reese from The Center for Imaginary Environments.