JDBC

© People Strategists - Duplication is strictly prohibited -
www.peoplestrategists.com

© People Strategists - Duplication is strictly prohibited -
www.peoplestrategists.com
Java Database Connectivity
(JDBC)

JDBC Overview
• JDBC is an Application Programming Interface (API) that allows a Java
programmer to access any kind of tabular data, such as a database in
a Java application.
• JDBC allows the programmers to develop Java applications that can:
• Connect to a data source, such as a database
• Send queries and update statements to the database
• Retrieve and process the results received from the database

JDBC Overview (Contd.)
• JDBC enables programmers to develop data-centric applications that can
access and manipulate data from diverse range of databases.
• For this, JDBC API consists of different types of JDBC drivers, as shown in the
following figure.

Types of Drivers
• A JDBC driver is a collection of Java classes that enables a
programmer to connect a Java application to a certain database.
• There are four types of JDBC drivers to connect with different types of
databases. These are:
• Type 1: JDBC-ODBC Bridge Driver
• Type 2: JDBC-Native API Driver
• Type 3: JDBC-Net Pure Java Driver
• Type 4: Thin driver

Types of Drivers (Contd.)
• Type 1: JDBC-ODBC Bridge Driver:
• While using type 1 driver, a JDBC bridge is used to access ODBC drivers
installed on each client machine.
• To enable this driver to use ODBC, you need to configure a Data Source Name
(DSN) that represents the target database on your system.
• This driver converts JDBC method calls into the ODBC function calls to enable
interactions with the database.
• This driver is easy to use and can be easily connected to any database.
• However, it decreases the performance of the application, as JDBC method
calls need to be converted into the ODBC function.
• Use of type 1 drivers requires installation of ODBC driver on the client
machine.

• Type 1: JDBC-ODBC Bridge Driver:
• The following figure shows the diagrammatic representation of Type 1 driver
use.

• Type 2: JDBC-Native API Driver:
• While using Type 2 driver, JDBC API calls are converted into native C/C++ API
calls, which are unique to the database.
• These drivers are typically provided by the database vendors and used in the
same manner as the JDBC-ODBC Bridge.
• The vendor-specific driver must be installed on each client machine.
• Therefore, when the database is changed, the database specific native API
needs to be installed.
• Use of the type 2 driver improves the application performance as compared
to the type 1 driver.

• Type 2: JDBC-Native API Driver:
• The following figure shows the diagrammatic representation of Type 2 driver
use.

• Type 3: JDBC-Net Pure Java Driver:
• While using Type 3 driver, a three-tier approach is used to access databases,
as shown in the following figure.

• Type 3: JDBC-Net Pure Java Driver:
• This driver uses middleware (application server) that converts JDBC calls
directly or indirectly into the vendor-specific database protocol.
• 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.
• Use of type 3 driver is extremely flexible as it does not require you to install
any vendor specific code on the client and a single driver can provide access
to multiple databases.

• Type 4: Thin driver:
• While using type 4 driver, the JDBC calls are directly converted into the
vendor-specific database protocol.
• Type 4 driver communicates directly with the vendor's database through
socket connection.
• This is the highest performance driver available for the database and is
usually provided by the vendor itself.
• Type 4 driver is the highly flexible and also referred to as thin driver.

java.sql Interfaces Driver, Connection,
Statement
• The core components of JDBC are provided under the java.sql
package.
• These core components includes, but are not limited to:
• JDBC Drivers: Allow establishing a communication between a database and a
Java application. It is available as Driver interface in the java.sql
package.
• Connections: Allow establishing a connection session with the database. It is
available as the Connection interface in the java.sql package.
• Statements: Allow executing static SQL statements and returning the results.
It is available as the Statement interface in the java.sql package. To
execute dynamic SQL statements the PreparedStatement interface is
available in java.sql package.

Statement (Contd.)
• Result Sets: Allow storing the data retrieved as a result of a SQL queries in a
tabular format. It is available as the Statement interface in the java.sql
package.
• Database Meta Data : Allow to get comprehensive information about the
database as a whole. It is available as DatabaseMetaData interface in
java.sql package.
• Result Set Meta Data: Allows to get information about the types and
properties of the columns in the ResultSet object. It is available as the
ResultSetMetaData interface in the java.sql package.
• The preceding JDBC core components help a programmer to establish
a connection with a database and manipulate the required data.

