Database Connectivity

Enterprise Application Development

Sanjay Goel

04/24/25 1
 Topics
• Overview
– JDBC
– Types of Drivers
– API
• Connecting to Databases
• Executing Queries & Retrieving Results
• Advanced Topics
– Prepared Statements
– Connection Pooling
• Assignment
04/24/25 2
 Overview

04/24/25 3
 JDBC
Definition
• JDBC: Java Database Connectivity
– It provides a standard library for Java programs to
connect to a database and send it commands using
SQL
– It generalizes common database access functions
into a set of common classes and methods
– Abstracts vendor specific details into a code library
making the connectivity to multiple databases
transparent to user
• JDBC API Standardizes:
– Way to establish connection to database
– Approach to initiating queries
– Method to create stored procedures
– Data structure of the query result
04/24/25 4
 JDBC
API
• Two main packages java.sql and javax.sql
– Java.sql contains all core classes required for accessing
database
(Part of Java 2 SDK, Standard Edition)
– Javax.sql contains optional features in the JDBC 2.0 API
(part of Java 2 SDK, Enterprise Edition)
• Javax.sql adds functionality for enterprise
applications
– DataSources
– JNDI
– Connection Pooling
– Rowsets
– Distributed Transactions

04/24/25 5
 JDBC
Architecture
• JDBC Consists of two
parts:
– JDBC API, a purely Java-
based API
– JDBC Driver Manager,
which communicates
with vendor-specific
drivers that perform the
real communication with
the database
• Translation to the vendor
format occurs on the client
– No changes needed to
the server
– Driver (translator)
04/24/25 needed on client 6
 JDBC
Drivers
• JDBC uses drivers to translate
generalized JDBC calls into vendor-
specific database calls
– Drivers exist for most popular
databases
– Four Classes of JDBC drivers exist
Type I
Type II
Type III
Type IV

04/24/25 7
 JDBC
Drivers (Type I)
• Type I driver provides mapping between JDBC and access API of a
database
– The access API calls the native API of the database to establish communication
• A common Type I driver defines a JDBC to ODBC bridge
– ODBC is the database connectivity for databases
– JDBC driver translates JDBC calls to corresponding ODBC calls
– Thus if ODBC driver exists for a database this bridge can be used to
communicate with the database from a Java application
• Inefficient and narrow solution
– Inefficient, because it goes through multiple layers
– Narrow, since functionality of JDBC code limited to whatever ODBC supports
Driver (Type I)

ODBC API
Native API
Client
Application Database
API Database
Protocol Specific
Protocol

04/24/25 8
 JDBC
Open Database Connectivity (ODBC)
• A standard database access method
developed by the SQL Access group
in 1992. ODBC Interface
– The goal of ODBC is to make it
possible to access any data from any
application, regardless of which
database management system
(DBMS) is handling the data.
– ODBC manages this by inserting a
middle layer, called a database
driver , between an application and
the DBMS.
– The purpose of this layer is to
translate the application's data
queries into commands that the
DBMS understands.
– For this to work, both the application
and the DBMS must be ODBC-
compliant, that is, the application
must be capable of issuing ODBC
commands and the DBMS must be
04/24/25capable of responding to them. 9
 JDBC
Drivers (Type II)
• Type II driver communicates directly with
native API
– Type II makes calls directly to the native API
calls
– More efficient since there is one less layer to
contend with (i.e. no ODBC)
– It is dependent on the existence of a native
API for a database
Driver (Type II)

Native API
Client
Application Database
API Database
Protocol Specific
Protocol

04/24/25 10
 JDBC
Drivers (Type III)
• Type III driver make calls to a middleware
component running on another server
– This communication uses a database independent net
protocol
– Middleware server then makes calls to the database
using database-specific protocol
– The program sends JDBC call through the JDBC driver
to the middle tier
– Middle-tier may use Type I or II JDBC driver to
communicate with the database.
Driver (Type III)

Client Middleware
Application Net Protocol Server Database Database
Specific
Protocol

04/24/25 11
 JDBC
Drivers (Type IV)
• Type IV driver is an all-Java driver that is also
called a thin driver
– It issues requests directly to the database using its
native protocol
– It can be used directly on platform with a JVM
– Most efficient since requests only go through one
layer
– Simplest to deploy since no additional libraries or
middle-ware
Driver (Type IV)

