CHAPTER 

4 Database Connectivity

Account  balance,  userid,  password,  telephone  number,  etc.  are  daily  use  information; each  has
some implicit meaning, the value called data. These are the facts and can be recorded. A collection
of  related  data  is  called  database,  and  the  system  used  to  manage  it  is  called  Database
Management System (DBMS). Data is an atomic entity that is stored in DBMS and become the
information after pull together.

As the use of computer is growing, there is a major impact of Database system to handle it, called
Database Management System, on everyday life in modern society. A DBMS offer strength to
industry solutions to manage the data and uses different algorithm to assure efficient interaction in
a secure way with stored data in the database.

Many DBMSs are available in the market, most of which are implemented on the basis of widely
accepted relational database model. A database model gives an explanation about the organization
of data in a database. Relational database model supports normalization, i.e. data is grouped in the
form of tables. A relational database is thus a collection of Tables.

Once  a  database  is  created,  at  least  containing  one  table,  then  the  following  operations  can  be
performed on the tables of the database:

 Save data into table
 Retrieve data from table
 Update data of table
 Manipulate data of table
 Delete data from table
There are a number of vendors in market that provides DBMS packages such as Oracle, DB2,
Sybase, and Microsoft Access. 

A  component  that  gives  access  to  the  database  to  Java  application  is  JDBC.  JDBC  is  used  to
connect  enterprise  component  to  any  data  source.  JDBC  is  the  standard  API  to  work  on  data
source,  retrieve  the  data  in  tabular  format  from  any  kind  of  data  source.  A  data  source  can  be
relational database, spreadsheet, or flat file. In this chapter we’ll discuss how Java data objects are
used  to  create  a  communication  links  with  a  data  source  and  SQL  is  used  to  create  a  message
(Query), later sent to DBMS, the message contains the information about an operation like retrieve
data, update data, delete data and other manipulations. 
In  most  of  the  applications,  information  repository  has  to  be  accessed  and  manipulated  by  the
application (implemented with J2SE or J2EE). Here, we’ll discuss about the architecture of JDBC
data  sources,  SQL  queries  related  to  some  operations  (update,  insert,  delete)  on  database  and
updates, and advanced concepts like prepared statements, batch updates, and metadata. Finally,
we’ll look at the built­in features of the JDBC API.  

JDBC is a unified standard API that facilitates you to access any data source in tabular format. 
JDBC API allows the programmer to write an application with the separation of the underlying
architecture and operating environment. JDBC in a nutshell performs all the database operations
related  methods,  connecting  methods,  process  database  results  and  also  support  heterogeneous
environment. It provides an interface that has intelligence how to communicate with a proprietary
database.  JDBC  is  same  as  ODBC  (Open  Database  Connectivity)  standard  that  facilitates  the
programmer by giving the interoperable function through JDBC­ODBC bridges. 

1. Introduction of JDBC

Using JDBC, it is easy to send SQL statements to any relational database. In other words, with the
JDBC API, it isn't necessary to write one program to access a Sybase database, another program to
access an Oracle database, another program to access an Informix database, and so on. One can
write a single program using the JDBC API, and the program will be able to send SQL statements
to the appropriate database. And, with an application written in Java programming language, one
doesn't  have  to  worry  about  writing  different  applications  to  run  on  different  platforms.  The
combination of Java and JDBC lets a programmer write it once and run it anywhere. Java, being
robust, secure, easy to use, easy to understand, and automatically downloadable on a network, is an
excellent  language  basis  for  database  applications.
 Figure 1 JDBC Access

JDBC extends what can be done in Java. For example, with Java and the JDBC API, it is possible
to publish a web page containing an applet that uses information obtained from a remote database.
Or an enterprise can use JDBC to connect all its employees to one or more internal databases via an
intranet. With more and more programmers using the Java programming language, the need for
easy  database  access  from  Java  is  continuing  to  grow.  Once  a  database  is  created,  at  least
containing one table, then the following operations can be performed on the tables of the database:

 Save data into table
 Retrieve data from table
 Update data of table
 Manipulate data of table
 Delete data from table

There  are  a  number  of  vendors  in  market  who  provide  DBMS  packages  such  as  Oracle,  DB2,
Sybase, and Microsoft Access. 

2. Database Connectivity/ Design of JDBC

Java provides JDBC product components that are a part of Java Development Toolkit. The first
component  is  JDBC  Driver  Manager  that  acts  as  the  backbone  of  JDBC  architecture  and
connects Java applications to the correct JDBC Driver. We will discuss about JDBC architecture
and JDBC Drivers in the proceeding sections. Another component is the JDBC Driver Test Suite
that provides a surety that the JDBC drivers will run our program. The last component is JDBC­
ODBC Bridge that allows ODBC drivers to be used as JDBC drivers. 

Figure 2: JDBC Driver Implementations

3. JDBC Drivers

JDBC  Driver  works  as  middleware  layer  between  the  data  source  and  the  application,  either
written through J2SE OR J2EE.

There are four types of JDBC Drivers that are discussed below:

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 three­tier architecture. 

JDBC­ODBC Bridge – Type 1: It uses the Open Database Connectivity (ODBC) as the prime
interface to data source (Database). Initially ODBC was developed for Microsoft Windows
platform to give API standard to communicate with SQL, but later upgraded to provide SDKs
for other platform as well. In JDBC­ODBC Bridge the client makes the JDBC calls. The type 1
driver provides a bridge between the JDBC API and the ODBC API. The bridge is responsible
to convert the JDBC calls to the corresponding ODBC calls, and finally request to data source
using ODBC libraries, that must be required on client tier. 
 J2SE contains the classes for the JDBC­ODBC Bridge and so that there is no need to install any
other packages. Though, you have to create Data Source Name (DSN) using ODBC Manager.

Figure 3 Type 1 Driver

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. 

Native­API Partly Java Driver – Type 2: Type 2 driver works on a combination of vendor­
specific and Java implemented APIs to give to communicate with data source. Here, the client
makes the JDBC calls and these calls are interpreted into vendor­specific APIs, finally from
vendor­specific APIs to database to perform the operations on it. Database process the request
and send the results back through the vendor­specific API, which will be forwarded back to the
JDBC driver. Now, here JDBC driver will convert the response (results) to the JDBC standards
and send to Java application. The driver can be used where is the need of high­performance and
large transaction volume. 

Figure 4 Type 2 Driver
3. JDBC­Net pure 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 pure 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, and so forth, that the Web imposes. 

JDBC­Net Pure Java Driver – Type 3: Type 3 driver works as middleware server between a
numbers of Java clients to multiple vendor databases. Type 2 is a multitier and vendor­neutral
driver. To connect with database server, client (Java client application) uses a server component
in­between the client and database that works as a gateway for multiple database servers. The
client application sends the request to intermediate data access server, by making the JDBC call
through  a  JDBC  driver.  The  intermediate  data  access  server  completes  the  request  to  the
Database using native driver.

Different protocols are used at different level of communication. Client and intermediate server
use  different  protocol,  and  based  on  the  vendor  of  middleware  server,  similarly middleware
sever connect and communicate with database server by using different native protocol.  There
is no need of any driver at the client machine. The JDBC call will be generated through RMI
Call to the JDBC driver that is stored in the middle tier.  It is used to provide solution and is
suitable  for  internet  use.  To  support  these  applications,  there  is  need  of  internet  access,
requirements for security, firewalls etc.  

       Figure 5 Type 3 Driver
4. Native­protocol pure Java driver: This kind of driver converts JDBC calls directly into the
network  protocol  used  by  DBMSs.  This  allows  a  direct  call  from  the  client  machine  to  the
DBMS server and is an excellent 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.

Native­protocol Pure Java Driver – Type 4: Type 4 drivers converts JDBC API request directly
to networking protocols of vendor­specific. By making the socket connection with database they
communicate with database. There is no need of other libraries or any middleware interface to
deploy it. 

Figure 6 Type 4 Driver

4.JDBC Application Architecture

JDBC API supports both two­tier and three­tier architectures or processing models for database
access. In the two­tier model, a Java application communicates directly to the data source with the
help of JDBC driver. The user’s commands are sent to the database and the response is sent back to
the user. This may form a client/server configuration in which the data source may be located on
some another machine in the network. The user machine acts as the client while the machine that
houses the data acts as the server. The figure below shows the two­tier and three­tier processing
models of JDBC.
 Figure 7 Processing Models of JDBC