Statement (Contd.)
• To perform different operations on data in a database by using JDBC,
a programmer needs to perform the following steps in an application:
• Import the packages for JDBC
• Register the JDBC driver for the corresponding database
• Create database URL
• Create connection to the database
• Interact with the database

Statement (Contd.)
• Example:
import java.sql.*; //Import statement for JDBC
public class JDBCTest {
public static void main(String[] args)throws
SQLException, ClassNotFoundException {
String userName="root";
String password="MySql";
String URL = "jdbc:mysql://localhost/world";
String driverClass = "com.mysql.jdbc.Driver";

Statement (Contd.)
try{
//Registering JDBC driver
Class.forName(driverClass);
//Creating connection to the database
Connection conn = DriverManager.getConnection(URL,
userName, password);
Statement stmt = conn.createStatement();
ResultSet results = stmt.executeQuery("select * from
city");

Statement (Contd.)
System.out.println("n-------------------------------
-------------------------------------");
while(results.next()){
int id = results.getInt(1);
String name = results.getString(2);
String cc = results.getString(3);
String dist = results.getString(4);
int pop = results.getInt(5);
System.out.println(id + "t" + name + "t" + cc+
"t" + dist+ "t" + pop);
}

Statement (Contd.)
//Closing resultset, statement, and connection
results.close();
stmt.close();
conn.close();
}
catch(Exception e){
System.out.println(e);
}
}
}

Statement (Contd.)
• Output:

Loading a Driver and Establishing a
Connection Using DriverManager
• In the preceding example, the static method, forName() of the
Class class is used to load the database driver.
• An alternative approach to load the database driver is by using the
registerDriver() static method of the DriverManager
class.
• For this, first you need to create an instance of the Driver class.
• Further, you can use the getConnection() static method of the
DriverManager class to establish a connection with the database.

Loading a Driver and Establishing a
Connection Using DriverManager (Contd.)
• Example:
Driver myDriver=new
org.apache.derby.jdbc.ClientDriver();
DriverManager.registerDriver(myDriver);
//Creating database URL
String dbURL = "jdbc:derby://localhost:1527/
University;create=true;user=uni;password=uni@123";
Connection conn=DriverManager.getConnection(dbURL);

Perform CRUD Operations Using JDBC
Interfaces
• The JDBC API provides you with the interfaces that defines the
methods to perform Create, Read, Update, and Delete (CRUD)
operations on the database.
• One of these interfaces is the Statement interface, which defines
most of the methods required to perform CRUD operations.
• The commonly used methods of the Statement interface that help
performing CRUD operations are:
• boolean execute(String sql)
• ResultSet executeQuery(String sql)
• int executeUpdate(String sql)

Interfaces (Contd.)
• boolean execute(String sql)
• Executes the given SQL statement, which may return multiple results.
• Is used in the situations where you are not sure whether the query to be
executed is an insert, update, or delete statement or it is a query to retrieve
data.
• ResultSet executeQuery(String sql)
• Executes the given SQL statement, which returns a single ResultSet
object.
• Is used to execute the queries that retrieve data from the databse.

Interfaces (Contd.)
• int executeUpdate(String sql)
• Executes the given SQL statement, which may be an INSERT, UPDATE, or
DELETE statement or an SQL statement that returns nothing, such as an SQL
DDL statement.
• These methods can be used for different types of database
interactions, such as:
• Create a table
• Insert records
• Select records
• Update records
• Delete records
• Drop a table

Interfaces (Contd.)
• Creating a Table:
• To create a table by using JDBC, you need to execute CREATE TABLE query by
using the executeUpdate() method, as shown in the following code
snippet:

Interfaces (Contd.)
try{
String qry = "CREATE TABLE REGISTRATION " +
"(id INTEGER not NULL, " +
" Name VARCHAR(25), " +
" Address VARCHAR(255), " +
" Email_ID VARCHAR(50), " +
" Phone VARCHAR(50)," +
" PRIMARY KEY ( id ))";

Interfaces (Contd.)
stmt.executeUpdate(qry);
stmt.close();
conn.close();
}catch(Exception e){
e.printStackTrace();
}

Interfaces (Contd.)
• Inserting Records:
• To insert records into a table by using JDBC, you need to execute the
INSERT query by using the executeUpdate() method, as shown in
the following code snippet:

Interfaces (Contd.)
try{
userName, password); Statement stmt =
conn.createStatement();
String qry = "INSERT INTO Registration " +
"VALUES (101, 'Manish', 'F-130, New
Delhi', 'manish@gmail.com', '91+8976546575')";

Interfaces (Contd.)
• Selecting Records:
• To select records from a table by using JDBC, you need to execute the SELECT
query by using the executeQuery() method, as shown in the following
code snippet:

Interfaces (Contd.)
try{
String qry = "SELECT * FROM Registration";
ResultSet results = stmt.executeQuery(qry);

Interfaces (Contd.)
String sName = results.getString(2);
String sAddress = results.getString(3);
String sEmail = results.getString(4);
String sPhone = results.getString(5);
System.out.println(id + "t" + sName + "t" +
sAddress+ "t" + sEmail+ "t" + sPhone);
}

Interfaces (Contd.)
stmt.close();
conn.close();
}
• Output:

Interfaces (Contd.)
• You can obtain meta data information about the database and table
using the DatabaseMetaData and ResultSetMetaData interfaces.
• Some of the commonly used methods of DatabaseMetaData interface
are:
• getURL(): Returns the URL for the DBMS
• getSQLKeywords(): Retrieves a comma-separated list of all of this database's
SQL keywords that are NOT also SQL92 keywords.
• supportsTransactions(): Retrieves whether this database supports
transactions. If not, invoking the method commit is no use, and the isolation
level is TRANSACTION_NONE.
• supportsSelectForUpdate(): Retrieves whether this database supports SELECT
FOR UPDATE statements.

Interfaces (Contd.)
• Some of the commonly used methods of ResultSetMetaData are:
• getColumnCount(): Returns the number of columns in the result set
object.
• getColumnName():Returns the column names in the result set object.
• getColumnTypeName(): Returns the data type of the columns in the
result set object.
• Example:
public static void main(String[] args)throws SQLException,
ClassNotFoundException {

Interfaces (Contd.)
try{
Connection conn = DriverManager.getConnection(URL, userName,
password);
//Starting database interaction
DatabaseMetaData dbmd = conn.getMetaData();

Interfaces (Contd.)
System.out.println(dbmd.getURL());
System.out.println(dbmd.getSQLKeywords());
System.out.println(dbmd.supportsTransactions());
System.out.println(dbmd.supportsSelectForUpdate());
country");
ResultSetMetaData rsmd = results.getMetaData();
for (int i = 1; i <= rsmd.getColumnCount(); i++) {
String colName = rsmd.getColumnName(i);
String colType = rsmd.getColumnTypeName(i);
System.out.println(colName+"t"+colType);
}

Interfaces (Contd.)
results.close();
stmt.close();
conn.close();
}
catch(Exception e){
}
}
}