Client
Application Database Specific Database
Protocol

04/24/25 12
 Connecting to Database

04/24/25 13
 JDBC
Conceptual Components
• Driver Manager: Loads database drivers and manages
connections between the application and the driver
• Driver: Translates API calls into operations for specific
database
• Connection: Session between application and data source
• Statement: SQL statement to perform query or update
• Metadata: Information about returned data, database, &
driver
• Result Set: Logical set of columns and rows of data returned
by executing a statement
Creates Creates Creates
DriverManager Connection Statement Result Set

Driver
Established
Link to DB

Database
04/24/25 14
JDBC
Basic Steps
• Import the necessary classes
• Load the JDBC driver
• Identify the data source (Define the
Connection URL)
• Establish the Connection
• Create a Statement Object
• Execute query string using Statement Object
• Retrieve data from the returned ResultSet
Object
• Close ResultSet & Statement & Connection
Object in order

04/24/25 15
 JDBC
Driver Manager
• DriverManager provides a common access
layer on top of different database drivers
– Responsible for managing the JDBC drivers available
to an application
– Hands out connections to the client code
• Maintains reference to each driver
– Checks with each driver to determine if it can handle
the specified URL
– The first suitable driver located is used to create a
connection
• DriverManager class can not be instantiated
– All methods of DriverManager are static
– Constructor is private

04/24/25 16
 JDBC Driver
Loading
• Required prior to communication with a database using
JDBC
• It can be loaded
– dynamically using Class.forName(String drivername)
– System Automatically loads driver using jdbc.drivers
system property
• An instance of driver must be registered with
DriverManager class
• Each Driver class will typically
– create an instance of itself and register itself with the
driver manager
– Register that instance automatically by calling
RegisterDriver method of the DriverManager class
• Thus the code does not need to create an instance of the
class or register explicitly using registerDriver(Driver)
class
04/24/25 17
JDBC Driver
Loading: class.forName()
• Using forName(String) from java.lang.Class
instructs the JVM to find, load and link the class
identified by the String
e.g try {
Class.forName(“COM.cloudscape.core.JDBCDriver”);
} catch (ClassNotFoundException e) {
System.out.println(“Driver not found”);
e.printStackTrace();
}
• At run time the class loader locates the driver
class and loads it
– All static initializations during this loading
– Note that the name of the driver is a literal string
thus the driver does not need to be present at compile
04/24/25 time 18
 JDBC Driver
Loading: System Property
• Put the driver name into the jdbc drivers System property
– When a code calls one of the methods of the driver manager, the
driver manager looks for the jdbc.drivers property
– If the driver is found it is loaded by the Driver Manager
– Multiple drivers can be specified in the property
– Each driver is listed by full package specification and class name
– a colon is used as the delimiter between the each driver
e.g jdbc.drivers=com.pointbase.jdbc.jdbcUniversalDriver
• For specifying the property on the command line use:
– java -Djdbc.drivers=com.pointbase.jdbc.jdbcUniversalDriver
MyApp
• A list of drivers can also be provided using the Properties file
– System.setProperty(“jdbc.drivers”,
“COM.cloudscape.core.JDBCDriver”);
– DriverManager only loads classes once so the system property
must be set prior to the any DriverManager method being called.
04/24/25 19
 JDBC
URLs
• JDBC Urls provide a way to identify a database
• Syntax:
<protocol>:<subprotocol>:<protocol>
– Protocol: Protocol used to access database (jdbc
here)
– Subprotocol: Identifies the database driver
– Subname: Name of the resource
• Example
– Jdbc:cloudscape:Movies
– Jdbc:odbc:Movies

04/24/25 20
 Connection
Creation
• Required to communicate with a database via JDBC
• Three separate methods:
public static Connection getConnection(String url)
public static Connection getConnection(String url, Properties info)
public static Connection getConnection(String url, String user, String
password)
• Code Example (Access)
try {// Load the driver class
System.out.println("Loading Class driver");
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
// Define the data source for the driver
String sourceURL = "jdbc:odbc:music”;
// Create a connection through the DriverManager class
System.out.println("Getting Connection");
Connection databaseConnection =
DriverManager.getConnection(sourceURL);
}
catch (ClassNotFoundException cnfe) {
System.err.println(cnfe); }
catch (SQLException sqle) {
04/24/25 System.err.println(sqle);} 21
 Connection