In the three­tier architecture, the commands are sent to the middle­tier which sends the command
to the data source. The data source processes the commands and sends the result back to the middle
­tier which then sends them to the user. Middle­tier makes it possible to maintain control over
access  and  the  kinds  of  updates  that  can  be  made  to  corporate  data.  It  also  simplifies  the
deployment of applications. The three tier architecture provides performance advantages. 

5. Relational Databases

A database is a means of storing information in such a way that information can be retrieved from
it easily. A relational database presents information in tables with rows and columns. A table is
referred to as a relation. A Database Management System (DBMS) handles the way data is stored,
maintained, and retrieved. In the case of a relational database, a Relational Database Management
System (RDBMS)  performs these tasks. The following terms are associated with RDBMS that
perform discrete tasks for accessing tables in the simplest and efficient manner. RDBMS is the
simplest method for accessing data. 

Integrity Rules 

Integrity means accuracy. Relational tables follow certain integrity rules to ensure that the data
they contain remains accurate and accessible. The rules are as follows:

1. First, the rows in a relational table should all be distinct. If there are duplicate rows, there
can be problems resolving which of two possible selections is correct. 

2. A second integrity rule is that column values cannot be repeating groups or arrays.

3. A third aspect of data integrity involves the concept of a null value. A database has to take
care of situations where data may not be available. A null value indicates that a value is
missing. It does not equate to a blank or zero. A blank is considered equal to another blank,
 a zero is equal to another zero, but two null values are not considered equal.

4. When each row in a table is different, it is possible to use one or more columns to identify a
particular  row.  This  unique  column  or  group  of  columns  is  called  a  primary  key.  Any
column that is part of a primary key cannot be null. This rule is referred to as entity integrity
. The Table below illustrates some of these relational database concepts: 

Student­ID First_Name Last_Name Date_of_Birth Marks

534 Ram Verma 28­AUG­87 87
589 Manan Sood 30­MAY­85 78
596 Munish Sharma 06­APR­85 89
675 Shivendra Tripathi 28­AUG­86 75
743 Swati Verma 26­AUG­84 92
859 Bhanu Priya 10­NOV­91 86

Student Table

In this student table, there are five columns: Student­ID, First_Name, Last_Name, Date_of_Birth
and Marks. There are six rows, each representing a different student. The primary key for this table
would be Student­ID because each one is guaranteed to be different. It would also be possible to
use First_Name and Last_Name because the combination of the two also identifies just one row.
Using  the  last  name  alone  would  not  work  because  there  are  two  students  with  the  last  name
"Verma." In this particular case the first names are all different, so one could conceivably use that
column as a primary key, but it is best to avoid using a column where duplicates could occur. 

Structured Query Language

As we know the meaning of the database, i.e. database is a methodology of storing data in it that
later it can be  fetched  from it. A  type  of database called relational database, discussed above,
presents  data  in  the  form  of  tables  (combination  of  rows  and  columns).  The  database  system
supports relational database called Relational Database System (RDBMS). 
Table Example: Employee

EmpID FirstName LastName DOB Salary

1001 Mariya Surkozi 22­AUG­45 339834
1009 Alice Haden 12­NOV­47 534877
1011 Bob Paul 10­JAN­69 569849
1088 Rosy Paul 14­JUL­74 236652
1090 Anna Kurnikova 11­SEP­81 258498
 1099 Rahina Washington 28­DEC­57 484599

The  above  table  shows  some  record  of  table  EMPLOYEE  with  attributes  EmpID,  FirstName,
LastName,  DOB,  CarNumber.  All  the  SQL  command  example  will  be  based  on  the  table
EMPLOYEE.
There are varies operations on data: 
 Writing to database
 Extract from database
 Modification of data
 Deletion of data
 For all significant operations on data there is a language called Structure Query Language (SQL),
supported by all RDBMS.  SQL Commands are divided into the following categories:
1. Data  Manipulation  Language  (DML):  DML  commands  work  on  data,  and  perform
operations  like,  retrieving  it;  manipulate  it.  A  brief  discussion  about  the  more  common
DML commands are as follows:
a. SELECT  :  A  flexible  and  simple  statement  is  used  to  select  rows  with  some
attributes (columns) from the given table name.
Syntax:
select [column1,column2,….] from [TABLENAME] where [criteria_1 {AND/OR}
criteria_2 . . . {AND/OR} . . . criteria_2]
e.g.       select * from Employee
Employee
empid firstname lastname salary DOB
1001 Mariya Surkozi 339834 8/22/1945
1009 Alice Haden 534877 11/12/1947
1011 Bob Paul 569849 1/10/1969
1088 Rosy Paul 236652 7/14/1974
1090 Anna Kurnikova 258498 9/11/1981
1099 Rahina Washington 484599 12/28/1957

 select EmpID, FirstName, DOB from Employee
Employee
EmpID FirstName DOB
1001 Mariya 8/22/1945
1009 Alice 11/12/1947
1011 Bob 1/10/1969
 Employee
EmpID FirstName DOB
1088 Rosy 7/14/1974
1090 Anna 9/11/1981
1099 Rahina 12/28/1957

 select * from Employee where Salary > 500000
Employee
Empid firstname lastname salary DOB
1009 Alice Haden 534877 11/12/1947
1011 Bob Paul 569849 1/10/1969

b. INSERT : It is used to insert data into the table as a record. Here we’ve to give the
attribute name (if store in selected attribute) and value (data) to store in database. 
Syntax:
insert  into  [TABLENAME]  [columnsname1,  columnname2,….]  values  [value1,
value2,…]
e.g.   insert into Employee values (1110,’Sujain’,’David’,’12­JAN­78’,578989)
Employee
empid firstname lastname DOB Salary
1001 Mariya Surkozi 8/22/1945 339834
1009 Alice Haden 11/12/1947 534877
1011 Bob Paul 1/10/1969 569849
1088 Rosy Paul 7/14/1974 236652
1090 Anna Kurnikova 9/11/1981 258498
1099 Rahina Washington 12/28/1957 484599
1110 Sujain David 1/12/1978 578989

 insert  into  Employee  (EmpId,  FirstName,  DOB,  Salary)  values

(1111,’David’,’21­MAR­78’,473554)
Employee
empid firstname lastname DOB Salary
1001 Mariya Surkozi 8/22/1945 339834
1009 Alice Haden 11/12/1947 534877
1011 Bob Paul 1/10/1969 569849
1088 Rosy Paul 7/14/1974 236652
1090 Anna Kurnikova 9/11/1981 258498
1099 Rahina Washington 12/28/1957 484599
1110 Sujain David 1/12/1978 578989
 Employee
empid firstname lastname DOB Salary
1111 David 3/21/1978 473554

c. DELETE : The command is used to delete record (row) from the table. We can
give some criteria using where clause to give selected record.
Syntax:    delete from [TABLENAME] where criteriaN
 delete from Employee where Empid=1099
Employee
Empid firstname lastname DOB Salary
1001 Mariya Surkozi 8/22/1945 339834
1009 Alice Haden 11/12/1947 534877
1011 Bob Paul 1/10/1969 569849
1088 Rosy Paul 7/14/1974 236652
1090 Anna Kurnikova 9/11/1981 258498
1110 Sujain David 1/12/1978 578989
1111 David 3/21/1978 473554

 delete from Employee where FirstName=’David’
Employee
Empid firstname lastname DOB Salary
1001 Mariya Surkozi 8/22/1945 339834
1009 Alice Haden 11/12/1947 534877
1011 Bob Paul 1/10/1969 569849
1088 Rosy Paul 7/14/1974 236652
1090 Anna Kurnikova 9/11/1981 258498
1110 Sujain David 1/12/1978 578989

d. UPDATE :  It is a simple SQL command that is used to update or modify the value
of any attribute (column) of records on the basis of given criteria.
Syntax:
update [TABLENAME] set [column1 = expression1], [column2 = expression2], …
[columnN = expression] where criteria1 [AND/OR] … criteriaN
 update Employee set salary= salary + salary* 0.10 where Empid=1111
Employee
Empid firstname lastname DOB Salary
1001 Mariya Surkozi 8/22/1945 339834
1009 Alice Haden 11/12/1947 534877
 Employee
Empid firstname lastname DOB Salary
1011 Bob Paul 1/10/1969 569849
1088 Rosy Paul 7/14/1974 236652
1090 Anna Kurnikova 9/11/1981 258498
1110 Sujain David 1/12/1978 636888

