5th Unit Java

JAVA & J2EE 10IS753

Dept. of ISE, MIT-Mysore

UNIT-5 JDBC

J2SE AND J2EE :

Java 2 standard edition is the original edition of java and it consist of

application programming interfaces (API) needed to build java application

or applet.

J2EE: java 2 enterprise edition is the enhanced version of J2SE, it has the API

to build applications for a multi- tier architecture.

CONCEPT OF JDBC:

JDBC driver to be a translator that converted low level proprietary DBMS

messages to low level messages understood by the JDBC API and vice

versa.

The high level data objects defined in the JDBC API to write a routine

that interacted with the DBMS.

JAVA data objects convert the routine into low-level messages that

conform to the JDBC driver specification and send them to the JDBC

driver. The JDBC driver translates the routine into low-level messages

that are understood and processed by the DBMS.

JDBC driver open a connection between the DBMS and the J2EE

component.

Translate low-level equivalents of SQL statements sent by the J2EE

component into messages that can be processed by the DBMS.

Return data that conforms to the JDBC specification to the JDBC driver.

Return information such as error messages that conforms to the JDBC

specification to the JDBC driver.

Provide transaction management routines that conform to the JDBC

specification.

Close the connection between the DBMS and the J2EE component.

JAVA & J2EE 10IS753


JAVA DATABASE CONNECTIVITY:

Whenever the java needs to connect to the database first it should obtain

the driver.

Java is a frontend tool.

Database is a backend tool.

The drivers are database, image, picture, sound drivers etc

These drivers are available in a class called "DriverManager".

The database driver is "sun.Jdbc.Odbc.JdbcOdbcdriver" . This is in the

form of "dll" (dynamic link library).

Once the driver is obtained then java can connect to the database.

Once the connection is established then java can issue “SQL"

statements.

These "SQLs" are insertion, deletion, updation, extraction etc.

If the SQL is of extraction then the matched records are retrieved from

the

"ResultSet”. It is an interface.

Then from the "ResultSet" records are retrieved and displayed.

If the SQL is of insertion, deletion and updation then “ResultSet" is not

required.

Data source name (DSN): It points exactly to the particular database

name.

Properties of JDBC Drivers:-

Open a connection between the DBMS and J2EE component.

Translate low-level equivalents of SQL statements sent by the J2EE component

into messages that can be processed by the DBMS.

Return data that conforms to the DBMS specification to the JDBC driver.

Return information such as error messages that conforms to the JDBC

specification to the JDBC driver.

Provide transaction management routines that conform to the JDBC

specification.

Close the connection between the DBMS and the J2EE component.

JAVA & J2EE 10IS753


JDBC DRIVER TYPES

TYEP1 JDBC-ODBC Bridge

TYPE2 JAVA / NATIVE CODE DRIVER

TYPE 3 JDBC DRIVER

TYPE4 Native-Protocol pure Java Driver

TYPE1 JDBC-ODBC BRIDGE:

It can also be called as JDBC-to-ODBC driver. It is used to translate

DBMS calls between the JDBC specification and the ODBC specification.

This driver receives the messages from a J2EE component that conforms

to the JDBC specifications.

These messages are translated by this driver into the ODBC message

format which in turn translated into the message format understood by

the DBMS.

In a type1 driver, a JDBC Bridge is used to access ODBC drivers

installed on each client machine. Using ODBC requires configuring on

system a data source name that represents the target database.

It is a java soft bridge product that provides JDBC access via ODBC

drivers.

TYPE 2 JAVA / NATIVE CODE DRIVER

This driver uses java classes to generate platform - specific code, that

code is understood by a specific DBMS.

The disadvantage of this using this driver is the loss of some portability

of code.

JDBC API calls are converted into native C/C++ API calls which are

unique to the database.

TYPE3 JDBC DRIVER

It is also referred to as the java protocol. It is the most commonly used

JDBC driver. This driver converts SQL queries into JDBC formatted

statements.

JAVA & J2EE 10IS753


This again translated into the format required by the DBMS.

Three tier approach is used to accessing databases. The JDBC clients

use standard network sockets to communicate with a middleware

application server.

The socket information is then translated by the middleware application