Creation
• Code Example (Oracle)
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
String sourceURL =
"jdbc:oracle:thin:@delilah.bus.albany.edu:1521:databasename";
String user = "goel";
String password = "password";
Connection
databaseConnection=DriverManager.getConnection(sourceURL,user,
password );
System.out.println("Connected Connection"); }
catch (ClassNotFoundException cnfe) {
System.err.println(cnfe); }
catch (SQLException sqle) {
System.err.println(sqle);}

04/24/25 22
 Connection
Closing
• Each machine has a limited number of connections (separate thread)
– If connections are not closed the system will run out of resources and freeze
– Syntax: public void close() throws SQLException

• Naïve Way: • Correct way (Use the finally

try { clause)
Connection conn try{
= Connection conn =
DriverManager.getConnection(url); Driver.Manager.getConnection(url)
// Jdbc Code ;
… // JDBC Code
} catch (SQLException sqle) { } catch (SQLException sqle) {
sqle.printStackTrace(); sqle.printStackTrace();
} } finally {
conn.close(); try {
conn.close();
• SQL exception in the Jdbc code will
} catch (Exception e) {
prevent execution to reach e.printStackTrace();
conn.close() }
}
04/24/25 23
 Statement
Types
• Statements in JDBC abstract the SQL
statements
• Primary interface to the tables in the database
• Used to create, retrieve, update & delete data
(CRUD) from a table
– Syntax: Statement statement =
connection.createStatement();
• Three types of statements each reflecting a
specific SQL statements
– Statement
– PreparedStatement
– CallableStatement

04/24/25 24
 Statement
Syntax
• Statement used to send SQL commands to the database
– Case 1: ResultSet is non-scrollable and non-updateable
public Statement createStatement() throws SQLException
Statement statement = connection.createStatement();
– Case 2: ResultSet is non-scrollable and/or non-updateable
public Statement createStatement(int, int) throws SQLException
Statement statement = connection.createStatement();
– Case 3: ResultSet is non-scrollable and/or non-updateable and/or
holdable
public Statement createStatement(int, int, int) throws SQLException
Statement statement = connection.createStatement();
• PreparedStatement
public PreparedStatement prepareStatement(String sql) throws
SQLException
PreparedStatement pstatement = prepareStatement(sqlString);
• CallableStatement used to call stored procedures
public CallableStatement prepareCall(String sql) throws SQLException
04/24/25 25
 Statement
Release
• Statement can be used try{
multiple times for sending a Connection conn =
query Driver.Manager.getConnec
• It should be released when it tion(url);
is no longer required Statement stmt =
– Statement.close():
conn.getStatement();
– It releases the JDBC resources
// JDBC Code
immediately instead of waiting } catch (SQLException
for the statement to close sqle) {
automatically via garbage
collection sqle.printStackTrace();
• Garbage collection is done } finally {
when an object is unreachable try {stmt.close();
– An object is reachable if there conn.close();
is a chain of reference that } catch (Exception e) {
reaches the object from some
root reference
e.printStackTrace();
• Closing of the statement }
should be in the finally clause
04/24/25 } 26
 JDBC
Logging
• DriverManager provides methods for managing
output
– DriverManagers debug output can be directed to a
printwriter
public static void setLogWriter(PrintWriter pw)
– PrintWriter can be wrapped for any writer or OutputStream
– Debug statements from the code can be sent to the log as
well.
public static void println(String s)
• Code
FileWriter fw = new FileWriter(“mydebug.log”);
PrintWriter pw = new PrintWriter(fw);
// Set the debug messages from Driver manager to pw
DriverManager.setLogWriter(pw);
// Send in your own debug messages to pw
DriverManager.println(“The name of the database is “ +
04/24/25databasename); 27
 Querying the Database

04/24/25 28
 Executing Queries
Methods
• Two primary methods in statement interface used
for executing Queries
– executeQuery Used to retrieve data from a database
– executeUpdate: Used for creating, updating & deleting
data
• executeQuery used to retrieve data from database
– Primarily uses Select commands
• executeUpdate used for creating, updating &
deleting data
– SQL should contain Update, Insert or Delete commands
• Uset setQueryTimeout to specify a maximum delay
to wait for results