2. Data  Definition  Language  (DDL):  DDL  commands  use  to  define  the  database,  like
creating the table, modifying the table structure, creating views; and indexing the database.
Let’s have a look on more common use of DDL commands as follows: 
a. CREATE TABLE
b. DROP TABLE
c. ALERT TABLE

6. JDBC Installation

Registering an ODBC data source

To configure the ODBC data source implement the following steps: 

1. Open the control panel from Windows settings and start the application "ODBC Data Sources
[32bit]" 

NOTE:  In  Windows  2000,  the  Control  Panel  does  not  contain  the  pointer  to  the  "ODBC  Data
Sources". Using  Help, search  on ODBC  and then  select the topic "Using Data Sources". From
there, select "Data Sources" to bring up the ODBC Data Source Administrator window.
2. Select the Add button to add a new data source.

3. Select the appropriate driver for your database and click the Finish button.
4. Enter a string in the Data Source Name that you want to use to register your database, and 
click the Select… button. 

5. Find the actual file of your database and click OK when you're done. 
6. Click on OK

7. Click on OK
 7.  JAVA.SQL PACKAGE­ Database Programming using JDBC 

Let’s  have  some  concise  look  on  java.sql  package,  before  going  in­depth  to  write  the  Java
application with database connectivity code.  The classes in the java.sql package can be separated
into the subsequent groups based on their functionality:
1. Management of Connection: The classes and interface related to connection management let
you create a connection to the data.
 java.sql.DriverManager:  :  The  class  offer  the  functionality  essential  for  running  one  or
more database drivers, individual driver connects to specific database.
 java.sql.Driver: The interface abstracts the connection protocol of specific­
vendor. 
 java.sql.Connection: It abstracts the interaction with the database. Sending SQL statement
to database, reading the results of operations is done by this interface.
2. Access  Database:  After  creating  connection  with  the  database,  these  types  of  classes  and
interfaces allow you to send SQL commands (statements) to the database for execution, and
also read the response (result).
 java.sql.Statement:  The  interface  allows  you  to  execute  SQL  commands  above  the
connection and access the results.
 java.sql.PreparedStatement:  The  interface  used  to  give  parameterized  SQL  Statement,
include place holders ( as “?”), later on which will be replaced with actual values. 
 java.sql.CallableStatement:  The  interface  allows  you  to  execute  stored
procedure. 
 java.sql.ResultSet: The interface stores the results of execute SQL SELECT commands. To
access the results row­by­row, it provides some methods. 
3. Type of Data: In java.sql package there are classes and interfaces that provide several Java
data types so as to correspond to some of the SQL data types. 
 java.sql.Array:  The  interface  gives  an  abstraction  in  Java  language  with  ARRAY
collection of SQL data types. 
 java.sql.Blob: The interface gives an abstraction in Java language with
SQL type BLOB
 java.sql.Clob: The interface gives an abstraction in Java language with
SQL type CLOB
  java.sql.Data: The  interface gives  an  abstraction in  Java language with
SQL type DATE
 java.sql.Time: The interface gives an abstraction in Java language with
SQL type TIME
4. Metadata of Database: Metadata is some data about the database. Sometime developer need
to work on metadata. So that JDBC API also supports this facility to retrieve metadata of the
database, also parameters to statements; and result too. 
 java.sql.DatabaseMetadata:  The  instance  of  this  interface  can  be  obtained  by
java.sql.Connection. This is used to get information about the features of database.
 java.sql.ResultSetMetadata: Methods are provided by this interface to access metadata of
java.sql.ResultSet. 
 java.sql.ParameterMetadata:  The  interface  permits  you  access  the  database  types  of
parameters in prepared statements. 
5. Exceptions  and  Warnings:  The  collection  of  classes  support  the  runtime  exception  and
warning related to JDBC.
 java.sql.SQLException:  Handle  all  type  of  exception  of  JDBC  related,  database  level,
driver level exceptions and error levels.
 java.sql.SQLWarnings: It represents database warnings. 
 java.sql.BatchUpdateException: Handles the exception for batch updates.
For writing the code to connect with database and work on database with the SQL commands the
developer has to perform the following steps.
6. Loading the Database Driver: The concept of a URL in JDBC is same as used like other
application such as internet. In basic concept of JDBC URLs, in application more than one
database  can  be  in  use,  each  will  be  accessed  via  a  different  database  driver.  In  such  a
situation, it is necessary that every driver must be uniquely identified. 
To communicate with the data source, you must load a driver. Here we’re taking the example of
JdbcOdbcDriver. The syntax to load the driver is given below: 

Syntax: (i)  Class.forName( “DriverClassName”);

OR
Class.forName(“DriverClassName”).newInstance();
Example:  
try{
 Class.forName (“sun.jdbc.odbc.JdbcOdbcDriver”);
}catch(ClassNotFoundException e)
{
System.out.println(“Unable to load the Driver”); }
(ii) Java –D jdbc.drivers=DriverClassName JavaApplication

The  above  command  specifies  the  driver  from  the  command  line,  using  a  system  property
jdbc.drivers, but it is necessary that the driver must be in CLASSPATH at the time of compilation. 

The DriverManager class has three variations of a static method getConnection() to establish the
connections as follows: 
public  static  Connection  getConnection(String  urlString)  throws  SQLException  return  a
Connection object to a driver from the set of registered JDBC driver. The urlString must be in form
of jdbc:subprotocol:subname. 
Example:
         Connection conn = DriverManager.getConnection(“jdbc:odbc:MYDSN”);

public  static  Connection  getConnection(String  urlString,  java.util.Properties  prop)  throws

IOException , two arguments are passed to it, urlString as same as above, and prop is an object of
Properties type, contains the additional information required for the specified database. 
Example:
String URL = “jdbc:cloudscape:Movies”;
Properties p = new Properties();
p.put(“autocommit”,”true”);
p.put(“create”,”true”);
Connection conn = DriverManager.getConnection(URL,p);

public static Connection getConnection(String urlString, String userName, String password) ,
this variant receives the userName and password as the argument to connect with the database. 
Example:
String urlString = “jdbc:odbc:MYDSN”;
String userName = ”admin”;
String password = ”adminadmin”
Connection  conn  =  DriverManager.getConnection(urlString,
                           userName, password);

7. Opening Connections or Establishing a Connection: DriverManager class defines object to
connect  application  to  a  JDBC  Driver.  It  has  a  method  getConnection()  used  to  find  a
connection to a database. It receives a URL, the URL contains protocol, sub­protocol, sub­
name, and other attribute as well, and return the connection object. 
A Connection object represents a context. SQL statements are fired on it and return the results.
You  can  create  more  than  one  connection  in  an  application with  one  database,  can  have  many
connection with many databases. 
URL Syntax:    jdbc: <subprotocol>:<subname>

Each driver supports it’s own sub­protocol, and each sub­protocol has its own syntax, varies on the
base of number of attributes. 
Example: 
try{
String url =  “jdbc:odbc:MYDB”;
Connection conn = DriverManager.getConnection(url, “USER1”,  “MYNAME”)
}catch( SQLException e ){
System.out.println( “Error in Connection ” + e ); }

In the given example, url contains the protocols name : jdbc, the sub­protocol : odbc, and data­
source name : MYDB is a DSN. USER1 is the username to access the database and MYNAME is
the password. 
The java.sql.Connection has many public methods, we’ll see the use of other later in this chapter
but all three of them are used to create different type statements as follows:
8. Creating  Statement:  Once  the  connection  has  been  established  with  data­source,  we  can
interact  with  database.  Connection  object  are  used  to  execute  SQL  statements  by  creating
Statement,  PreparedStatement,  or  CallableStatement.  These  objects  are  abstract  SQL
commands. 
Once we have created the object on one of these statements, we can execute the statement and read
the results, though  the result can  be  stored in java.sql.ResultSet object if the SQL command is
SELECT. The methods are given below to create either type of these statements.
Statement createStatement() throws SQLException
      The method creates a Statement object, which use to send the SQL command to the database. 
Statement createStatement(int result_Set_Type,  int result_Set_Concurrency)
                                           throws SQLException 