Interfaces (Contd.)
• Output:

Interfaces (Contd.)
• Updating Records:
• To updates records in a table by using JDBC, you need to execute the UPDATE
query by using the executeUpdate() method, as shown in the following
code snippet:

Interfaces (Contd.)
try{
String qry = "UPDATE Registration " +"SET Address
= 'E-985, New Delhi' WHERE id = 101";

Interfaces (Contd.)
qry = "SELECT * FROM Registration";
}

Interfaces (Contd.)
• Deleting Records:
• To delete records from a table by using JDBC, you need to execute the DELETE
query by using the executeUpdate() method, as shown in the following
code snippet:

Interfaces (Contd.)
try{
String qry = "DELETE FROM Registration WHERE
id = 101";

Interfaces (Contd.)
• Dropping a Table:
• To drop a table by using JDBC, you need to execute the DROP query by using
the executeUpdate() method, as shown in the following code snippet:

Interfaces (Contd.)
try{
String qry = "DROP TABLE REGISTRATION ";
stmt.close();
conn.close();
}

Prepared Statement for Precompiled Queries
• While using JDBC for database interactions, you need to supply values
in the queries while writing code using the instance of the
Statement interface.
• However, if you want to supply the values to the precompiled queries
at the run time, you cannot use the instance of the Statement
interface.
• For this, you need to use the instance of the of the
PreparedStatement interface.

(Contd.)
• The use of the PreparedStatement interface improves
application performance as queries are complied only once.
• To create an instance of the PreparedStatement interface, you
need to use the prepareStatement() method of the Connection
interface, as shown in the following code snippet:
PreparedStatement updateemp = con.prepareStatement
("insert into emp values(?,?,?)");
• In the preceding code snippet, con is an instance of the Connection
interface and ? is the placeholders for which values will be
supplied at runtime.

(Contd.)
• To set the values of the placeholders and execute queries, the
PreparedStatement interface defines various methods, such as:
• public void setInt(int paramIndex, int value)
• public void setString(int paramIndex, String value)
• public void setFloat(int paramIndex, float value)
• public void setDouble(int paramIndex, double value)
• public int executeUpdate()
• public ResultSet executeQuery()

(Contd.)
• Example:
import java.sql.*;
public class PreparedStatementTest {
public static void main(String[] args) {
try{
Connection conn = DriverManager.getConnection(URL, userName,
password); PreparedStatement insertEMP = conn.prepareStatement
("insert into REGISTRATION values(?,?,?,?,?)");

(Contd.)
insertEMP.setInt(1, 102);
insertEMP.setString(2, "Dinesh");
insertEMP.setString(3, "M-260, Navi Mumbai");
insertEMP.setString(4, "dinesh@gmail.com");
insertEMP.setString(5, "91+2045678909");
insertEMP.executeUpdate();
String qry = "SELECT * FROM Registration";

(Contd.)
}

(Contd.)
insertEMP.close();
stmt.close();
conn.close();
}
}
}