04/24/25 29
 Executing Queries
Data Definition Language (DDL)
• Data definition language queries use executeUpdate
• Syntax: int executeUpdate(String sqlString) throws
SQLException
– It returns an integer which is the number of rows updated
– sqlString should be a valid String else an exception is
thrown
• Example 1: Create a new table
Statement statement = connection.createStatement();
String sqlString =
“Create Table Catalog”
+ “(Title Varchar(256) Primary Key Not Null,”+
+ “LeadActor Varchar(256) Not Null, LeadActress Varchar(256)
Not Null,”
+ “Type Varchar(20) Not Null, ReleaseDate Date Not NULL )”;
Statement.executeUpdate(sqlString);
–
04/24/25 executeUpdate returns a zero since no row is updated 30
 Executing Queries
DDL (Example)
• Example 2: Update table
Statement statement = connection.createStatement();
String sqlString =
“Insert into Catalog”
+ “(Title, LeadActor, LeadActress, Type, ReleaseDate)”
+ “Values(‘Gone With The Wind’, ‘Clark Gable’, ‘Vivien
Liegh’,”
+ “’Romantic’, ‘02/18/2003’ ”
Statement.executeUpdate(sqlString);
– executeUpdate returns a 1 since one row is added

04/24/25 31
 Executing Queries
Data Manipulation Language (DML)
• Data definition language queries use executeQuery
• Syntax
ResultSet executeQuery(String sqlString) throws
SQLException
– It returns a ResultSet object which contains the results of the
Query
• Example 1: Query a table
Statement statement = connection.createStatement();
String sqlString = “Select Catalog.Title, Catalog.LeadActor,
Catalog.LeadActress,” +
“Catalog.Type, Catalog.ReleaseDate
From Catalog”;
ResultSet rs = statement.executeQuery(sqlString);

04/24/25 32
 ResultSet
Definition
• ResultSet contains the results of the database query that
are returned
• Allows the program to scroll through each row and read all
columns of data
• ResultSet provides various access methods that take a
column index or column name and returns the data
– All methods may not be applicable to all resultsets depending
on the method of creation of the statement.
• When the executeQuery method returns the ResultSet the
cursor is placed before the first row of the data
– Cursor refers to the set of rows returned by a query and is
positioned on the row that is being accessed
– To move the cursor to the first row of data next() method is
invoked on the resultset
– If the next row has a data the next() results true else it returns
false and the cursor moves beyond the end of the data
• 04/24/25
First column has index 1, not 0 33
 ResultSet
• ResultSet contains the results of the database query that are
returned
• Allows the program to scroll through each row and read all
the columns of the data
• ResultSet provides various access methods that take a column
index or column name and returns the data
– All methods may not be applicable to all resultsets depending on
the method of creation of the statement.
• When the executeQuery method returns the ResultSet the
cursor is placed before the first row of the data
– Cursor is a database term that refers to the set of rows returned
by a query
– The cursor is positioned on the row that is being accessed
– First column has index 1, not 0
• Depending on the data numerous functions exist
– getShort(), getInt(), getLong()
– getFloat(), getDouble()
– getClob(), getBlob(),
04/24/25 34
– getDate(), getTime(), getArray(), getString()
 ResultSet
• Examples:
– Using column Index:
Syntax:public String getString(int columnIndex) throws
SQLException
e.g. ResultSet rs = statement.executeQuery(sqlString);
String data = rs.getString(1)
– Using Column name
public String getString(String columnName) throws
SQLException
e.g. ResultSet rs = statement.executeQuery(sqlString);
String data = rs.getString(Name)
• The ResultSet can contain multiple records.
– To view successive records next() function is used on the
ResultSet
– Example: while(rs.next()) {
–
04/24/25 System.out.println(rs.getString); } 35
 Scrollable ResultSet
• ResultSet obtained from the statement created using the no argument
constructor is:
– Type forward only (non-scrollable)
– Not updateable
• To create a scrollable ResultSet the following statement constructor is
required
– Statement createStatement(int resultSetType, int resultSetConcurrency)
• ResultSetType determines whether it is scrollable. It can have the
following values:
– ResultSet.TYPE_FORWARD_ONLY
– ResultSet.TYPE_SCROLL_INSENSITIVE (Unaffected by changes to
underlying database)
– ResultSet.TYPE_SCROLL_SENSITIVE (Reflects changes to underlying
database)
• ResultSetConcurrency determines whether data is updateable. Its
possible values are
– CONCUR_READ_ONLY
– CONCUR_UPDATEABLE
• Not all
04/24/25 database drivers may support these functionalities 36
 Scrollable ResultSet
• On a scrollable ResultSet the following commands can be
used
– boolean next(), boolean previous(), boolean first(), boolean
last()
– void afterLast(), void beforeFirst()
– boolean isFirst(), boolean isLast(), boolean isBeforeFirst(),
boolean isAfterLast()
• Example

04/24/25 37
 RowSet
• ResultSets limitation is that it needs to stay connected to the data
source
– It is not serializable and can not transporting across the network
• RowSet is an interface which removes the limitation
– It can be connected to a dataset like the ResultSet
– It can also cache the query results and detach from the database
• RowSet is a collection of rows
• RowSet implements a custom reader for accessing any tabular
data
– Spreadsheets, Relational Tables, Files
• RowSet object can be serialized and hence sent across the network
• RowSet object can update rows while diconnected fro the data
source
– It can connect to the data source and update the data
• Three separate implementations of RowSet
– CachedRowSet
– JdbcRowSet
04/24/25
– WebRowSet 38
 RowSet
• RowSet is derived from the BaseRowSet
– Has SetXXX(…) methods to supply necessary information for
making connection and executing a query
• Once a RowSet gets populated by execution of a query or
from some other data source its data can be manipulated or
more data added
• Three separate implementations of RowSet exist
– CachedRowSet: Disconnected from data source, scrollable &
serilaizable
– JdbcRowSet: Maintains connection to data source
– WebRowSet: Extension of CachedRowSet that can produce
representation of its contents in XML

04/24/25 39
 MetaData
• Meta Data means data about data
• Two kinds of meta data in JDBC
– Database Metadata: To look up information about the database (here)
– ResultSet Metadata: To get the structure of data that is returned
(later)
• Example
– connection.getMetaData().getDatabaseProductName()
– connection.getMetaData().getDatabaseProductVersion()
• Sample Code:
private void showInfo(String driver,String url,String user,String password,
String table,PrintWriter out) {
Class.forName(driver);
Conntection con = DriverManager.getConnection(url, username, password);
DatabaseMetaData dbMetaData = connection.getMetaData();
String productName = dbMetaData.getDatabaseProductName();
System.out.println("Database: " + productName);
String productVersion = dbMetaData.getDatabaseProductVersion();
System.out.println("Version: " + productVersion);
}
04/24/25 40
 Source Code

04/24/25 41
 Connecting to Microsoft Access
/** // Load the driver
* The code allows a user to connect to the MS Access Database and try {
* run queries on the database. A sample query execution is provided // Load the driver class
* in this code. This is developed to help the students get initially Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
* connected to the database.
* // Define the data source for the driver
String sourceURL = "jdbc:odbc:music";
* @author Sanjay Goel
* @company School of Business, University at Albany
// Create a connection through the DriverManager class
*
Connection databaseConnection
* @version 1.0
= DriverManager.getConnection(sourceURL);
* @created April 01, 2002 - 9:05 AM System.out.println("Connected Connection");
*
* Notes 1: Statement is an interface hence can not be instantiated // Create Statement
* using new. Need to call createStatement method of connection class Statement statement = databaseConnection.createStatement();
* String queryString
* Notes 2: Use executeQuery for DML queries that return a resultset = "SELECT recordingtitle, listprice FROM recordings";
* e.g., SELECT and Use executeUpdate for DDL & DML which do not
* return Result Set e.g. (Insert Update and Delete) & DDL (Create // Execute Query
* Table, Drop Table, Alter Table) ResultSet results = statement.executeQuery(queryString);
*
* */ // Print results
while (results.next()){
System.out.println(results.getString("recordingtitle") +
import java.sql.*;
"\t" +
results.getFloat("listprice"));
public class ConnectAccess { }

/** // Close Connection

* This is the main function which connects to the Access database databaseConnection.close();
* and runs a simple query }
* catch (ClassNotFoundException cnfe) {
* @param String[] args - Command line arguments for the program System.err.println(cnfe);
* @return void }
* @exception none catch (SQLException sqle) {
* System.err.println(sqle);
*/ }
}
public static void main(String[] args) {
}