server into the call format required by the DBMS, and forwarded to the

database server.

TYPE4 JDBC DRIVER

It is also known as database protocol. This is similar to type3 JDBC

driver except SQL queries are translated into the format required by the

DBMS.

It is a pure java based driver that communicates directly with database

through socket connection.

JDBC PACKAGES:

The JDBC API contained in two packages.

The first package is called java.sql and contains core java data objects

of the JDBC API.

These include java data objects that provide basics for connecting to the

DBMS and interacting with data stored in the DBMS.

The other package contains the JDBC API is the javax.sql. It extends

java.sql and it is in J2EE.

Java data objects that interact with the Java Naming and Directory

Interface (JNDI). It manages connection pooling.

OVERVIEW OF JDBC PROCESS:

Loading the JDBC driver

Connecting to the DBMS

Creating and executing a statement

Processing data returned by the DBMS

Terminating the connection with the DBMS

JAVA & J2EE 10IS753


LOADING THE JDBC DRIVER:

The JDBC driver must be loaded before the J2EE component can connect to

the DBMS.

class.forName("sun.JDBC.odbc.JDBCOdbcDriver")

class.forName() method is used to load the JDBC driver.

Connecting to the DBMS:

Once the driver is loaded, the J2EE component must connect to the

DBMS using DriverManager.getConnection() METHOD.

DriverManager is the highest class in the java.sql hierarchy and is

responsible for managing driver information.

This method returns a connection interface that is used throughout the

process to reference the database.

Create and execute a SQL statement:

After loading the driver and connection is established with a particular

database managed by the DBMS, is to send a SQL query to the DBMS for

processing. SQL query consist of SQL commands.

createStatement() method is used to create a statement object.

The statement object is then used to execute a query and return a

ResultSet object that contains the response from the DBMS.

Processing the data returned by the DBMS:

ResultSet object is assigned the results received from the DBMS after the

query is processed. ResultSet object consists of methods used to interact

with data that is returned by the DBMS to J2EE component.

The first time that the next() method of the ResultSet is called , then the

pointer is positioned at the first row in the ResultSet.

The getString() method of the ResultSet object is copy the value of a

specified column in the current row of the resultset to a string object.

Terminate the connection to the DBMS:

The connection to the DBMS is terminated by using the close() method of the

connection object once the J2EE component is finished accessing the DBMS.

JAVA & J2EE 10IS753


DATABASE CONNECTION:

JDBC driver is loaded and registered with the DriverManager.

J2EE component connects with the JDBC driver that is associated with

the DBMS.

The purpose of the loading and registering the JDBC driver is to bring the

JDBC driver into the Java Virtual Machine (JVM).

class.forName() method is used to load the JDBC driver.

JDBC/ODBC Bridge is the driver that is being loaded.

THE CONNECTION

The URL consists of three parts. These are

jdbc which indicates the JDBC protocol is to be used to read the URL.

<sub protocol> which is the JDBC driver name.

<subname> which is the name of the database.

The types of connection methods:-

After the JDBC driver is successfully loaded and registered the J2EE

component must connect to the database.

The connection to the database is established by using one of the three

getconnection() method of DriverManager object.

A connection object is returned by the getConnection() method if access

is generated; otherwise getConnecton method throws SQLException.

Sometimes the DBMS grants access to a database to anyone. In this case

the J2EE component uses the getConnection(String url) method.

One parameter is passed to the method because DBMS only needs the

database identified.

String url=”jdbc:odbc:customerInformation”;

Statement DataRequest;

Connection Db;

JAVA & J2EE 10IS753


try

{

class.forName(“sun.jdbc.odbc.JDBCODBCDriver”);

Db=DriverManager.getConnection(url);

}

catch(ClassNotFoundException error)

{

System.err.println(“unable to load JDBC/ODBC bridge”,er+erroe);

System.exit(1);

}

catch (SQLException error)

{

System.err.println(“cannot connect to the database:”,+error);

System.exit(2);

}

Other databases limit access to the authorized users & require the J2EE

to supply a userid & password with the request to access the database.

In this case, the J2EE component uses the getConnection (string url,

string userid, string password) method.

String url=”jdbc:odbc:customerInformation”;