(Contd.)
• Output:

Callable Statement for Stored Procedures
• Similar to preapred statements, the callable statements are used to
execute the precompiled queries, which are calls to procedures.
• To use callable statements in your application, you need to create an
instance of the CallableStatement interface.
• This interface defines various methods to set the values at runtime
similar to that of the PreparedStatment interface.
• To create an instance of the CallableStatement interface, you
need to invoke the prepareCall() method of the Connection
interface.

(Contd.)
• Consider an example where you have created a procedure that
updates the employee name in a table. The procedure accepts the ID
and name of an employee and returns the number of rows affected
as an integer value.
• To call this procedure by using callable statement, you can use the
following code snippet:

(Contd.)
try{
Connection conn =
DriverManager.getConnection(URL, userName,
password);
int iParam1 = 102;

(Contd.)
String iParam2 = "Raghav";
String proc = "{call UpdateEMP(?, ?, ?)}";
CallableStatement cs = conn.prepareCall(proc);
cs.setInt(1, iParam1);
cs.setString(2, iParam2);
cs.registerOutParameter(3, java.sql.Types.INTEGER);
cs.executeUpdate();
int oParam = cs.getInt(3);
System.out.println("Updated row count from the proc: "
+ oParam);
}catch(Exception E){
E.printStackTrace();
}

Transactions with JDBC
• The database transactions are managed by using the Connection
object.
• The default mode of connection object is autocommit.
• The autocommit mode allows the statements to be executed and
committed as individual transactions.
• You can change the autocommit mode by using setAutoCommit()
method.
• To control transactions when autocommit mode is false the following
methods are used:
• commit():
• rollback():

Transactions with JDBC
• The commit() method makes permanent all changes since the
previous commit or rollback and releases any database locks held by
the connection.
• The rollback() method drops all changes since the previous commit or
rollback and releases any database locks.
• Example:
import java.sql.*;

Transactions with JDBC (Contd.)
try{
conn.setAutoCommit(false);

stmt.executeUpdate("create table Employee(empno integer,ename
varchar(20),deptno integer)");
stmt.executeUpdate("insert into Employee values(1,'sakre',1)");
stmt.executeUpdate("insert into Employee values(22,'pradeep',1)");
stmt.executeUpdate(" insert into Employee values (37,'vivek',5)");
conn.commit();
stmt.close();
conn.close();
}
catch(Exception e){
}
}
}

• The preceding code will create a table named employee and insert
values inside the table.