04/24/25 42
 Connecting to Oracle
/** // Load the driver
* The code allows a user to connect to the ORACLE Database and run try {
* queries on the database. A sample query execution is provided in // Load the driver class
* this code. This is developed to help the students get initially Class.forName("oracle.jdbc.driver.OracleDriver");
* connected to the database.
* // Define the data source for the driver
* @author Sanjay Goel String sourceURL
* @company School of Business, University at Albany =
* "jdbc:oracle:thin:@delilah.bus.albany.edu:1521:bodb01";
* @version 1.0
* @created April 01, 2002 - 9:05 AM // Create a connection through the DriverManager class
* String user = "goel";
* Notes 1: Statement is an interface hence can not be instantiated String password = "goel";
* using new. Need to call createStatement method of connection class Connection databaseConnection
* = DriverManager.getConnection(sourceURL, user,
* Notes 2: Use executeQuery for DML queries that return a resultset password);
* e.g., SELECT and Use executeUpdate for DDL & DML which do not System.out.println("Connected to Oracle");
* return Result Set e.g. (Insert Update and Delete) & DDL (Create
* Table, Drop Table, Alter Table) // Create a statement
* Statement statement = databaseConnection.createStatement();
* */
// Create a query String
import java.sql.*; String sqlString = "SELECT artistid, artistname FROM
artistsandperformers";