In it resultSetType and resultSetConcurrency arguments apply to ResultSet object, which is created
by  executing  queries.  For  the  first  argument  there  are  three  different  constant
ResultSet.TYPE_FORWARD_ONLY,  ResultSet.TYPE_SCROLL_INSENSITIVE  and
ResultSet.TYPE_SCROLL_SENSITIVE  for  different  purposes  discuss  later  in  the  same  chapter.
For  the  second  argument  there  are  two  constants  ResultSet.CONCUR_READ_ONLY,
ResultSet.CONCUR_UPDATABLE
The no­argument createStatement() returns a forward­only scrollable and read­only ResultSet.
Example:
Statement stmt = conn.createStatement();
OR
Statement stmt = conn.createStatement(
                                                            ResultSet.TYPE_SCROLL_INSENSITIVE, 
                                                            ResultSet.CONCUR_READ_ONLY);

public PreparedStatement prepareStatement(String sqlString) throws SQLException
It’s a pre­compiled SQL statement that avoids the repeated compiling of the same SQL command.
It is used to create parameterized statements in a way that the parameters will be placed at run time.
It is useful to create statements where data values are not always as character string. It’s superclass
is Statement.
Example:
PreparedStatement prstmt = conn. prepareStatement(“INSERT INTO” + “EMPLOYEE (empid,
firstname, lastname, salary)”+           VALUES  ?, ?, ?, ?, ?)”);

To  set  the  value  at  place  holder  i.e.  at  ‘?’  (Question  Mark)  there  are  number  of  setXXX(int
placeHolderIndex,  dataTypeXXX  data)  method  of  each  data  type  value.The  placeHolderIndex
starts from 1. For the prstmt, the value will be set to the placehoder in the following manner:
prstmt.setInt(1, 1078);
prstmt.setString(2, “Holzner”);
prstmt.setString(3. “Steve”);
prstmt.setInt(4, 567439);
        pstmt.executeUpdate();
public CallableStatement prepareCall(String sqlString) throws SQLException
public     CallableStatement prepareCall(String sqlString, int resultSet_Type,  int 
resultSet_Concurrency)  throws SQLException

The purpose of this interface is to create statements for executing stored procedures. 

   Example:
String queryString = “ { CALL LastAttendanceRecord (?) }”;
CallableStatement cstmt = conn.prepareCall(queryString);

9. Executing the Querying: After creating the statement of either type, execute the query on the
database.  To  execute  the  query  on  database  we  use  executeQuery(),  executeUpdate(),  and
execute() method of Statement interface according to the need. Before exploring the logic in
database  programming,  a  discussion  on  execute(),  executeQuery()  and  executeUpdate()
method of Statement interfaces is required:
 Here we’ll take the table EMPLOYEE for demonstartion
executeUpdate() method is used to execute SQL INSERT, UPDATE, and DELETE statements,
and returns number of rows updated by the either of these SQL statement.
The method of Statement interface will receive a sqlString as argument that is a SQL statement has
to execute. In PreparedStatement interface, the SQL statement is given at its creation time, so that
the method passes no argument. The prototype is given in the corresponding method description
table.
Example: Using the Statement object
Statement stmt;
Connection conn;
String url = “jdbc:odbc:MYDSN”;
try
{
    Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
    conn = DriverManager.getConnection(url);
     String  qryStr  =  “UPDATE  Employee  set  Salary  =  708767  where
                            EmpId = 1011”;
     stmt = conn.createStatement();
    int rows = stmt.executeUpdate(qryStr);
   System.out.println(“Update Rows : ” + rows);
}catch(ClassNotFoundException cnfe){
System.out.println(cnfe);
}catch(SQLException se){
System.out.println(se);
}

In the above code stmt.executeUpdate(qryStr) will execute the query string given in qryStr and
returns the number of updated records count to rows. Here the value of rows will be one only,
because only one record of employee of whom EmpId is ‘1011’ will be updated in Employee table.

Example : Using PreparedStatement Object
PreparedStatement prstmt;
Connection conn;
String url = “jdbc:odbc:MYDSN”;
try
{
    Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
    conn = DriverManager.getConnection(url);
     String  qryStr  =  “UPDATE  Employee  set  Salary  =  Salary  +  Salary  *  0.10  where
                            EmpId = ?”;
    prstmt = conn.prepareStatement(qryStr);
   prstmt.setInt(1, 1090);
   prstmt.executeUpdate();
  }catch(ClassNotFoundException cnfe){
System.out.println(cnfe);
}catch(SQLException se){
System.out.println(se);
}
In  the  above  code  prstmt.executeUpdate()  will  execute  the  query  string  given  in  qryStr  that  is
already  passed  at  the  creation  time  of  PreparedStatement  object.  The  statement
prstmt.setInt(1,1090)  will  set  the  value  of  first  placeholder  as  ‘1090’,  as  the  statement
prstmt.executeUpdate() executes, only one record of employee of whom EmpId is ‘1090’ will be
updated in Employee table. The method executeUpdate() of PreparedStatement will never return
any value.

Example: 
stmt = conn.createStatement();

stmt.executeUpdate("INSERT INTO EMPLOYEE (EmpId, FirstName, LastName, 
Salary) VALUES (1212, ‘Aman’,’Rai’,676545)");

stmt.executeUpdate("INSERT  INTO  EMPLOYEE  (EmpId,  FirstName,  LastName,

Salary) VALUES (1046, ‘Neomi’,’Lio’,548975)");

stmt.executeUpdate("INSERT  INTO  EMPLOYEE  (EmpId,  FirstName,  LastName,

Salary) VALUES (1045, ‘David’,’Fernandis’,549598)");

executeQuery() method execute SQL SELECT statements, and store the results of exeution in
ResultSet object.
ResultSet  contains  the  data  returned  by  executing  Java  method  with  SQL  statement.  It  also
provides methods for conversion of data between SQL and Java. ResultSet also acts as an iterator
to move tuple by tuple. 
To  retrieve  the  value  from  any  column,  we  have  to  use  getXXX(int  columnIndex)  or
getXXX(String  columnName),  where  XXX  is  the  data  type  in  Java  that  corresponds  to  the
datatype in SQL.  The mapping of Java datatype with SQL datatype, is given at the last of this
chapter. 
Let the columnName is FIRSTNAME of Employee table and of type VARCHAR, then its value
can be retrieve by the following statement, where rst is an object of ResultSet:
System.out.println(rst.getString(“FIRSTNAME”);
OR
String fname = rst.getString(“FIRSTNAME”);

Example: Using the Statement object
public void showAllData() throws SQLException{
 Connection conn=null;
try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
conn= DriverManager.getConnection("jdbc:odbc:MYDSN");
}catch(ClassNotFoundException cnfe){
System.out.println(cnfe);
}
Statement stmt =  conn.createStatement();
ResultSet rst = stmt.executeQuery(“select * from Employee”);
while(rst.next())
{
System.out.println(rst.getString(“EMPID”)+ “, ” 
+rst.getString(“FIRSTNAME”)+ “, ” +rst.getString(“LASTNAME”)+ “, ” 
+rst.getInt(“SALARY”));
}  
 }

In the above code the statement stmt.executeQuery(“select * from Employee”) returns the result of
the SQL statement and store it in ResultSet object rst. The while loop will continue till rs.next()
return  true,  and  rs.next()  return  true  until  last  record  traversed.  The  getString(“EMPID”)  will
return the value of EMPID of current row , similarly with other getXXX() methods.

Example : Using PreparedStatement Object
import java.sql.*;
import java.io.*;
public class JDBCDemo1
{
public static void main(String ar[]){
Connection conn=null;
PreparedStatement pstmt=null;
try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
 conn= DriverManager.getConnection("jdbc:odbc:MYDSN");
pstmt=conn.prepareStatement("SELECT  EmpID,  FirstName,  LastName,  Salary
from EMPLOYEE where EmpID =?");
pstmt.setString(1, ar[0]);
ResultSet rst = pstmt.executeQuery();
if(rst.next())
{
System.out.println(rst.getString("EMPID")+ ", " +rst.getString("FIRSTNAME")+
", " +rst.getString("LASTNAME")+ ", " +rst.getInt("SALARY"));
}
else
System.out.println("No record found");
}catch(ClassNotFoundException ce){
System.out.println("Error "+ce);
}catch(SQLException se){
System.out.println("Error"+se);
} } }

execute() method execute the SQL statement given to it by String. It returns true if the statement
returns a result set, otherwise false. Method getUpdateCount() returns number of updation in table,
and getResultSet() will return result set that come out after executing the SQL statement. 
The method of Statement interface will receive a sqlString as argument, that is a SQL statement
has to execute, in PreparedStatement interface, the SQL statement is given at its creation time, so
that the method pass no argument, but both returns ResultSet object The prototype is given in the
corresponding method description table.