Connection Db;

try

{

class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);

Db=DriverManagergetConnection(url, userid, password);

}

catch (ClassNotFoundException error)

{

System.err.println(“unable to load JDBC/ODBC bridge”,er+erroe);

System.exit(1);

JAVA & J2EE 10IS753


}

catch (SQLException error)

{

System.err.println(“cannot connect to the database:”,+error);

System.exit(2);

}

There might be chances where a DBMS requires information besides the

userid & password before the DBMS grants access to the database. This

additional information is called properties & must be associated with

properties object.Properties used to access a database are stored in a text

file.

The J2EE component uses a FileInputStream object to opoen the file &

the uses the properties object load () method to copy the properties into

properties object.

Associating the JDBC / ODBC bridge with the database :

This is creation of "data source name " (dsn).

Start----settings---controlpanel---administrative tools---- data sources

odbc-----user dsn----add button---select the driver ----next-----enter the

data source name ex: db25---------click next button and click finish

button.

Select "select button" select the database name and click ok button.

Connection pool:-

A connection pool is a collection of database connections that are opened once

and loaded into memory so these connections can be reused without having to

reconnect to the DBMS.

There are two types of connections made to the database. The first is the

physical connection, which is made by the application server using

PooledConnection objects. PooledConnection objects are cached and reused.

The other type of connection is the logical connection. A logical connection is

made by a client calling the DataSource.getConnection() method, which

JAVA & J2EE 10IS753


connects to a PooledConnection objects that already has a physical connection

to the database.

A connection pool is accessible by using the Java Naming and directory

Interface(JNDI).

JNDI provides a uniform way to find and access naming and directory services

independent of any specific naming or directory service.

Context ctext = new InitialContext();

DataSource pool = (DataSource)

ctext.lookup(“java:/cmp/env/jdbc/pool”);

Connection Db = pool.getConnection();

//place code to interact with the database here

Db.close();

Table: - Connecting to a database using a pool connection.

First J2EE component must obtain a handle to the JNDI context, which is

shown in the first statement in the above code segment.

Next, the JNDI lookup() method is called and is passed the name of the

connection pool, which returns the DataSource object called pool.

The getConnection() method of the DataSource object is then called. The

getConnection() returns the logical connection to the database, which is used by

the J2EE component to access the database.

The close() method of the DataSource object is called once when the J2EE

component is finished accessing the database. The close() method closes the

logical connection to the database and not the physical database connection.

This means that same physical connection can be used by the next J2EE

component that needs access to the database.

JAVA & J2EE 10IS753


STATEMENT OBJECTS:-

There are 3 types of statement objects used to execute the query these

objects are

1. Statement Object which execute a query immediately.

2. PreparedStatement object which is used to execute a compiled

query.

3. CallableStatement object which is used to execute store

procedures.

THE STATEMENT OBJECT

The statements object is used whenever a J2EE component needs to

immediately execute a query without first having the query compiled.

The statement object contains the execute Query () method.

The executeQuery () method returns one ResultSet object that contains

rows, columns and metadata that represent data requested by query.

The ResultSet object also contains methods that are used to manipulate

data in the ResultSet.

The executeUpdate() method is used to execute queries that contain

UPDATE and DELETE SQL statements which changes values in a row

and removes a row respectively.

The executeUpdate() method returns an integer indicating the number

Of rows that were updated by the query.

The executeUpdate() is used to INSERT,UPDATE,DELETE and DDL

statements.

import java.SQL.*;

class JDBC60

{

public static void main(String v[])throws SQLException

{


JAVA & J2EE 10IS753


ResultSet Results;

Connection Db=null;

try

{

Class.forName("sun.JDBC.odbc.JDBCOdbcDriver");

Db = DriverManager.getConnection("JDBC:odbc:db100");

}


{

System.err.println("unable to load the JDBC/odbc bridge "+error);

System.exit(1);

}

catch(SQLException error)

{

System.err.println("cannot connect to the database"+error);

System.exit(2);

}

try

{

String query="select * from emp";

DataRequest=Db.createStatement();

Results=DataRequest.executeQuery(query);

while(Results.next())

{

System.out.println("empno="+Results.getString("empno"));

System.out.println("empname="+Results.getString("empname"));

System.out.println("empsal="+Results.getString("empsal"));

}

DataRequest.close();

}


{

System.err.println("SQL error "+ error);

JAVA & J2EE 10IS753


System.exit(3);

}

Db.close();

}

}