public class ConnectOracle {

// Close Connection
databaseConnection.close();
/**
}
* This is the main function which connects to the Oracle database
catch (ClassNotFoundException cnfe) {
* and executes a sample query
System.err.println(cnfe);
*
}
* @param String[] args - Command line arguments for the program
catch (SQLException sqle) {
* @return void
System.err.println(sqle);
* @exception none
}
*
}
*/
}
public static void main(String[] args) {

04/24/25 43
 Connecting to Cloudscape
/** // Create a connection through the DriverManager class
* The code allows a user to connect to the Cloudscape Database and Connection databaseConnection =
* run queries on the database. A sample query execution is provided DriverManager.getConnection(sourceURL);
* in this code. This is developed to help the students get initially System.out.println("Connected Connection");
* connected to the database.
* // Create a statement
* @author Sanjay Goel Statement statement = databaseConnection.createStatement();
* @company School of Business, University at Albany
* // Create an SQL statement
* @version 1.0 String sqlString = "SELECT artistid, artistname FROM
* @created April 01, 2002 - 9:05 AM artistsandperformers";
*
* Notes 1: Statement is an interface hence can not be instantiated // Run Query
* using new. Need to call createStatement method of connection class ResultSet results = statement.executeQuery(sqlString);
*
* Notes 2: Use executeQuery for DML queries that return a resultset // Print Results
* e.g., SELECT and Use executeUpdate for DDL & DML which do not while(results.next()) {
* return Result Set e.g. (Insert Update and Delete) & DDL (Create System.out.println(results.getInt("artistid") + "\t" +
* Table, Drop Table, Alter Table)
results.getString("artistname"));
*
}
* */
// Close Connection
import java.sql.*;
databaseConnection.close();
}
public class ConnectCloudscape {
catch (ClassNotFoundException cnfe) {
System.err.println(cnfe);
public static void main(String[] args) {
}
catch (SQLException sqle) {
// Load the driver
System.err.println(sqle);
try {
}
// Load the driver class
}
Class.forName("COM.cloudscape.core.JDBCDriver");
}

// Define the data source for the driver

String sourceURL = "jdbc:cloudscape:Wrox4370.db";

04/24/25 44
 Prepared Statement
Import java.sql.*; // code from IVOr horton

public class AuthorDatabase {

public static void main(String[] args) {
try {
String url = “jdbc:odbc:library”;
String driver = “sun.jdbc.odbc.JdbcOdbcDriver”;
String user = “goel”
String password = “password”;
// Load the Driver
Class.forName(driver);
Connection connection = DriverManager.getConnection();
String sqlString = “UPDATE authors SET lastname = ? Authid = ?”;
PreparedStatement ps = connection.prepareStatement(sqlString);
// Sets first placeholder to Allamaraju
ps.setString(1, “Allamaraju”);
// Sets second placeholder to 212
ps.setString(2, 212);
// Executes the update
int rowsUpdated = ps.executeUpdate();
System.out.println(“Number of rows changed = “ + rowsUpdated);
connection.close();
}
catch (ClassNotFoundException cnfe) {
System.out.println(“Driver not found”);
cnfe.printStackTrace();
}
catch (SQLException sqle) {
System.out.println(“Bad SQL statement”);
sqle.printStackTrace();
}

}
}

04/24/25 45
 Access Data Source
• Create a database
• Select DataSources (ODBC) from the control panel
(Start Settings ControlPanelDataSourcesAdministrativeToolsData
Sources)
• Select the System DSN tab
• On ODBC data source administrator click on add
• Select the database driver as Microsoft Access Driver

04/24/25 46
 Access Data Source
• Fill the ODBC Microsoft Access Setup Form
– Write Data Source Name (Name of the data source that
you have in the program)
– Add description of database
– Click on select and browse the directory to pick a
database file
– Click on OK

04/24/25 47
 Advanced Topics

04/24/25 48
 JDBC – Data Types

04/24/25 49
 Prepared Statement
• PreparedStatement provides a means to create a
reusable statement that is precompiled by the
database
• Processing time of an SQL query consists of
– Parsing the SQL string
– Checking the Syntax
– Checking the Semantics
• Parsing time is often longer than time required to
run the query
• PreparedStatement is used to pass an SQL string
to the database where it can be pre-processed for
execution

04/24/25 50
 Prepared Statement
• It has three main uses
– Create parameterized statements such that data for
parameters can be dynamically substituted
– Create statements where data values may not be
character strings
– Precompiling SQL statements to avoid repeated
compiling of the same SQL statement
• If parameters for the query are not set the driver
returns an SQL Exception
• Only the no parameters versions of
executeUpdate() and executeQuery() allowed with
prepared statements.

04/24/25 51
 Prepared Statement
• Example
// Creating a prepared Statement
String sqlString = “UPDATE authors SET lastname = ? Authid =
?”;
PreparedStatement ps =
connection.prepareStatement(sqlString);
ps.setString(1, “Allamaraju”); // Sets first placeholder to
Allamaraju
ps.setString(2, 212); // Sets second placeholder to
212
ps.executeUpdate(); // Executes the update

04/24/25 52
 Callable Statements & Stored
Procedures
• Stored Procedures
– Are procedures that are stored in a database.
– Consist of SQL statements as well as procedural
language statements
– May (or may not) take some arguments
– May (or may not) return some values
• Advantages of Stored Procedures
– Encapsulation & Reuse
– Transaction Control
– Standardization
• Disadvantages
– Database specific (lose independence)
• Callable statements provide means of using stored
procedures in the database
04/24/25 53
 Callable Statements & Stored
Procedures
• Stored Procedures must follow certain rules
– Names of the stored procedures and parameters must be
legal
– Parameter types must be legal supported by database
– Each parameter must have one of In, Out or Inout modes
• Example
// Creating a stored procedure using SQL
– CREATE PROC procProductsList AS SELECT * FROM Products;
– CREATE PROC procProductsDeleteItem(inProductsID LONG) AS DELETE
FROM Products WHERE ProductsID = inProductsID;“
– CREATE PROC procProductsAddItem(inProductName VARCHAR(40),
inSupplierID LONG, inCategoryID LONG) AS INSERT INTO Products
(ProductName, SupplierID, CategoryID) Values (inProductName,
inSupplierID, inCategoryID);"
– CREATE PROC procProductsUpdateItem(inProductID LONG, inProductName
VARCHAR(40)) AS UPDATE Products SET ProductName = inProductName
WHERE ProductID = inProductID;"
Usage: procProductsUpdateItem(1000, “My Music”)
04/24/25
(Sets the name of the product with id 1000 to 16.99) 54
 Example of Using Blob
(Images)
• Look at

04/24/25 55
 JNDI
• Look at

04/24/25 56