Mapping SQL and Java Types
• JDBC defines a standard mapping from the JDBC database types to
Java types.
• For example, a JDBC INTEGER is normally mapped to a Java int.
• The different types of JDBC data types and their equivalent to
standard SQL types and to Java types are:
• CHAR: The SQL CHAR type corresponding to JDBC CHAR is defined in SQL-92
and is supported by all the major databases. It takes a parameter that
specifies the string length. Thus CHAR(12) defines a 12-character string. All
the major databases support CHAR lengths up to at least 254 characters.

Mapping SQL and Java Types (Contd.)
• VARCHAR: The SQL VARCHAR type corresponding to JDBC VARCHAR is defined
in SQL-92 and is supported by all the major databases. It takes a parameter
that specifies the maximum length of the string. Thus VARCHAR(12) defines a
string whose length may be up to 12 characters. All the major databases
support VARCHAR lengths up to 254 characters. When a string value is
assigned to a VARCHAR variable, the database remembers the length of the
assigned string and on a SELECT, it will return the exact original string.
• Java programmers do not need to distinguish among the three types of JDBC
strings, CHAR, VARCHAR, and LONGVARCHAR. Each can be expressed as a Java
String, and it is possible to read and write an SQL statement correctly
without knowing the exact data type that was expected.

• BINARY: The SQL BINARY type corresponding to JDBC BINARY is a non-
standard SQL extension and is only implemented on some databases. It takes
a parameter that specifies the number of binary bytes. Thus BINARY(12)
defines a 12-byte binary type. Typically, BINARY values are limited to 254
bytes.
• VARBINARY: The SQL VARBINARY type corresponding to JDBC VARBINARY is a
non-standard SQL extension and is only implemented on some databases. It
takes a parameter that specifies the maximum number of binary bytes. Thus
VARBINARY(12) defines a binary type whose length may be up to 12 bytes.
Typically, VARBINARY values are limited to 254 bytes. When a binary value is
assigned to a VARBINARY variable, the database remembers the length of the
assigned value and on a SELECT, it will return the exact original value.

• BINARY, VARBINARY, and LONGVARBINARY can all be expressed identically as
byte arrays in Java. Since it is possible to read and write SQL statements
correctly without knowing the exact BINARY data type that was expected,
there is no need for Java programmers to distinguish among them.
• TINYINT:
• The JDBC type TINYINT represents an 8-bit unsigned integer value between 0 and 255.
• The corresponding SQL type, TINYINT, is currently supported by only a subset of the
major databases.
• The recommended Java mapping for the JDBC TINYINT type is as either a Java byte or a
Java short. The 8-bit Java byte type represents a signed value from -128 to 127, so it may
not always be appropriate for larger TINYINT values, whereas the 16-bit Java short will
always be able to hold all TINYINT values.

• SMALLINT:
• The JDBC type SMALLINT represents a 16-bit signed integer value between -32768 and
32767.
• The corresponding SQL type, SMALLINT, is defined in SQL-92 and is supported by all the
major databases. The SQL-92 standard leaves the precision of SMALLINT up to the
implementation, but in practice, all the major databases support at least 16 bits.
• The recommended Java mapping for the JDBC SMALLINT type is as a Java short.
• INTEGER:
• The JDBC type INTEGER represents a 32-bit signed integer value between - 2147483648
and 2147483647.
• The corresponding SQL type, INTEGER, is defined in SQL-92 and is widely supported by all
the major databases. The SQL-92 standard leaves the precision of INTEGER up to the
implementation, but in practice all the major databases support at least 32 bits.
• The recommended Java mapping for the INTEGER type is as a Java int.

• BIGINT:
• The JDBC type BIGINT represents a 64-bit signed integer value
between -9223372036854775808 and 9223372036854775807.
• The corresponding SQL type BIGINT is a non-standard extension to SQL. In practice the
SQL BIGINT type is not yet currently implemented by any of the major databases, and we
recommend that its use should be avoided in portable code.
• The recommended Java mapping for the BIGINT type is as a Java long.
• REAL:
• The JDBC type REAL represents a "single precision" floating point number which supports
7 digits of mantissa.
• The corresponding SQL type REAL is defined in SQL-92 and is widely, though not
universally, supported by the major databases.
• The recommended Java mapping for the REAL type is as a Java float.

