jdbc introduction
TRANSCRIPT
JDBC
(Java Database Connectivity)
Rakesh Ray
Contents
Overview
History of JDBC
JDBC Model
JDBC Driver Type
JDBC Programming Steps
Step 1 : Loading a JDBC Driver
Step 2 : Connecting to a Database
Step 3 : Executing SQL
Step 4 : Processing the Results
Step 5 : Closing Database Connection
The PreparedStatement Object
Transaction and JDBC
Summary
Online Resources
Overview (1/2)
JDBC
JDBC is a standard interface for connecting to relational databases from Java
The JDBC Classes and Interfaces are in the java.sqlpackage
JDBC is Java API for executing SQL statements
Provides a standard API for tool/database developers
Possible to write database applications using a pure Java API
Easy to send SQL statements to virtually any relational database
What does JDBC do?
Establish a connection with a database
Send SQL statements
Process the results
JDBC DriverJAVA Applet/
Application DatabaseJDBC Call
DatabaseCommand
Overview (2/2)
Reason for JDBC Database vendors (Microsoft Access, Oracle etc.) provide
proprietary (non standard) API for sending SQL to the server and receiving results from it
Languages such as C/C++ can make use of these proprietary APIs directlyHigh performanceCan make use of non standard features of the databaseAll the database code needs to be rewritten if you change
database vendor or product JDBC is a vendor independent API for accessing relational data from
different database vendors in a consistent way
History of JDBC (1/2)
JDBC 1.0 released 9/1996.
Contains basic functionality to connect to database, query database, process results
JDBC classes are part of java.sql package
Comes with JDK 1.1
JDBC 2.0 released 5/1998
Comes with JDK 1.2
javax.sql contains additional functionality
Additional functionality:
Scroll in result set or move to specific row
Update database tables using Java methods instead of SQL commands
Send multiple SQL statements to the database as a batch
Use of SQL3 datatypes as column values
History of JDBC (2/2)
JDBC 3.0 released 2/2002
Comes with Java 2, J2SE 1.4
Support for:
Connection pooling
Multiple result sets
Prepared statement pooling
Save points in transactions
JDBC Model
JDBC consists of two parts:
JDBC API, a purely Java-based API
JDBC driver manager
Communicates with vendor-
specific drivers
JAVA Applet/
Application
JDBC API
Driver Manager
Driver API
Vendor Specific
JDBC DriverJDBC-ODBC Bridge
Database
Vender Specific
ODBC Driver
Database
Java
Application
Developer
JDBC
Developer
Vender
Specific JDBC
developer
JDBC Driver Type
JDBC-ODBC bridge plus ODBC driver
Native-API partly-Java driver
JDBC-Net pure Java driver
Native Protocol pure Java API driver
JDBC-ODBC bridge plus ODBC driver
Type 1 drivers act as a "bridge" between JDBC and another database connectivity mechanism such as ODBC. The JDBC- ODBC bridge provides JDBC
access using most standard ODBC drivers.
Functions:
Translates query obtained by JDBC into corresponding ODBC query, which is
then handled by the ODBC driver.
Sun provides a JDBC-ODBC Bridge driver. sun.jdbc.odbc.JdbcOdbcDriver. This
driver is native code and not Java, and is closed
source.
Client -> JDBC Driver -> ODBC Driver -> Database
There is some overhead associated with the translation work to go from JDBC to ODBC.
Native-API partly-Java driver
Type 2 Java to Native API. Drivers that are written partly in the Java programming language and partly in native code. This is faster than the type 1 driver. This can’t use in applet as native code can’t be executed by applet.
Functions:
This type of driver converts JDBC calls into calls to the client API for that database.
Client -> JDBC Driver -> Vendor Client DB Library -> Database
Advantages and Disadvantages Advantage
Better performance than Type 1 since no jdbc to odbc translation is needed.
Disadvantages
The vendor client library needs to be installed on the client machine.
Cannot be used in internet due the client side software needed.
Not all databases give the client side library.
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.
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.
Functions
Type 4 drivers are entirely written in Java that communicate directly with a
vendor's database through socket connections. No translation or middleware
layers, are required, improving performance.
The driver converts JDBC calls into the vendor-specific database protocol so that
client applications can communicate directly with the database server.
Completely implemented in Java to achieve platform independence.
e.g include the widely used Oracle thin driver - oracle.jdbc.driver. OracleDriver
which connect to jdbc:oracle:thin URL format.
Client Machine -> Native protocol JDBC Driver -> Database server
Advantages & Disadvantage
Advantages
These drivers don't translate the requests into db request to ODBC or pass it to client
api for the db, nor do they need a middleware layer for request indirection. Thus the performance is considerably improved.
Disadvantage
At client side, a separate driver is needed for each database.
JDBC Programming Steps
Connect
Query
Process Results
Close
1) Register the driver
2) Create a connection to the database
1) Create a statement
2) Query the database
1) Get a result set
2) Assign results to Java variables
1) Close the result set
2) Close the statement
3) Close the connection
Skeleton Code
Class.forName(DRIVERNAME);
Connection con = DriverManager.getConnection(
CONNECTIONURL, DBID, DBPASSWORD);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(“SELECT a, b, c FROM member);
While(rs.next())
{
Int x = rs.getInt(“a”);
String s = rs.getString(“b”);
Float f = rs.getFloat(“c”);
}
rs.close();
stmt.close();
con.close();
Loading a JDBC driver
Connecting to a database
Processing the result set
Closing the connections
Executing SQL
Examplepublic class JdbcDemo {
public static void main(String[] args) {
Connection con=null;
Statement st=null;
ResultSet rs=null;
try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
con=DriverManager.getConnection("jdbc:odbc:ora", "system", "manager");
st=con.createStatement();
rs=st.executeQuery("select * from EMP");
while(rs.next())
System.out.print("Name : "+rs.getString("name")+"\nSalary : "+rs.getFloat("sal"));
rs.close();
st.close();
con.close();
}catch (ClassNotFoundException e) {
e.printStackTrace();
}catch(SQLException sql){
sql.printStackTrace();
}
}
}
Step 1 : Loading a JDBC Driver
A JDBC driver is needed to connect to a database
Loading a driver requires the class name of the driver.
Ex) JDBC-ODBC: sun.jdbc.odbc.JdbcOdbcDriver
Oracle driver: oracle.jdbc.driver.OracleDriver
MySQL: com.mysql.jdbc.Driver
Loaing the driver class
Class.forName("com.mysql.jdbc.Driver");
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
It is possible to load several drivers.
The class DriverManager manages the loaded driver(s)
Step 2 : Connecting to a Database (1/2)
JDBC URL for a database
Identifies the database to be connected
Consists of three-part:
jdbc:<subprotocol>:<subname>
Protocol: JDBC is
the only protocol in
JDBC
Protocol: JDBC is
the only protocol in
JDBC
Subname: indicates the location and
name of the database to be
accessed. Syntax is driver specific
Subname: indicates the location and
name of the database to be
accessed. Syntax is driver specific
Sub-protocol:
identifies a
database
driver
Sub-protocol:
identifies a
database
driver
Ex)
jdbc:mysql://oopsla.snu.ac.kr/myd
b
JDBC URLVendor of database, Location of
database server and name of
database
Username Password
Step 2 : Connecting to a Database (2/2)
The DriverManager allows you to connect to a database using the specified JDBC driver, database location, database name, username and password.
It returns a Connection object which can then be used to communicate with the database.
Connection connection =
DriverManager.getConnection("jdbc:mysql://oopsla.snu.ac.kr/mydb",“useri
d",“password");JDBC URL
Vendor of database, Location of
database server and name of
database
Username Password
DriverManager class
The DriverManager class acts as an interface between user and drivers. It keeps track of the
drivers that are available and handles establishing a connection between a database and
the appropriate driver.
Commonly used methods of DriverManager
1) public static void registerDriver(Driver driver): is used to register the given driver with
DriverManager.
2) public static void deregisterDriver(Driver driver):is used to deregister the given driver (drop
the driver from the list) with DriverManager.
3) public static Connection getConnection(String url): is used to establish the connection with
the specified url.
4) public static Connection getConnection(String url, Properties prop): is used to establish
connection with URL and properties which contains userid and password.
4) public static Connection getConnection(String url,String userName,String password): is
used to establish the connection with the specified url, username and password.
Database URL & Driver Name
RDBMS JDBC driver name URL format
MySQL com.mysql.jdbc.Driver jdbc:mysql://hostname/ databaseName
ORACLE oracle.jdbc.driver.OracleDriver jdbc:oracle:thin:@hostname:port Number:databaseName
DB2 COM.ibm.db2.jdbc.net.DB2Dri
verjdbc:db2:hostname:port Number/databaseName
Sybase com.sybase.jdbc.SybDriver jdbc:sybase:Tds:hostname: port Number/databaseName
JDBC-
ODBC Bri
dge
jdbc:odbc:<DB> sun.jdbc.odbc.JdbcOdbcDriver
SQL Serv
er
jdbc:weblogic:mssqlserver4:<D
B>@<HOST>:<PORT>weblogic.jdbc.mssqlserver4.Driver
Step 3 : Executing SQL (1/2)
Statement object
Can be obtained from a Connection object
Sends SQL to the database to be executed
Statement has three methods to execute a SQL statement:
executeQuery() for QUERY statements
Returns a ResultSet which contains the query results
executeUpdate() for INSERT, UPDATE, DELETE, or DDL statements
Returns an integer, the number of affected rows from the SQL
execute() for either type of statement
Statement statement = connection.createStatement();
Statement stmt = conn.createStatement();
ResultSet rset = stmt.executeQuery
("select RENTAL_ID, STATUS from ACME_RENTALS");
Statement stmt = conn.createStatement();
int rowcount = stmt.executeUpdate
("delete from ACME_RENTAL_ITEMS
where rental_id = 1011");
Step 3 : Executing SQL (2/2)
Execute a select statement
Execute a delete statement
Connection InterfaceA Connection is the session between java application and database. This is the factory of Statement,
PreparedStatement, CallableStatement, DatabaseMetaData and also manage Transaction by
several methods.
Commonly used methods
public Statement createStatement(): creates a statement object that can be used to execute SQL
queries.
public Statement createStatement(int resultSetType,int resultSetConcurrency): Creates a Statement
object that will generate ResultSet objects with the given type and concurrency.
public PreparedStatement prepareStatement(String): Create a preparedStatement object that can
be used for execute SQL query.
public CallableStatement prepareCall(String): Create a CallableStatement object that can be used
for execute stored procebure.
public void setAutoCommit(boolean status): is used to set the commit status.By default it is true.
public void commit(): saves the changes made since the previous commit/rollback permanent.
public void rollback(): Drops all changes made since the previous commit/rollback.
public void close(): closes the connection and Releases a JDBC resources immediately.
Statement interface
The Statement interface provides methods to execute queries with the database.
Commonly used methods
public ResultSet executeQuery(String sql): is used to execute SELECT query. It returns the object of ResultSet.
public int executeUpdate(String sql): is used to execute specified query, it may be create, drop, insert, update, delete etc.
public boolean execute(String sql): is used to execute queries that may return multiple
results.
public int[] executeBatch(): is used to execute batch of commands.
Step 4 : Processing the Results (1/2)
JDBC returns the results of a query in a ResultSet object
ResultSet object contains all of the rows which satisfied the conditions in an SQL statement
A ResultSet object maintains a cursor pointing to its current row of data
Use next() to step through the result set row by row
next() returns TRUE if there are still remaining records
getString(), getInt(), and getXXX() assign each value to a Java variable
Record 1 Record 2 Record 3 Record 4
ResultSetInternal Pointer
The internal pointer starts one before the first
record
Step 4 : Processing the Results (2/2)
Example
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(“SELECT ID, name, score FROM table1”);
While (rs.next()){
int id = rs.getInt(“ID”);
String name = rs.getString(“name”);
float score = rs.getFloat(“score”);
System.out.println(“ID=” + id + “ ” + name + “ ” + score);}
NOTE You must step the cursor to the first record before read the results
This code will not skip the first record
ID name score
1 James 90.5
2 Smith 45.7
3 Donald 80.2
Table1
Output
ID=1 James 90.5
ID=2 Smith 45.7
ID=3 Donald 80.2
Step 5 : Closing Database Connection
It is a good idea to close the Statement and Connection objects when you have finished with them
Close the ResultSet object
rs.close();
Close the Statement object
stmt.close();
Close the connection
connection.close();
ResultSet Interface
A ResultSet is a Java object that contains the results of executing an
SQL query.
The data stored in a ResultSet object is retrieved through a set of get
methods that allows access to the various columns of the current row.
A result set is also a table with rows and columns, but it contains only
the column values from a database table that satisfy the conditions of
a query
Each record contains the same amount of columns, although not all
columns may have a value. A column can have a null value
Creating a ResultSet
You create a ResultSet by executing a Statement or PreparedStatement
Statement statement = connection.createStatement();
ResultSet result = statement.executeQuery("select * from people");
String sql = "select * from people";
PreparedStatement statement = connection.prepareStatement(sql);
ResultSet result = statement.executeQuery();
Iterating the ResultSet
To iterate the ResultSet you use its next() method.
The next() method returns true if the ResultSet has a next
record, and moves the ResultSet to point to the next record. If
there were no more records, next() returns false
while(result.next()) {
// ... get column values from this record
}
Navigation Methods
Method Description
absolute() Moves the ResultSet to point at an absolute position. The
position is a row number passed as parameter to
the absolute() method.
afterLast() Moves the ResultSet to point after the last row in
the ResultSet.
beforeFirst() Moves the ResultSet to point before the first row in
the ResultSet.
first() Moves the ResultSet to point at the first row in the ResultSet.
last() Moves the ResultSet to point at the last row in the ResultSet.
next() Moves the ResultSet to point at the next row in the ResultSet.
previous() Moves the ResultSet to point at the previous row in
the ResultSet.
relative() Moves the ResultSet to point to a position relative to its
current position. The relative position is passed as a
parameter to the relative method, and can be both positive
and negative.
Navigation Methods for position
Method Description
getRow() Returns the row number of the current row - the row currently
pointed to by the ResultSet.
getType() Returns the ResultSet type.
isAfterLast() Returns true if the ResultSet points after the last row. False if
not.
isBeforeFirst() Returns true if the ResultSet points before the first row. False if
not.
isFirst() Returns true if the ResultSet points at the first row. False if not.
ResultSet Types
there are three ResultSet types
ResultSet.TYPE_FORWARD_ONLY: ResultSet can only be navigated forward. That is,
you can only move from row 1, to row 2, to row 3 etc.
ResultSet.TYPE_SCROLL_INSENSITIVE:
ResultSet can be navigated (scrolled) both forward and backwards.
You can also jump to a position relative to the current position, or jump to an absolute
position.
The ResultSet is insensitive to changes in the underlying data source while the ResultSet is
open.
ResultSet.TYPE_SCROLL_SENSITIVE:
ResultSet can be navigated (scrolled) both forward and backwards.
You can also jump to a position relative to the current position, or jump to an absolute
position.
The ResultSet is sensitive to changes in the underlying data source while the ResultSet is
open.
The default type is TYPE_FORWARD_ONLY
ResultSet Concurrency
The ResultSet concurrency determines whether the ResultSet can be
updated, or only read.
The DatabaseMetaData.supportsResultSetConcurrency(int concurrency)
method returns true or false depending on whether the given concurrency
mode is supported or not.
ResultSet can have one of two concurrency levels
ResultSet.CONCUR_READ_ONLY: means that the ResultSet can only be read.
ResultSet.CONCUR_UPDATABLE:means that the ResultSet can be both read and
updated.
ResultSet Holdability
The ResultSet holdability determines if a ResultSet is closed when the commit()
method of the underlying connection is called.
DatabaseMetaData.supportsResultSetHoldability(int holdability) returns true or false depending on whether the given holdability mode is supported or not.
There are two types of holdability:
ResultSet.CLOSE_CURSORS_OVER_COMMIT: means that all ResultSet instances are
closed when connection.commit() method is called on the connection that
created the ResultSet.
ResultSet.HOLD_CURSORS_OVER_COMMIT: means that the ResultSet is kept open
when the connection.commit() method is called on the connection that created
the ResultSet. this might be useful if you use the ResultSet to update values in the
database.
Retrieving Column Values
The getter methods in the ResultSet interface (getInt, getString, and so on)
provide the means for retrieving column values from the current row.
column values should be read only once if not scrollable.
the column name or the column number can be used to designate the column
from which to retrieve data.
String s = rs.getString(2);
String s = rs.getString("TITLE");
Information about the columns in a ResultSet is available by calling the
method ResultSet.getMetaData().
Accoring to the datatype used for column we have to use corresponding
getter method.
Providing Performance
Many DBMSs and drivers are optimized to give the best performance under various circumstances,
which means that generally a database programmer is best advised to use their default settings.
The number of rows that should be fetched from the database each time new rows are needed: The
number of rows to be fetched is called the fetch size, and it can be set by two different methods:
Statement and ResultSet.
setFetchSize and ResultSet.setFetchSize
Statement stmt = con.createStatement();
stmt.setFetchSize(25);
ResultSet rs = stmt.executeQuery(SELECT * FROM EMPLOYEES);
rs.setFetchSize(50);//code changes thefetch size of rs to 50
The direction in which rows will be processed: The interface ResultSet defines the following three
constants for specifying the direction in which to process rows:FETCH_FORWARD, FETCH_REVERSE,
and FETCH_UNKNOWN
Statement stmt = con.createStatement();
stmt.setFetchDirection(FETCH_REVERSE);
ResultSet rs = stmt.executeQuery(SELECT * FROM EMPLOYEES);
rs.setFetchDirection(FETCH_FORWARD);//code changes the fetch direction of rs to forward.
Example: Creating Different Types of ResultSets
a default ResultSet object, one that is forward-only and uses read-only
concurrency.
we can set a ResultSet scrollabele, sensitive, updatable and holdable by
following statements
Connection con = DriverManager.getConnection("jdbc:my_subprotocol:my_subname");
Statement stmt = con.createStatement( ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE), ResultSet.HOLD_CURSORS_OVER_COMMIT);
stmt.setFetchSize(25);
ResultSet rs2 = stmt.executeQuery("SELECT EMP_NO, SALARY FROM EMPLOYEES");
Example update method 1/2
A ResultSet object may be updated (have its rows modified, inserted, or
deleted) programmatically if its concurrency type is CONCUR_UPDATABLE.
rs.updateInt(3, 88); // the value in column 3 of rs is set to 88
rs.updateInt("SCORES", 88);// the value in column SCORES of rs is set to 88
rs.updateRow();//to update in database
move to a specific row and update value
rs.absolute(4);
rs.updateString("ADDRESS", "321 Kasten");
rs.updateFloat("AMOUNT", 10101.0f);
rs.updateRow();
we can also delete the current row
rs.deleteRow();
Example update method 2/2
Insert Row can be done using following steps
rs.moveToInsertRow();
rs.updateObject(1, myArray);
rs.updateInt(2, 3857);
rs.updateString(3, "Mysteries");
rs.insertRow();
rs.first();
First we have to set the ResultSet in insert mode.
Then we set value for columns
Then save the result through insertRow()
Then set corsor to fetch mode.
The PreparedStatement Object
The PreparedStatement interface inherits from Statement. PreparedStatement objects are precompiled, their execution can be faster than that of Statement
objects.Differs from it in two ways.
Instances of PreparedStatement contain an SQL statement that has already been compiled
The SQL statement contained in a PreparedStatement object may have one or more IN parameters. IN parameters are given by "?"
The PreparedStatement's primary features are:
Easy to insert parameters into the SQL statement.
Easy to reuse the PreparedStatement with new parameters.
May increase performance of executed statements.
Enables easier batch updates.
The PreparedStatement Object
// Create the prepared statement
PreparedStatement pstmt =
con.prepareStatement(“
UPDATE table1 SET status = ? WHERE id =?”)
// Supply values for the variables
pstmt.setString (1, “out”);
pstmt.setInt(2, id);
// Execute the statement
pstmt.executeUpdate();
Reusing a PreparedStatement
String sql = "update people set firstname=? , lastname=? where id=?";
PreparedStatement preparedStatement =
connection.prepareStatement(sql);
preparedStatement.setString(1, "Gary");
preparedStatement.setString(2, "Larson");
preparedStatement.setLong (3, 123);
int rowsAffected = preparedStatement.executeUpdate();
preparedStatement.setString(1, "Stan");
preparedStatement.setString(2, "Lee");
preparedStatement.setLong (3, 456);
int rowsAffected = preparedStatement.executeUpdate();
Batch Updates
A batch update is a batch of updates grouped together, and sent to the database in one "batch", rather than sending the updates one by one.
Sending a batch of updates to the database in one go, is faster than
sending them one by one, waiting for each one to finish. There is less
network traffic involved in sending one batch of updates (only 1 round trip),
and the database might be able to execute some of the updates in parallel.
The speed up compared to executing the updates one by one, can be
quite big.
You can batch both SQL inserts, updates and deletes. It does not make
sense to batch select statements.
There are two ways to execute batch updates:
Using a Statement
Using a PreparedStatement.
Statement Batch Updates
You can use a Statement object to execute batch updates. You do so using the addBatch() and executeBatch() methods.
The int[] array returned by the executeBatch() method is an array of int
telling how many records were affected by each executed SQL statement in
the batch. Here is an example:
Statement statement = null;
try{
statement = connection.createStatement();
statement.addBatch("update people set firstname='John' where id=123");
statement.addBatch("update people set firstname='Eric' where id=456");
statement.addBatch("update people set firstname='May' where id=789");
int[] recordsAffected = statement.executeBatch();
} finally {
if(statement != null) statement.close();
}
PreparedStatement Batch Updates
String sql = "update people set firstname=? , lastname=? where id=?";
PreparedStatement preparedStatement = null;
try{
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, "Gary"); preparedStatement.setString(2, "Larson");
preparedStatement.setLong (3, 123);
preparedStatement.addBatch();
preparedStatement.setString(1, "Stan"); preparedStatement.setString(2, "Lee");
preparedStatement.setLong (3, 456);
preparedStatement.addBatch();
int[] affectedRecords = preparedStatement.executeBatch();
}finally {
if(preparedStatement != null) {
preparedStatement.close();
}
}
Transactions and JDBC (1/3)
The classic example of when transactions are necessary is the example of bank
accounts. You need to transfer $100 from one account to the other. You do so
by subtracting $100 from the first account, and adding $100 to the second
account. If this process fails after you have subtracted the $100 from the first
bank account, the $100 are never added to the second bank account. The
money is lost in cyber space.
Transaction: more than one statement that must all succeed (or all fail)
together
If one fails, the system must reverse all previous actions
Also can’t leave DB in inconsistent state halfway through a transaction
COMMIT = complete transaction
ROLLBACK = cancel all actions
Transactions and JDBC (2/3)
Connection connection = ...
try{
connection.setAutoCommit(false);
// create and execute statements etc.
connection.commit();
} catch(Exception e) {
connection.rollback();
} finally {
if(connection != null) {
connection.close();
}
}
Transactions and JDBC (3/3) A Savepoint object marks an intermediate point within a transaction and makes it possible
to roll back the transaction to that point instead of rolling back the entire transaction.
Connection con = ...try{
con.setAutoCommit(false);Statement stmt = con.createStatement();int rows = stmt.executeUpdate("INSERT INTO AUTHORS VALUES " + "(LAST, FIRST, HOME)
'TOLSTOY', 'LEO', 'RUSSIA'");Savepoint save1 = con.setSavepoint("SAVEPOINT_1");rows = stmt.executeUpdate("INSERT INTO AUTHORS VALUES " + "(LAST, FIRST, HOME) 'MELVOY',
'HAROLD', 'FOOLAND'");con.commit();
} catch(Exception e) {con.rollback(save1);
} finally {if(connection != null) {
con.close();}
}
CallableStatement
A CallableStatement object provides a way to call stored procedures in a standard way
for all DBMSs.
variable number of parameters used for input (IN parameters), output (OUT parameters), or
both (INOUT parameters). A
question mark serves as a placeholder for a parameter.
Creating a CallableStatement
CallableStatement callableStatement = connection.prepareCall("{call calculateStatistics(?, ?)}");
Setting IN Parameter Values
callableStatement.setString(1, "param1");
callableStatement.setInt (2, 123);
OUT Parameters
callableStatement.registerOutParameter(1, java.sql.Types.VARCHAR);
callableStatement.registerOutParameter(2, java.sql.Types.INTEGER);
CallableStatement
Retrieve OUT parameter
String s = callableStatement.getString(1);
int i = callableStatement.getInt(2);
INOUT Parameters
CallableStatement cstmt = con.prepareCall("{call reviseTotal(?)}");
callableStatement.setInt(1, 25);
callableStatement.registerOutParameter(1, java.sql.Types.INTEGER);
callableStatement.executeUpdate();
int x = callableStatement.getInt(1);
Executing the CallableStatement
ResultSet result = callableStatement.executeQuery();
callableStatement.executeUpdate();
DatabaseMetaData
Through the java.sql.DatabaseMetaData interface you can obtain meta data about the database you have connected.
Obtaining a DatabaseMetaData Instance
DatabaseMetaData databaseMetaData = connection.getMetaData();
Database Product Name and Version
String productName = databaseMetaData.getDatabaseProductName();
String productVersion = databaseMetaData.getDatabaseProductVersion();
Database Driver Version
int driverMajorVersion = databaseMetaData.getDriverMajorVersion();
int driverMinorVersion = databaseMetaData.getDriverMinorVersion();
Listing Tables
ResultSet result = databaseMetaData.getTables(catalog, schemaPattern, tableNamePattern, types );
Java Bean
This is a regular java Object, typically used for modeling data.
This class coded according to the JavaBeans API specifications.
This is also known as POJO(Plain Old Java Object)
characteristics of a JavaBean
It provides a default, no-argument constructor.
It should be serializable and implement the Serializable interface.
It may have a number of properties which can be read or written.
It may have a number of "getter" and "setter" methods for the
properties.
JavaBeans Properties
A JavaBean property is a named attribute that can be accessed by
the user of the object.
A JavaBean property may be read, write, read only, or write only.
JavaBean properties are accessed through two methods
getPropertyName(): if property name is firstName, your method name would be getFirstName() to read that property. This method
is called accessor.
setPropertyName(): if property name is firstName, your method
name would be setFirstName() to write that property. This method
is called mutator.
JavaBeans Properties Rules
First letter should small letter.
First letter should capital in getter and setter method.
Property can be
Read only
Write only
Read and writer
Property type should be same for getter and setter.
Getter should not have arguments
Setter should have one argument.
JavaBeans Examplepackage com.cutm;
public class StudentsBean implements java.io.Serializable
{
private String firstName = null;
private String lastName = null;
private int age = 0;
public StudentsBean() { }
public String getFirstName(){ return firstName; }
public String getLastName(){ return lastName; }
public int getAge(){ return age; }
public void setFirstName(String firstName){ this.firstName =
firstName; }
public void setLastName(String lastName){ this.lastName =
lastName; }
public void setAge(Integer age){ this.age = age; }
}
Online Resources
Sun’s JDBC site
http://java.sun.com/products/jdbc/
JDBC tutorial
http://java.sun.com/docs/books/tutorial/jdbc/
http://tutorials.jenkov.com/jdbc/index.html
List of available JDBC drivers
http://developers.sun.com/product/jdbc/drivers
API for java.sql
http://java.sun.com/j2se/1.5.0/docs/api/java/sql/package-summary.html