PreparedStatement OBJECT:

A SQL query can be precompiled and executed by using the

preparedStatement object. A question mark is used as a placeholder

for a value that is inserted into the query after the query is compiled.

It is this value that changes each time query is executed.

EX: String query= "select * from customer where custnumber = ? ";

It is used to use the SQL statements many times. It accepts input

parameters at runtime.

import java.SQL.*;

class JDBC62

{


{


ResultSet Results;

Connection Db=null;

try

{



}


{


System.exit(1);

}


JAVA & J2EE 10IS753


{


System.exit(2);

}

try

{

String query="select * from emp where empno=?";

PreparedStatement pstatement=Db.preparedStatement(query);

//pstatement.setString(1,"123");

Results=pstatement.executeQuery();

pstatement.close();

}


{


System.exit(3);

}

Db.close();

}

}

Callable statement:

This object is used to call a stored procedure from within a J2EE

object. A stored procedure is a block of code and it identified by a

unique name.

The stored procedure is executed by invoking the name of the stored

procedure.

This object uses three types of parameters when calling a stored

procedure.

These parameters are IN, OUT and INOUT.

IN: data needs to be passed as a parameter to the stored procedure.

OUT: contains the value returned by the stored procedures.

INOUT: It is single parameter that is used to both pass information to

JAVA & J2EE 10IS753


the stored procedure and retrieve information from a stored

procedure.

It is used to access database stored procedures. This interface can

also accept runtime input parameters.

import java.SQL.*;

class JDBC63

{


{


ResultSet Results;

Connection Db=null;

String lastordernumber;

try

{



}


{


System.exit(1);

}


{


System.exit(2);

}

try

{

String query="{ CALL lastordernumber(?))";

CallableStatement cstatement=Db.prepareCall(query);

cstatement.registerOutParameter(1,Types.VARCHAR);

JAVA & J2EE 10IS753


cstatement.execute();

lastordernumber=cstatement.getString(1);

cstatement.close();

}


{


System.exit(3);

}

Db.close();

}

}

RESULTSET

Data in a ResultSet is logically organized into a virtual table consisting of

rows & columns.

ResultSet object contains metadata such as columns names, column size

& column data type.

The ResultSet uses a virtual cursor to point to a row of the virtual table.

The next() method of the ResultSet object return a Boolean value true if

the row contained data otherwise a Boolean value false is returned

indicating that no more rows present in the ResultSet.

The next() method of the ResultSet is called to move the virtual pointer to

the first row in the ResultSet.

If the is a data in that row the next() returns a true.

getString() method is called to retrieve values in the 1st & 2nd columns of

the ResultSet.

READING THE RESULTSET:-

String url=”jdbc:odbc:customerinformation”;

String userid=”jim”;

String passwd=”keogh”;

String printrow;

JAVA & J2EE 10IS753


String fname;

String DataRequest;

ResultSet results;

Connection Db;

string query=”select fname, lname from customers”;

try

{

class.foName(“sun.jdbc.odbc.JdbcOdbcDriver”);

Db=DriverManager.getconnection(url,userid,passwd);

DataRequest=Db.createstatement();


}

boolean Records=recults.next();

if(!Records)

{

System.out.println(“no data returned”);

System.exit(4);

}

do

{

fname = Results.getstring(1);

lname = result.getstring(2);

printrow = fname + ” “ +lname”;

System.out.println(printrow);

}while(Results.next());


}

Catch(SQLException err)

{

System.err.println(“Data display error”+error);

System.exit(5);

}

Catch(classNotFoundException error)

{

System.err.println(unable to load JDBC/ODBC bridge”+erroe);

System.exit(1);

}

}

JAVA & J2EE 10IS753


UPDATABLE RESULTSET:-

There are 3 ways in which a ResultSet can be changed.

These are updating values in z row deleting a row, and inserting a new

row.

UPDATE RESULTSET:-