• DOUBLE:
• The JDBC type DOUBLE represents a "double precision" floating point number which
supports 15 digits of mantissa.
• The corresponding SQL type is DOUBLE PRECISION, which is defined in SQL- 92 and is
widely supported by the major databases.
• The recommended Java mapping for the DOUBLE type is as a Java double.
• FLOAT:
• The JDBC type FLOAT is basically equivalent to the JDBC type DOUBLE. FLOAT represents
a "double precision" floating point number that supports 15 digits of mantissa.
• The corresponding SQL type FLOAT is defined in SQL-92. The SQL-92 standard leaves the
precision of FLOAT up to the implementation, but in practice all the major databases
supporting FLOAT support a mantissa precision of at least 15 digits.
• The recommended Java mapping for the FLOAT type is as a Java double.

• DECIMAL and NUMERIC:
• The JDBC types DECIMAL and NUMERIC are very similar. They both represent fixed-
precision decimal values.
• The corresponding SQL types DECIMAL and NUMERIC are defined in SQL-92 and are very
widely implemented. These SQL types takes precision and scale parameters. The
precision is the total number of decimal digits supported, and the scale is the number of
decimal digits after the decimal point. The scale must always be less than or equal to the
precision.
• The recommended Java mapping for the DECIMAL and NUMERIC types is
java.math.BigDecimal, a Java type that also expresses fixed-point numbers with
absolute precision. The java.math.BigDecimal type provides math operations to
allow BigDecimal types to be added, subtracted, multiplied, and divided with other
BigDecimal types, with integer types, and with floating point types.

• DATE, TIME, and TIMESTAMP:
• The JDBC DATE type represents a date consisting of day, month, and year. The
corresponding SQL DATE type is defined in SQL-92, but it is implemented by only a subset
of the major databases. Some databases offer alternative SQL types that support similar
semantics.
• The JDBC TIME type represents a time consisting of hours, minutes, and seconds. The
corresponding SQL TIME type is defined in SQL-92, but it is implemented by only a subset
of the major databases. As with DATE, some databases offer alternative SQL types that
support similar semantics.
• The JDBC TIMESTAMP type represents DATE plus TIME plus a nanosecond field. The
corresponding SQL TIMESTAMP type is defined in SQL-92, but it is implemented by only a
very small number of databases.

• Because the standard Java class java.util.Date does not match any of these three
JDBC date-time types exactly, JDBC defines three subclasses of java.util.Date to
correspond to the SQL types. They are:
• java.sql.Date for SQL DATE information. The hour, minute, second, and millisecond
fields of the java.util.Date base class are set to zero.
• java.sql.Time for SQL TIME information. The year, month, and day fields of the
java.util.Date base class are set to 1970, January, and 1. This is the "zero" date in the
Java epoch.
• java.sql.Timestamp for SQL TIMESTAMP information. This class extends
java.util.Date by adding a nanosecond field.

• Example
try{

//Starting database interaction
country");
ResultSetMetaData rsmd = results.getMetaData();
for (int i=1; i<=8; i++){
//Printing column names
System.out.print(rsmd.getColumnLabel(i)+"t");
}

String code = results.getString(1);
String name = results.getString(2);
String continent = results.getString(3);
String region = results.getString(4);
float sa = results.getFloat(5);
short iy=results.getShort(6);
int pop=results.getInt(7);
float le=results.getFloat(8);
System.out.println(code + "t" + name + "t" +
continent+
"t" +region+ "t" +
sa+"t"+iy+"t"+pop+"t"+le);
}

results.close();
stmt.close();
conn.close();
}
catch(Exception e){
}
}
}

• Output:

Summary
• You have learnt that:
• JDBC is an Application Programming Interface (API) that allows a Java
programmer to access any kind of tabular data, such as a database in a Java
application.
• JDBC enables programmers to develop data-centric applications that can
access and manipulate data from diverse range of databases.
• A JDBC driver is a collection of Java classes that enables a programmer to
connect a Java application to a certain database.
• There are four types of JDBC drivers to connect with different types of
databases.
• The core components of JDBC are provided under the java.sql package.

JDBC

More Related Content

What's hot

Similar to JDBC

More from People Strategists

Recently uploaded

JDBC