Example: 
public class JdbcExecuteStatement {
public static void main(String args[]) {
~~ Connection con = null; 
        Statement st = null; 
        String url = "jdbc:mysql://localhost:3306/"; 
        String db = "komal"; 
        String driver = "com.mysql.jdbc.Driver"; 
         String user = "root"; 
        String pass = "root"; 
        try { 
            Class.forName(driver);
            con = DriverManager.getConnection(url + db, user, pass);
            st = con.createStatement();
         String sql = "create table Abc(no integer,name varchar(10))"; 
            st.execute(sql);
        } catch (Exception e) {
            System.out.println(e);
        } 
    } 
}  

8. Scrollable and Updatable Result Sets

Sometimes  there  is  a  need  to  move  in  forward  direction as  well  as in backward  direction. The
next() method of ResultSet allows to iterate in forward direction only. i.e. by default the ResultSet
object is forward­only scrollable. As we traversed the ResultSet, the next() will return false when it
has reached the last record, now no further details can be retrieved. 

New  JDBC  2.1  API  enhanced  the  old  version  and  functionalities  are  categories  in  following
section:
a. Scrollable : The scrollable result set allows to move the cursor in either direction, and also
able to support absolute positioning of the cursor.
b. Scroll Sensitive: There are two types of sensitivity of result set: sensitive and in­sensitive.
In­sensitive result set give a static snapshot, while sensitive result set give dynamic view
that supports the changes made to the data after the query has been executed. 
c. Updatable: By default the resultsets are read­only in nature, i.e. the contents of the result
set can not be changed. Now it supports updateable resultsets.
Before we create an object of Statement or PreparedStatement let’s have a look on the three 
types of resultset of java.sql.ResultSet as follows:

TYPE_FORWARD_ONLY Set the result set is not scrollable.

TYPE_SCROLL­INSENSITIVE Set the result set is scrollable but not sensitive to 
database changes.
TYPE­SCROLL_SENSITIVE Set the result set is scrollable and sensitive to 
database changes.
Scrollable  results  means  to  move  cursor  in  forward  and  backwards  direction,  and  also  allow
moving to absolute and relative position.
Scroll sensitive resultset means the change will be reflected in the resultset and database after the
execution of query while insensitive resultset give a static snapshot of query results.
Updatable  results  allow  the  updation  in  resultset  as  well  as  in  underlying  database.  By  default
resultset is read­only.
To  obtain  the  result  set  of  scrollable  type,  the  Statement  object  has  to  be  creating  using  the
following syntax;
Syntax: 
Statement stmt = conn.createStatement(scroll_type, concurrency_type); 
PreparedStatement  pstmt  =  conn.prepareStatement(command,  scroll_type,
                                                                                       concurrency_type);
Example:
PreparedStatement pstmt = conn.prepareStatement(“select * from 
                                                   Employee where salary > ?”,   
                                                   ResultSet.TYPE_SCROLL_INSENSITIVE, 
                                                   ResultSet.CONCUR_UPDATABLE);
By default, resultsets are created in read­only mode. That is, the contents of the reasultsets can not
be changed. But enhanced version of JDBC (JDBC 2.1 API) provides updateable resultsets. As we
perform update operations on resultset, it updates the corresponding original data.
There are two constants of java.sql.ResultSet to show whether the resultset will be read­only or
updateable are given below:

CONCUR_READ_ONLY Set the result set cannot be used to update the
database.
CONCUR_UPDATABLE Set  the  result  set  can  be  used  to  update  the
database.

Example:
Statement stmt = conn.createStatement ( 
                           ResultSet.TYPE_SCROLL_INSENSITIVE,                                                         
                           ResultSet.CONCUR_UPDATABLE);
Example:    Code  is  to  update  the  set  of  attribute  of  Employee Table  and print  the records  in
reverse order
Statement stmt = conn.createStatement( 
                           ResultSet.TYPE_SCROLL_INSENSITIVE, 
                           ResultSet.CONCUR_UPDATABLE);
ResultSet rst = stmt.executeQuery(“select * from employee where empid= ‘E1001’”);
if(rst.next())
{
rst.updateString(“address”, “new defence colony, south ex­1”);
rst.updateString(“phonon”,”9898980001”);
rst.updateRow();
}
rst = stmt.executeQuery(“seletct * from employee”);
rst.last();
while(rst.previous())
{
System.out.println(“Emp ID :: ” + rst.getString(“empid”));
System.out.println(“Emp First name :: ” + rst.getString(“firstname”));
System.out.println(“Emp Last name :: ” + rst.getString(“lastname”))
}

Example:  Code is to insert data into Employee Table
Statement stmt = conn.createStatement(
                           ResultSet.TYPE_SCROLL_INSENSITIVE, 
                           ResultSet.CONCUR_UPDATABLE);