Once the executeQuery () method of the statement object returns a

ResultSet the updatexxx () method is used to change the values of a

columns in the current row of the ResultSet.

The xxx in the updatexxx() method is replaced with the data type of the

column that in to be updated.

Updatexxx() method requires two parameters the first is either the

number or name of the column of the ResultSet that is being updated &

second parameter in the value that will replace the value in the column

of the ResultSet.

The value in a column of the result can be replaced with a NULL value by

using updateNULL () method.

The updateNULL () method requires one parameter which is the number

of the column in the current ResultSet.

The updateRow () method is called after all the updatexxx() method are

called.

updateRow() method changes the valued in columns of the current row of

the ResultSet.




String printrow;

String fname;

String DataRequest;

ResultSet Results;

Connection Db;

JAVA & J2EE 10IS753


string query=”select fname, lname from customers where

fname=’mary’ and lastname=smith”;

try

{

class.foName(“sun.jdbc.odbc.JDBCODBCDriver”);

Db=DriverManager.getconnection(url, userid, passwd);

DataRequest=Db.createstatement(ResultSet.CONCUR_UPDATABLE);


}


if(!Records)

{


System.exit(4);

}

try

{

Results.updateString(“ lname“,”smith”);

Results.updateRow();


}


{


System.exit(5);

}


{


System.exit(1);

}

}

JAVA & J2EE 10IS753


Delete row in the ResultSet:-

The deleteRow() method is used to remove a row from a ResultSet.

The deleteRow() is passed an integer that contains the number of the row to be

deleted.

Results.deleteRow(0); //deletes 0th row in the resultset

Insert row in the ResultSet:-

Inserting a row into the resultset is accomplished using basically the same

technique as is used to update the resultset.

The updateXXX() method requires two parameters. The first parameter is either

the name of the column or the number of the column of the resultset.

The second parameter is the new value that will be placed in the column of the

resultset.

The datatype of the column replaces the xxx in the method name.

The insertRow() method is called after the updateXXX() methods, which causes

a new row to be inserted into the ResultSet.




String printrow;

String fname;

String DataRequest;

ResultSet Results;

Connection Db;


try

{



DataRequest=Db.createstatement(CONCUR_UPDATABLE);


}

JAVA & J2EE 10IS753



if(!Records)

{


System.exit(4);

}

try

{

Results.updateString(1,”Tom”);

Results.updateString(2,”smith”);

Results.insertRow();


}


{


System.exit(5);

}


{


System.exit(1);

}

JAVA & J2EE 10IS753


SCROLLABLE RESULTSET:-

There are 6 methods of the ResultSet object that are used to position the

virtual cursor. They are first(), last(), previous(), absolute(), relative(), and

getRow().

The first() method moves the virtual cursor to the first row in the

ResultSet.

last() method moves the virtual cursor to the last row in the ResultSet.

Previous() method moves the virtual cursor to the previous row.

The absolute() method positions the virtual cursor at the row number

specified by the integer passed as a parameter to the absolute() method.

The relative() method moves the virtual cursor specified number of rows

contained in the parameter.

The parameter is a positive or negative integer where the sign represents

the direction the virtual cursor is moved.

For example, -4 moves the virtual cursor back four rows from the current

row, likewise, 5 moves the virtual cursor forwards 5 row’s from the

current row.

getRow() method returns an integer that represents the current row in

the ResultSet.

The statement object that is created using the createStatement() of the

connection object must be set up to handle a scrollable resultset by

passing the createStatement() method one of three constants.

These constants are TYPE_FORWARD_ONLY,

TYPE_SCROLL_INSENSITIVE, and TYPE_SCROLL_SENSITIVE.

The TYPE_FORWARD_ONLY constant restricts the virtual cursor to

downward movement, which is default setting,

The TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE

constants permit the virtual cursor to move in both directions.



JAVA & J2EE 10IS753



String printrow;

String fname;

String DataRequest;

ResultSet Results;

Connection Db;


try

{



DataRequest=Db.createstatement(TYPE_SCROLL_INSENSITIVE);


}


if(!Records)

{


System.exit(4);

}

do

{

Results.first();

Results.last();

Results.previous();

Results.absolute(10);

Results.relative(-2);

Results.relative(2);

fname = Results.getstring(1);

lname = Result.getstring(2);

printrow = fname + ” “ +lname”;

System.out.println(printrow);

}while(Results.next());


}


{


JAVA & J2EE 10IS753


System.exit(5);

}


{


System.exit(1);

}

METADATA: - Metadata is the data about data.

In databases, metadata describes the structural components of tables

and their elements.

J2EE component can access metadata by using the DatabaseMetadata

interface.

The DatabaseMetadata interface is used to retrieve information about

databases, tables, columns and indexes among other about the DBMS

A J2EE component retrieves metadata about the database by calling the

getdata() method of the connection object.

The getMetadata() method returns a DatabaseMetadata object that

contains information about the database and its component.

Some of the more commonly used DatabaseMetadata object methods are:

getDatabaseProductName():-Returns the product name of the database.

getUserName():- Returns the username.

getURL():- Returns the URL of the database.

getSchemas():-Returns all the schemas names available in this

database.

getPrimaryKey():-Returns primary key.

getProcedures():-Returns stored procedures names.

getTables():-Returns name of the tables in the database.

In databases, metadata an element could include data types, names of data,

size, length of the field, number of columns.

JAVA & J2EE 10IS753


RESULTSET METADATA:-

There are two types of metadata that can be retrieved from the DBMS.

These are metadata that describes the database & metadata that

describes the ResultSet.

Metadata that describes the ResultSet is retrieved by calling the

getMetadata() method of the ResultSet object this returns a

ResultSetMetadata object.

ResultSetMetadata rm = Result.getMetadata ();

Once the ResultSetMetadata is retrieved, the J2EE component can call

method of the ResultSetMetadata object to retrieve specific kind of

metadata, the most commonly called methods are:

getColumnCount():-Returns the number of the columns contained in the

table.

getColumnsName(int Number):- Returns the name of the columns

specified by the column number.

getColumnType(int number):- Returns the data type of the specified by

the column number.

DATA TYPES:

CHAR String

VARCHAR String

LONGVARCHAR String

NUMERIC java.math.BigDecimal

DECIMAL java.math.BigDecimal

BIT Boolean

INTEGER Integer

REAL float

DOUBLE double

DATE java.SQL.date

TIME java.SQL.Time

JAVA & J2EE 10IS753


EXCEPTIONS

Three kinds of exceptions thrown by JDBC methods they are

SQLExceptions

SQLWarnings

DataTruncation

SQLExceptions:

Specify common SQL syntax error in the query and are thrown by many

of the methods contained in java.SQL package.

SQLWarnings throws warnings received by the connection from the

DBMS.

Whenever data is lost due to truncation of the data value, data

truncation exception is thrown.

Transaction processing:

A database transaction consists of a set of SQL statements, each of

which must be successfully completed for the transaction to be

completed. If one fails, SQL statements that executed successfully up to

that point in the transaction must be rolled back.

The commit() must be called regardless if the SQL statement is part of a

transaction or not.

Autocommit feature is by default set to true for comitting automatically.

//program update records

import java.SQL.*;

class JDBC50

{

public static void main(String v[])

{

Statement s1,s2;

Connection con=null;

JAVA & J2EE 10IS753


try

{


con = DriverManager.getConnection("JDBC:odbc:db300");

}


{


System.exit(1);

}


{

System.err.println("cannot connecto the database"+error);

System.exit(2);

}

try

{

con.setAutoCommit(false);

String query1="update emp set empsal=15750 where empno=200";

String query2="update emp set empsal=18025 where empno=300";

s1=con.createStatement();

s2=con.createStatement();

s1.executeUpdate(query1);

s2.executeUpdate(query2);

con.commit();

s1.close();

s2.close();

con.close();

}

catch(SQLException ex)

{

System.err.println("SQLexception "+ ex.getMessage());

if(con !=null)

JAVA & J2EE 10IS753


try

{

System.err.println("transaction is being rolled back");

con.rollback();

}

catch(SQLException e)

{

System.out.println(e.getMessage());

}

}

}

}

5th Unit Java

Documents

Transcript of 5th Unit Java