ResultSet rst = stmt.executeQuery(“select * from employee”);
rst.moveToInsertRow();
rs.updateString("empid", “E1009”);
rs.updateString("firstname", pubid);
rs.updateString("lastname”, lastname);
rs.updateDouble("P", price);
rs.insertRow();
rs.moveToCurrentRow();
 9. Metadata
Meta means “Data About Data”. As any database is created, or any table is created in a database,
then database system store some information about all these for the internal use. If there is any
need then we can retrieve from system file or the tools given by database system. For example,
metadata describes that table structure, like column name, size, type etc. 
JDBC also provides two interfaces by which we can get the information about the structures of a
database and its relations. Supporting methods are useful to write the tool to interact with database.
To explain the need of these interfaces let’s take one example: only the database name and its URL
is given, now the developer has to write the code to extract the stored data in the tables. So before
writing  the  code  the  developer  must  know  all  tables  name,  their  structures,  etc.  In  that  these
interfaces will provide help to the developer to collect the information about the database and their
components. 
Let’s have a look on the JDBC interfaces that facilitate the developer to work on metadata of the
database and resultset. There are two interfaces as following:
 DatabaseMetaData:  The  interface  java.sql.DatabaseMetaData  is  used  to  provide
information  about  the  database  itself.  Vendor  to  vendor  the  differences  are  found.  For
example, it gives data or information about the version, table name list, and other function
too. 
The object of DatabaseMetaData can be get from getMetaData() from Connection object.
Example:
DatabaseMetaData mtd = conn.getMetaData();
Sysetm.out.println(“Major Version :: ”+mtd.getJDBCMajorVersion());
Sysetm.out.println(“Minor Version :: ”+mtd.getJDBCMinorVersion());
Sysetm.out.println(“Maximum Connection :: ” 
                               +mtd.getMaxConnections());
/*Print name of all tables of the database*/
ResultSet mrst = mtd.getTables(null, null, null, new String[] { “TABLE” });
while(mrst.next())
System.out.println(mrst.getString(3));
mrst.close();
  ResulstSetMetaData:  The  interface  java.sql.ResultSetMetaData  is  used  to  provide  the
information about the characteristics ResultSet object. For example, using this developer
can  collection  the  name  of  each  column  of  the  corresponding  table  of  which  ResultSet
object has the reference. 
The object of ResultSetMetaData can be get from getMetaData() from ResultSet object.
Example:
public void get_Meta_Data()
{
ResultSet rst = stmt.executeQuery(“select * from Employee”);
ResultSetMetaData metad = rst.getMetaData();
System.out.println(“COLUMN  NAME\t  COLUMN  LABLE  \t  COLUMN
                               TYPE”);
for(int i=1; i<= metad.getColumnCount(); i++){
System.out.print(metad.getColumnName(i)+ “\t” + 
                                metad.getColumnType(i)+”\t”+                                                                   
                                metad.getColumnLabel(i));
}
}
In the above example, metad is an object of ResultSetMetaData, created by ResultSet object rst
.getColumnCount() will return the number of columns as a result of corresponding ResultSet.
The  getColumnName()  returns  the  name  of  the  column  on  ith    index,  and  getColumnType()
return the data type of the column as integer value. These types are constants and define in the
java.sql.Types interface. 

10.Row Sets

There  is  a  drawback  of  scrollable  result  set,  because  database  connections  must  be  open
throughout the interaction. Row set is a connectionless state with database, and extends ResultSet
interface.  Connection  less  means  that  after  fetching  the  data  from  database,  it  disconnects  the
connection. 

Row sets support the features to move the query result to another tier of an application or to any
other supporting device.
Properties of RowSet
The javax.sql.RowSet interface provides a set of JavaBeans properties, those can be set at design
time. The following are some of the commonly required parameter:
 URL
 Data source name
 User name
 User password
 Transaction isolation
 Command

Events of RowSet
The javax.sql.RowSet object generates three types of events discuss following:
There are three types of implementation of RowSet: 
 Cached  rowsets  (sun.jdbc.rowset.CachedRowSet)  :  A  CachedRowSet  support
disconnected operation. It contains all data from a resultset because it extends ResultSet.
The developer can use it similarly as result set.
Whenever any command is going to execute, then command opens the connection, issues a
query, store the result in rowset, and then disconnects the connections. But there is one
drawback of rowset that it doesn’t support large query results. 
If the database is updated after populating the rowset, it leads to data inconsistency. At the
run time, the references check the database values with rowset value. If both are same then
it is replaced with new value otherwise SyncProviderException is thrown. 
The CachedRowSet object is suitable in at least following two situations:
 The client application holds the results for long time interval. 
 The client has neither capacity nor the resources for connecting to a database. 
 JDBC  rowsets  (sun.jdbc.rowset.JdbcRowSet):  It  is  a  connected  rowset.  It  provides
JavaBeans type layer. The sun.jdbc.rowset.JdbcRowSet class is connected, not serializable
and nor is it cloneable. 
 Web rowsets (sun.jdbc.rowset.WebRowSet): For web applications, the webrows is used.
The  Cached  RowSet  use  XML  to  communicate  with  other  components  over  HTTP
protocol. 

11.Transactions
Transaction is a set of statements. As the transaction is completed or done successful, then it can be
committed. If any error occurs during transaction execution with any one of them, then it can be
rollback to the last committed state. 
Data  integrity  is  an  important  issue  of  any  database,  so  as  to  maintain  it  we  group  the  related
commands into one transactions. 
For Example: Transfer money from one account to another account.
By default, a database connection is in auto­commit mode. As any SQL command is executed, it
commit the database as soon as possible, and cannot be rollback. 

Concepts of Transaction Processing: 
Before starting explanation of related APIs, let’s have look at concepts associated with distributed
transactions: 
1. Transaction demarcation 
2. Transaction context and propagation
3. Resource enlistment
4. Two­phase commit

Methods related to Transaction’s operations
 setAutoCommit() – 
conn.setAutoCommit(false); 
The above command turn off autocommit mode. 
 commit() –
After  executing  executeUpdate()  method  one  or  more  then  one  times    commit()
method is called. 
Example:
Statement stmt = conn.createStatement();
                    stmt.executeUpdate(“insert  into  Employee  values
                                                (1110,’Sujain’,’David’, ’12­JAN­78’,578989)”);
                    stmt.executeUpdate(“insert  into  Employee  values
                                           (1121,’Edward’,’Luis’, ’21­DEC­78’,545676)”);
     conn.commit();
  rollback() – If any error occurred then 
conn.rollaback();
                            can be called, and every updates will be roll back to last commit point. 

Save Points
You can gain finer­grained control over the rollback process by using save points. Creating a save
point  marks  a  point  to  which  you  can  later  return  without  having  to  return  to  the  start  of  the
transaction. 
Example: 
Statement stmt = conn.createStatement();
stmt.execute(“insert  into  Employee  values  (1221,’Tom’,’Glib’,
                                   ’09­FEB­76’,496876)”);
Savepoint sp = conn.setSavepoint();
stmt.execute(“insert  into  Employee  values  (1231,’Jerry’,’Messa’,
                           ’19­MAY­74’,597869)”);
if(error) 
conn.rollback(sp);
conn.commit();

You can assign or give the a name to save point.
Syntax:
Savepoint st = conn.setSavepoint(“firstSavePoint”);
After done with the save point , it must be release using the following syntax:
stmt.releaseSavepoint(st);

Batch Updates
Apart from scrollable resultsets, JDBC support for batch updates. The features facilitate, to use
update statements (INSERT, UPDATE, OR DELETE) in a single request to the datasource. In
batch update mechanism more than one commands is collected and submitted as a batch. All the
commands have to be added to batch exception SELECT because it returns ResultSet object. To
add command to batch and to execute the batch there is following two commands:
  addBatch(command) : It used to add command in batch. The commands will execute then
ther order of execution will be same as, the command was added in batch. 
 executeBatch() : To execute all the added command, this method is used. It submit entire
batch to datasource, but one statement will execute at a time. It return the updated row
count the table, 
Example:
Statement stmt = conn.createStatement();
boolean flag = conn.getAutoCommit();
if(flag)
conn.setAutoCommit(false);
stmt.addBatch("INSERT INTO EMPLOYEE (EmpId, FirstName, LastName, Salary) 
                          VALUES (1212, ‘Aman’,’Rai’,676545)");
stmt.addBatch("INSERT  INTO  EMPLOYEE  (EmpId,  FirstName,  LastName,  Salary)
                          VALUES (1046, ‘Neomi’,’Lio’,548975)");
stmt.addBatch("INSERT  INTO  EMPLOYEE  (EmpId,  FirstName,  LastName,  Salary)
                          VALUES (1045, ‘David’,’Fernandis’,549598)");
int a[] = stmt.executeBatch();
conn.commit();
conn.setAutoCommit(flag);
 

12.Advanced Connection Management (JNDI and Data Source)

The JDBC can be used at small scale application that is for small organization. In that database
connection  can  be  setup  with  the  help  of  properties  files.  These  database  properties  file  will
contains some information about the database that is require to makes the connection. But for large
scale application it will not be so efficient. 

In an enterprise environment, JDBC is deployed in a different manner. The database management
will work with the mechanism of Java Naming Directory Interface (JNDI). All the properties are
not  stored  in  a  properties  file,  but  all  the  details  are  stored  in  a  directory.  Using  the  directory,
centralized management can be possible of user name, passwords, database names, and URLs of
JDBC.
The following code is used to establish the database connection:
Context jndi_Context = new InitialContext();
DataSource data_Source = (DataSource) jndi_Context.lookup(“java:comp/env/jdbc/ad_java”);
Connection con = data_Source.getConnection();

Here DataSource is used instead of DriverManager. DataSource interface is defined in javax.sql
standard extension package. It provides some advance services with simple JDBC connectivity. It
can execute distributed transaction on multiple databases simultaneously. So data source is a better
option than DriverManager.
A data source is considered as a shareable network resource, and can be retrieved from a JNDI
service. Any object can be bind with a name to JNDI service from any application. The application
that binds objects with names in the JNDI service, and the application that lookup object by the
name, are on remote side. JDBC APIs provides methods to build the database resources based on
this approach. 

Let’s have a look on how to create a data source and later how to retrieve data source object.
Create a Data Source
XDataSource xyz = new XDataSource(…);
//Set the properties for the datasource
try { 
Context ctx = new InitialContext();
ctx.bind(“jdbc/mydb”,xyz);
}catch(NamingException ne){}
XDataSource is a class that implements javax.sql.DataSource. In the above code the data source is
bind with a name ‘jdbc/mydb”. Any application can access the data source by retrieving it from
JNDI services.  
Retrieving a DataSource object
try{
Context ctx = new InitialContext();
DataSource dataSource = (DataSource) ctx.lookup(“jdbc/mydb”);
}catch(NamingException ne){}
There are following advantages for data source approach:
 There is no need for each client application to initialize JDBC drivers.
 The client application need not be know the details about the driver.
 It provides location independency.

An  enterprise  application server  will deal with more clients. As  the number  of clients increase

there is need of a technique that can give efficient services to all clients. In case of distributed
system, each client will create its own object, initialize it, and the JVM has to keep track of each
and every object, so that no longer used object can be garbage­collected. In the same way server
receive the request from more then one client for same type of object. Every time server creates
object for each client, and initializes it. It increases the overhead on the server. 
The solution for minimizing the overhead of server for creating and managing the object is Object
Pooling. It is the technique for organization and reusability of the objects. Connection objects are
most frequent access objects on the server. So we create a pool of these objects. As any request
come from client to create a connection object, server allots one connection object from the pool to
the client thread, after performing all the jobs, the connection object is returned to pool. Before
allocating the pool object, the server checks the authentication and other security credentials. 
By distribution a set of connections along with number of clients, instead of creating them when
required, we can distribute and improve the load on resources and therefore the responsiveness of
the application will be better.

13.Introduction of LDAP

The  Lightweight  Directory  Access  Protocol  (LDAP)  was  developed  in  the  early  1990s  as  a
standard  directory  protocol.  LDAP  is  now  probably  the  most  popular  directory  protocol  and,
because JNDI can access LDAP.

“LDAP defines the mechanism by which clients should be able access data on the serve. It does not
however; give details how the data should be stored on the server.”
LDAP uses the hierarchical tree structure to organize the data, called a Directory Information Tree
(DIT). In DIT each leaf is an entry, and the first entry is called root entry.
An entry contains a Distinguished (DN) and attributes­value pairs related to it. The DN is a unique
name by which entry will be identified, and it works as unique key of relational database table. It
comprises the information how it is related to rest of the DIT, same as the pathname shows how the
file is related to rest of file system.
The path to a file on a system start root to file. A DN reads right to left for example:
 uid=sujjain, oi=people, o=theweb.com
The leftmost part of a DN is called a Relative Distinguished Name (RDN his example would be
uid=scarter.

LDAP attributes often use mnemonics as their names. Some of the more common LDAP attributes
are following.

LDAP Attribute Definition
Cn Common name

Sn Surname
Givename First Name

Uid User ID
Dn Distinguished Name

Mail E­mail address

An attributes can have one or more values. For example, a user can have more than one e­mail
address. Attribute values can be text or binary data and are referred as name­value pairs. 
Attributes also have matching rules. These rules tell the server how it should decide whether a
particular entry is a match or not for a given query . the possible matching rules are:

Matching Rules Meaning
DN Attribute is in the form of a Distinguished Name.

Case­Insensitive String (CIS) Attribute can match if both the query value and the
attribute’s value are equals, regardless of case.
Case­Sensitive String (CSS) Attribute can match if both the query value and the
attribute’s value are equals, including the case.

Integer Attribute match is determined by numbers.
Binary Attribute  matches  if  both  the  query  value  and  the
attribute’s value are the same binary value.

LDAP servers have other following benefits:
  They support reference pointers to other LDAP directories where data is stored. So that just
by one client request a single LDAP server could search millions of entries.
 Reliability and speed is improved by replication of LDAP data.
 LDAP also has a exceptionally strong security model that contains
o ACLs to protect data inside the server.
o Secure Socket Layers (SSL)
o Transport Layer Security (TLS)
o Simple Authentication and Security Layer (SASL) protocols.

Application Areas of LDAP
There are basic three basic applications of LDAP in Java today;
 Access Control
 White Pages Services
 Distributed Computing Directory

Access Control 
All application defines when user has permission to access them. As any user selects
the application to start it, the required credentials are scan to match. Most applications like in
between these two extremes. Access control can be broken into following two part:
 Authentication  is  determining  who  can  work  on  specific  part  of  the  complete
application software. There are various authentication mechanism. 
 Authorization is determining what certain operations are allowed to do with the
application module for that user is authenticated. 

White Page Services
White pages services are services that provides a facility to look up any user based on
attributes contained in their entries. For example, you can look up Mariya’s e­mail address, and
obtain the telephone number of the Accounts office, the building number of Sales Department,
etc. they are called white pages because this type of information you search in the white pages of
US telephone books. 

Distributed Computing Directory
 According  to  the  current  environment  and  current  organization  need  the  distributed
networking  programming  become  the  most  common  solution,  when  different  modules  resides
separately  on  different  machine  (JVM)  of  an  application.  To  implement  this  approach  Java
provides following three distributed architecture:

 Remote Method Invocation (RMI)
 Common Object Request Broker Architecture (CORBA)
 Enterprise Java Beans (EJB)

LDAP Operations
We must first obtain a references and a network connection to the LDAP server, before we can
perform  any  type  of  operation  on  an  LDAP  server.  Then  we  must  also  give  the  authentication
credentials. Some LDAP servers allow some type of anonymous access, with the support of ACL.
Standard LDAP Operations
 Connect to the LDAP server
 Bind to the LDAP server
 Perform a sequence of LDAP operations
o Search the server
o Add a new entry
o Modify an entry
o Delete an entry
 Disconnect from the LDAP server
14.Accessing a database from a JSP page

JSTL (JSP Standard Tag Library) includes a number of actions for database access to make it easy
to develop simple database­driven JSP applications. The actions provide the following features:

 Using a connection pool for better performance and scalability
 Supporting queries, updates, and inserts
 Handling the most common data­type conversions
 Supporting a combination of database operations in one transaction
We need to load JDBC and return a Connection object. We use the Connection object to create a
Statement object. We can either updated the data or generate a ResultSet object.

The steps are as follows:

a. Load the JDBC driver

b. Create a Connection object

c. Create a Statement object and call its executeUpdate method to insert a record

d. Use the same Statement object to obtain a ResultSet object

The  example  below  uses  MySQL  JDBC  driver  to  access  the  Users  table  in  a  MySQL  Server
database named CompanyEmployee. The database server is called xeon and we need to pass the
user  name  "cmp"  and  password  "emp123"  to  log  into  the  database  server.  The  SQL  statement
queries two columns: FirstName and LastName. Upon retrieving the ResultSet, the statement will
loop through it to print all the first names and last names in the ResultSet.

In  this  example,  we  mix  Java  code  with  HTML  to  make  the  example  simpler.  In  real­world
applications, we should always separate Java code into a JavaBean or a custom tag library.

Here is the JSP page.

<html>
<head>
<title>Accessing data in a database</title>
</head>
<body>
<%

try {
  // Step 1. Load the JDBC driver
  Class.forName(".mysql.Driver");
  
  // Step 2. Create a Connection object
  Connection con = DriverManager.getConnection("jdbc:mysql///xeon/CompanyEmployee", 
    "cmp", "emp123");

  System.out.println("got connection");

    // Step 3. Create a Statement object and call its executeUpdate method to insert a record
  Statement s = con.createStatement();
  String sql =   "INSERT INTO Users VALUES ('Michael', 'Franks', '12/12/2003', 'm')";
  s.executeUpdate(sql);

  // Step 4. Use the same Statement object to obtain a ResultSet object
  sql = "SELECT FirstName, LastName FROM Users";
  ResultSet rs = s.executeQuery(sql);
  while (rs.next()) {
    out.println(rs.getString(1) + " " + rs.getString(2) + "<br>");
  }
  rs.close();
  s.close();
  con.close();
}
catch (ClassNotFoundException e1) {
  // JDBC driver class not found, print error message to the console
  System.out.println(e1.toString());
}
catch (SQLException e2) {
  // Exception when executing java.sql related commands, print error message to the console
  System.out.println(e2.toString());
}
catch (Exception e3) {
  // other unexpected exception, print error message to the console
  System.out.println(e3.toString());
}
%>
</body>
</html>

Now, if we open our browser and type in the URL to the JSP page, we can see the data from the
database  displayed  on  it,  as  shown  in  Figure  below.  What  appears  on  the  browser  might  be
different than the Figure, depending on what has been inserted into our table.
 Figure . Displaying data from the database.

15.Application­specific Database Action

We can use JSTL database actions to develop many types of interesting web applications, such as
product  catalog  interfaces,  employee  directories,  or  online  billboards,  without  being  a  Java
programmer. These types of applications account for a high percentage of the web applications
developed  today.  But  at  some  level of  complexity, putting  SQL  statements directly in  the  web
pages can become a maintenance problem. The SQL statements represent business logic, and for
more complex applications, business logic is better developed as separate Java classes.
For a complex application, it may be better to use application­specific custom actions instead of
the  JSTL  database  actions.  For  example,  all  the  generic  database  actions  to  SELECT  and  then
INSERT or UPDATE the database, can be replaced with one application­specific action like this:

<myLib:saveEmployeeInfo dataSource="${example}" />

This action can be implemented so it uses JDBC to access the database directly, similar to how the
JSTL actions work. But at some point it may make sense to migrate the application to an Enterprise
JavaBeans architecture, perhaps to support other types of clients than web browsers. The action
can then be modified to interact with an Enterprise JavaBeans component instead of accessing the
database directly. From the JSP page author's point of view, it doesn't matter; the custom action is
still used exactly the same way. Another approach is to use a servlet for all database processing and
only use JSP pages to show the result. 

16.Developing Java Beans in a JSP page

JavaBeans specification defines a set of programming conventions for Java classes that should be
used as pluggable components. This means that, tools that have no inside information about a class
can use it if it's developed according to these conventions. For instance, a GUI builder tool can
support widgets developed as JavaBeans components.

A  JavaBeans  component  is  often  used  in  JSP  as  the  container  for  the  dynamic  content  to  be
displayed by a web page. It typically represents something specific, such as a person, a product, or
a shopping order. When JSP is combined with servlets, the bean can be created and initialized with
data by the servlet and passed to a JSP page that simply adds the bean's data to the response. But
even in a pure JSP application, a bean is a useful tool, for instance for capturing and validating user
input. A programmer must develop the bean, but someone who doesn't have any programming
experience can then use it in a JSP page. JSP defines a number of standard actions for working
with beans, and the JSTL Expression Language accepts beans as variables in expressions. Now we
take a closer look at what a bean is and how it can produce dynamic content in a page. 
Declaring a Bean in a JSP Page
<html>
<head>
<title>A Cartoon</title>
</head>
<body bgcolor="white">
<h1>Cartoon</h1>
<jsp:useBean id="cartoon"
class="com.ora.jsp.beans.motd.CartoonBean" />
<img src="images/<jsp:getProperty name="cartoon" property="fileName" />">
</body>
</html>

Before  we  use  a  bean  in  a  page,  we  must  tell  the  JSP  container  which  type  of  bean  it  is  and
associate it with a name. In other words, we must declare the bean. The first JSP action in

<jsp:useBean>, is used for this purpose:
<jsp:useBean id="cartoon" class="com.ora.jsp.beans.motd.CartoonBean" />

The <jsp:useBean> action is one of the JSP standard actions (identified by the jsp prefix). The
action creates an instance of the bean class specified by the class attribute and associates it with the
name  specified  by  the  id  attribute.  The  name  must  be  unique  in  the  page  and  be  a  valid  Java
variable name: it must start with a letter and can't contain special characters such as dots, plus
signs,  etc.  Other  attributes  we  can  specify  for  the  <jsp:useBean>  action  are  scope,  type,  and
beanName.

Reading Bean Properties

A bean's data is represented by its properties. The CartoonBean in above example has only one
property,  named  fileName,  but  other  beans  may  have  many  different  properties.  The  fileName
property's value is the name of an image file that contains a cartoon. 

Using the <jsp:getProperty> Action
Once we have created a bean and given it a name using the <jsp:useBean> action, we can get the
bean's  property values  with  another JSP standard action, named <jsp:getProperty>. This action
obtains the current value of a bean property and inserts it directly into the response body.

To include the current fileName property value in the page, simply use this tag:
 <jsp:getProperty name="cartoon" property="fileName" />

The  name  attribute,  set  to  cartoon,  refers  to  the  specific  bean  instance  declared  by  the
<jsp:useBean> action. The <jsp:getProperty> action locates this bean and asks it for the value of
the property specified by the property attribute. In above example, the property value is used as the
src attribute value for an HTML <img> element. 

Setting Bean Properties

If a bean property is writable (write­only or read/write access), we can set the value using another
standard action: <jsp:setProperty>. Table below shows a bean that has a writable property named
category.

17.Introduction to Struts framework

Struts  is  a  framework  that  promotes  the  use  of  the  Model­View­Controller  architecture  for
designing large scale applications. The framework includes a set of custom tag libaries and their
associated Java classes, along with various utility classes. The most powerful aspect of the Struts
framework is its support for creating and processing web­based forms. 

The  Apache  Struts  web  framework  is  a  free  open­source  solution  for  creating  Java  web
applications.  Web  applications  differ  from  conventional  websites  in  that  web  applications  can
create a dynamic response. Many websites deliver only static pages. A web application can interact
with databases and business logic engines to customize a response. 

Web  applications  based  on  Java  Server  Pages  sometimes  combine  database  code,  page  design
code, and control flow code. In practice, we find that unless these concerns are separated, larger
applications become difficult to maintain. 

One way to separate concerns in a software application is to use a Model­View­Controller (MVC)
architecture. The Model represents the business or database code, the View represents the page
design  code,  and  the  Controller  represents  the  navigational  code.  The  Struts  framework  is
designed to help developers create web applications that utilize a MVC architecture. 

The framework provides three key components: 
  A "request" handler provided by the application developer that is mapped to a standard
URI. 

 A  "response"  handler  that  transfers  control  to  another  resource  which  completes  the
response. 

 A tag library that helps developers create interactive form­based applications with server
pages. 

The  framework's  architecture  and  tags  are  buzzword  compliant.  Struts  works  well  with
conventional REST applications and with new technologies like SOAP and AJAX

The Model­View­Controller Architecture

"Model­View­Controller"  is  a  way  to  build  applications  that  promotes  complete  separation
between business logic and presentation. It is not specific to web applications, or Java, or J2EE but
it can be applied to building J2EE web applications.

The "view" is the user interface, the screens that the end user of the application actually sees and
interacts with. In a J2EE web application, views are JSP files. For collecting user input, we will
have a JSP that generates an HTML page that contains one or more HTML forms. For displaying
output like a report, we will have a JSP that generates an HTML page that probably contains one or
more HTML tables. Each of these is a view: a way for the end user to interact with the system,
putting data in, and getting data out.

Figure. Model View Controlloer
When  the  user  clicks  'Submit'  in  an  HTML  form,  the  request  (complete  with  all  the  form
information) is sent to a "controller". In a J2EE web application, controllers are JavaBeans. The
controller's job is to take the data entered by the user (in the HTML form that the JSP generated)
and pass it to the "model", which is a separate Java class that contains actual business logic. The
model does whatever it does (for instance, store the user's data in a database), then returns some
result back to the controller (perhaps a new ID value from the database, or perhaps just a result
code saying "OK, I'm done"). The controller takes this value and figures out what the user needs to
see  next,  and  presents  the  user  with  a  new  view  (for  instance,  a  new  JSP  file  that  displays  a
confirmation that the data they entered was successfully saved).

This  all  sounds  like  a  lot  of  work.  But  there  is  a  point  to  architecting  applications  this  way:
flexibility. The beauty of model­view­controller separation is that new views and controllers can
be created independently of the model. The model  knows nothing of HTML forms or JSP pages.
The  model  defines  a  set  of  business  functions  that  only  ever  get  called  by  controllers,  and  the
controllers act as proxies between the end user (interacting with the view) and the business logic
(encapsulated in the model). This means that we can add a new view and its associated controller,
and the model doesn't know or care that there are now two different ways for human beings to
interact with the application.

Struts Tags

Almost all tags provided by the Struts framework use the following attributes:

Referencing Properties

Bean properties can be referenced in three different ways: simple, nested, or indexed. 
How Struts work

. 

Central  controller  mediates  application  flow  and  delegates  it  to  the  appropriate  handler.  The
handlers are tied to model components. Model encapsulates business logic, control forwarded back
through the Controller to the appropriate View. The forwarding can be determined by consulting a
set  of  mappings  in  configuration  file,  which  provides  a  loose  coupling  between  the  View  and
Model

Three major Components in Struts are:
a. Servlet controller (Controller)
b. Java Server Pages or any other presentation technology (View)
c. Application Business Logic in the form of whatever suits the application (Model)

Struts is focused on Controller. Struts is Model and View independent. Configuration file contains
an action mapping that determines forwarding/navigation. Controller uses mappings to turn HTTP
requests into application actions. Mapping must specify a request path and action to act upon the
request

Review Questions

1. Write  all  the  steps  that  a  Java  program  takes  to  access  the  databases  (Access,  MySQL,
Oracle). (UTU, Odd sem 2011­12)

2. Explain each step with proper syntax. Write a program to establish the connection with the
data  having  fields  name,  roll  number  and  marks.  Read  the  contents  of  this  database  and
display those contents whose marks are greater than 80%. (UTU, Odd sem 2011­12)
3. Explain Struts Framework in detail. (UTU, Odd sem 2011­12)

4. How do you access database from a JSP page­ Explain. (UTU, Odd sem 2011­12)

5. Write a function to create a database connection and retrieve all the records from a table  that
has name="RAHUL".                                                  

6. What is the difference between static and dynamic query? Explain in reference to prepared
statements.                                                                                      

7. Explain various JDBC programming concepts.                               

8. Describe LDAP and Metadata with example.         

9. What  is  JDBC?  Explain  the  different  JDBC  drivers.  Explain  the  steps  of  java  to  database
communication in details.                                                            

10. Write a program to connect to a database query and display the results. 

11. Explain the following:

a. Metadata

b. Design of JDBC    

12. How can you load the drivers?

13. How can you create JDBC statement?

14. What are the different types of statement?

15. What is the usage of PreparedStatement? Discuss with an example.