JDBC TALKING TO DATABASE

(Unit-VI)

K.Phani Sirisha

What Is JDBC?• Java database connectivity or JDBC is an interface

used to connect to relational databases from the Java program.

• JDBC is a Java API which consists of a set of classes and interfaces written in the Java programming language.

• JDBC provides a standard API tool for database developers and makes it possible to write database applications using a pure Java API.

• With the help of JDBC API developers can query database, add data, update data and even delete the data from database very easily.

What does JDBC Do ?With the help of JDBC, it is possible to do the following three things• to establish a connection with a database• to send SQL statements• to process the resullts

The following code fragment gives a basic example of these three steps:

Connection con = DriverManager.getConnection ( "jdbc:odbc:wombat", "login", "password");

Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table1"); while (rs.next()) { int x = getInt("a"); String s = getString("b"); float f = getFloat("c"); }

JDBC Vs. ODBC and other APIs Microsoft's ODBC (Open DataBase Connectivity) API is probably the most widely

used programming interface for accessing relational databases. It offers the ability to connect to almost all databases on almost all platforms. So why not just use ODBC from Java? "Why do you need JDBC?"

• ODBC is not appropriate for direct use from Java because it uses a C interface. Calls from Java to native C code have a number of drawbacks in the security, implementation, robustness, and automatic portability of applications.

• A literal translation of the ODBC C API into a Java API would not be desirable. For example, Java has no pointers, and ODBC makes copious use of them.

• ODBC is hard to learn. It mixes simple and advanced features together, and it has complex options even for simple queries. JDBC, on the other hand, was designed to keep simple things simple while allowing more advanced capabilities where required.

• When ODBC is used, the ODBC driver manager and drivers must be manually installed on every client machine. When the JDBC driver is written completely in Java, however, JDBC code is automatically installable, portable, and secure on all Java platforms from network computers to mainframes.

Two-tier and Three-tier Models• The JDBC API supports both two-tier and three-tier

models for database access.• In a two-tier model, a Java application/applet

communicates directly with the database, via the JDBC driver. The Java application/applet and the database can be on the same machine, or the database can be on a server and the Java application/applet can be on a client machine using any network protocol.

• In the three-tier model, commands are sent to a "middle tier" of services, which then send SQL statements to the database. The database processes the SQL statements and sends the results back to the middle tier, which then sends them to the user. Another advantage is that when there is a middle tier, the user can employ an easy-to-use higher-level API which is translated by the middle tier into the appropriate low-level calls.

• In a three-tier model, a Java application/applet communicates with a middle tier component that functions as an application server. The application server talks to a given database using JDBC.

The JDBC Package• The java.sql and javax.sql are the primary

packages for JDBC 4.0 JDBC API is contained in 2 packages.

java.sql - which contains java data objects that provide the basics for connecting to the DBMS and interacting with data stored in the DBMS. This package is a part of J2SE.

javax.sql – which extends java.sql and is in J2EE. This includes the data objects that manage connection pooling, JNDI , and other advanced JDBC features.

Components of JDBCComponent DescriptionDriverManager It loads database drivers and manages the

connection between the application and the driver

Driver It translates API calls into operation for a specific data source

Connection It is a session between an application and a database

Statement It is an SQL statement to perform a query or update operation

MetaData It gives information about returned data, the database, and the driver

ResultSet It is the logical set of columns and rows of data returned by executing a statement

Types of JDBC Drivers

The JDBC drivers that we are aware of at this time fit into one of four categories:

• JDBC-ODBC bridge driver: Which 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 appropriate for application server code written in Java in a three-tier architecture.

• 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.

• 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.

• Native-protocol pure Java driver: This kind of driver converts JDBC calls into the network protocol used by DBMSs directly. This allows a direct call from the client machine to the DBMS server and is a practical solution for Intranet access.

Note: To access database using the JDBC API, driver categories 3 and 4 are the most preferable.

JavaSoft FrameworkJavaSoft provides three JDBC product components as part of the

Java Development Kit (JDK):• The JDBC driver manager, • The JDBC driver test suite, and • The JDBC-ODBC bridge. The JDBC driver manager is the backbone of the JDBC architecture.

Its primary function is to connect Java applications to the correct JDBC driver

The JDBC driver test suite provides some confidence that JDBC drivers will run your program. Only drivers that pass the JDBC driver test suite can be designated JDBC COMPLIANT

The JDBC-ODBC bridge allows ODBC drivers to be used as JDBC drivers. It will provide a way to access some of the less popular DBMSs if JDBC drivers are not implemented for them.

Driver Interface and DriverManager Class• To create Connection objects is the primary use of the

Driver interface.• All drivers supply a class that implements the Driver

interface.• DriverManager keeps track of the drivers that are available

and establishing a connection between a database and the appropriate driver.

• With the help of DriverManager class drivers are loaded for any given connection request

• When a Driver class is loaded, it creates an instance of itself and registers it with the DriverManager class.

• A user can load and register a driver by calling Class.forName(“URL”)

• The DriverManager class will attempt to load the driver classes referenced in the Url by calling getConnection and getDrivers methods.

Connection Interface• A Connection object is instantiated to make a

connection to a specific database using a specific driver.

• Connection interface can be used for the maintenance and monitoring the status of database sessions

• A connection session includes the SQL statements that are executed and the results that are returned over that connection.

• A single application can have one or more connections with a single database, or it can have connections with many different databases.

Statement Interface

• A Statement object is used to send SQL statements to a database. • There are actually three kinds of Statement objects, all of which

act as containers for executing SQL statements on a given connection: Statement, PreparedStatement, which inherits from Statement, and CallableStatement, which inherits from PreparedStatement.

• They are specialized for sending particular types of SQL statements

• A Statement object is used to execute a simple SQL statement• A PreparedStatement object is used to execute a precompiled

SQL statement• A CallableStatement object is used to execute a call to a database

stored procedure.

PreparedStatement Interface• The PreparedStatement interface is a subclass

of Statement interface. It is used to execute precompiled SQL statements.

• For faster and efficient statement execution, pre-compilation is allowed.

ResultSet Interface• A ResultSet is actually a container for the

result of a query. i.e which contains all of the rows which satisfied the conditions in an SQL statement

• ResultSet provides the methods for the retrieval of data which is returned by the database.

• It also contains methods for conversion of data types between SQL and Java.

ResultSetMetaData Interface

• Through ResultSetMetaData interface, the user can get information about the types and properties of the columns in a ResultSet object

• This is useful to collect data that has the same semantics, but stored in different database sources in different formats.

DatabaseMetaData Interface

• The DatabaseMetaData interface provides information regarding the database itself.

• For example, it gives information about its version , table names, columns of these tables and their types and supported functions.

• It has also methods for discovering database information specific to the current connection, such as available tables, schemas, and catalogs.

The Essential JDBC ProgramBasic steps to writing an application that uses JDBC API1. Import the java.sql package Any application that uses JDBC API must import the java.sql package import java.sql.*;2. Load a JDBC Driver• JDBC driver must be loaded before the J2EE component can connect the

DBMS. • When a driver class is first loaded, it registers itself with the DriverManager. • Class.forName() method can be used to load the JDBC driver.• We should pass the name of the driver to this method and this method

throws ClassNotFoundException if an error occurs when loading the driver

String driver = “sun.jdbc.odbc.JdbcOdbcDriver”;Class.forName(driver);

OR Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);

3. Establishing a Connection• Once the driver is loaded, the J2EE component must

connect the DBMS using the DriverManager class and Connection interface.

• getConnection() method of DriverManager class is used to establishing a connection to the database

• DriverManager Connects to given JDBC URL with given user name and password.

• A Connection object is returned by the getConnection() if access is granted; else getConnection() throws an SQLException.

• If username & password is required then those information need to be supplied to access the database.

Connection con = DriverManager.getConnection(url,username,password) ;

4. Create a Statement• Once the Connection is established, a Statement object is

needed to execute the SQL statements• So, to create a Statement object, we can use

createStatement() method of Connection interface by using Connection object.

Statement st = con.createStatement();5.Execute the Statement• The executeQuery() method of Statement interface is used

to execute queries to the database and it throws an SQLException if it found anything wrong in the query.

• This method returns the object of ResultSet that can be used to get all the records of a table.

ResultSet rs = st.executeQuery(“Select * from Customers”);

6. Process the ResultSet• After executing the query, the results received from DBMS are assigned to

ResultSet object. • Only one ResultSet per Statement can be open at once. • The ResultSet consists of tuples and returns one tuple at a time when the next()

function is paplied• We can say that the ResultSet acts like an iterator.• A ResultSet maintains a cursor pointing to its current row of data.• The next() method moves the cursor to the next row. • getString() method of ResultSet object is used to get the value of a specified

column in the current row of the ResultSet. while(rs.next()) { FirstName = rs.getString(1); LastName = rs.getString(2); Salary = rs.getInt(3);

System.out.println(Firstname+” “+LastName+” “+salary); }

7. Close the Satement• It is appropriate to close a statement when it is no longer in

need st.close();

8. Close the Connection• Once the J2EE component is finished accessing the DBMS, it

is necessary to disconnect from the database• The connection to the DBMS is terminated by using the

close() method of the Connection interface.• commit() function is executed to commit all transactions

that have been made through the connection• By closing connection object statement and ResultSet will be

closed automatically. con.commit();

con.close();

JDBC URL Syntax: jdbc : <subprotocol> :

<subname>• URL consists of 3 parts

Jdbc – This indicates that the jdbc protocol is to be used to read the URL.

<subprotocol> - which is the JDBC driver name<subname> - which is the name of the database• Each driver has its own subprotocol• Each subprotocol has its own syntax for the source

Ex: jdbc : odbc : CustomerInfo

Statement Object contains 3 methods: execute() (used for DDL commands like, Create, Alter, Drop) executeUpdate() (Used for DML commands like, Insert, Update,

Delete) exceuteQuery() (Used for Select command) • The execute() method is used during execution of DDL commands

and also used when there may be multiple results returned.• The executeUpdate() executes INSERT, UPDATE, DELETE, and

returns an integer value specifying the number of rows affected or 0 if zero rows selected.

• The executeQuery() method, which passes the query as an argument. The query is then transmitted to the DBMS for processing.

• The executeQuery()method executes a simple select query and returns a ResultSet object.

• All the 3 methods throws an SQLException when error occurs.

Example-1: Statement st = con.createStatement(); ResultSet rs = st.executeQuery(“select * from employee”);

Example-2: Statement st = con.createStatement();int r=st.executeUpdate(“insert into employee values(10,"skr”,98453421)”); int s= st.executeUpdate(“update employee set Mobile=89706454 where

Mobile=98453421” );int n=st.executeUpdate(“delete from employee where eno=10”);

Example-3: Statement st = con.createStatement(); st.execute(“Drop table Employee”); st.execute(“Create table Employee (eno number,name varhcar(10), age

Number(3))”); st.execute(“alter table employee add primary key(eno)”);

PreparedStatement

• The PreparedStatement object allows you to execute parameterized queries.

• PreparedStatement interface is used to represent a precompiled query, which can be executed multiple times without compiling it again and again.

• It improves the performance of an application and performs faster execution by avoiding compilation of multiple queries.

• A SQL query can be precompiled and executed by using the PreparedStatement object.

Ex: Select * from employee where eno=?• Here a query is created as usual, but a question mark is used as a

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

• The prepareStatement() method of Connection object is called to return the PreparedStatement object.

• The setxxx() method of the PreparedStatement object is used to replace the question mark with the value passed to the setxxx() method.

• The setxxx() requires 2 parameters. The first parameter is an integer that identifies the position of the question mark placeholder and the second parameter is the value that replaces the question mark placeholder.

• PreparedStatement's execute methods have no parametersCode snippet:try{PreparedStatement pst;String query=“select * from customer where custNumber=?”;pst = con.prepareStatement(query);pst.setInt(1,1234);ResultSet rs=pst.executeQuery();pst.close();}catch (Exception e){ }

executeUpdate• executeUpdate method can be used to execute both the Statement and the

PreparedStatement objects.• No argument is supplied to the execueUpdate when it is used with

PreparedStatement because the PreparedStatement’s object already contains the query

• Once a parameter has been set with a value, it will retain that value until it is reset to another value or the method clearParameters is called

String query = “update coffees set sales=? where cof_name like ? “;PreparedStatement updateSales = con.prepareStatement(query);updateSales.setInt(1,75);updateSales.setString(2,”colombian”);updatesales.executeUpdate();

• executeUpdate() method can also return an integer value that indicates howmany rows of a table were updated

int n = updatesales.executeUpdate();

Using a Loop to Set Values

The following code fragment demonstrates using a for loop to set values for parameters in the preparedStatement object updateSales.

String query = “update coffees set sales=? where cof_name like ? “;PreparedStatement updateSales = con.prepareStatement(query);int [] sales = {175,150,60};String [] coffees = {“colombian”,”French_Roast”, “Espresso”};for(int i=0;i<coffees.length;i++){ updateSales.setInt(1,sales[i]); updateSales.setString(2,coffees[i]); updatesales.executeUpdate();}

ResultSet• The ResultSet interface is used to represent the data in tabular form, which is

generated by executing an SQL query. • The ResultSet object contains methods that are used to copy data from the

ResultSet into a Java collection object or variable for further processing.• Data in a ResultSet object is logically organized into a virtual table consisting of

rows and columns.• The ResultSet uses a virtual cursor to point to a row of the virtual table.• The virtual cursor is positioned above the first row of data when the ResultSet

is returned by the executeQuery(). This means the virtual cursor must be moved to the first row using the next() method.

• The next() method returns a boolean true if the row contains data, otherwise a boolean false is returned.

• Once the virtual cursor points to a row, the getxxx() method is used to copy data from the row to a collection, object or variable.

• The data type of the getxxx() method must be same data type as the column in the ResultSet.

• getxxx() method requires one parameter, which is an integer that represents the number of the column that contains the data.

• For example, getString(1) copies the data from the first column of the ResultSet.• We can also retrieve the data from ResultSet object by passing column name as

argument to the getxxx() method. i.e rs.getString(“FirstName”); Reading the ResultSet try { String query = "SELECT FirstName,LastName FROM Customers"; Statement st;ResultSet rs;st = con.createStatement();rs = st.executeQuery (query); while(rs.next()){ System.out.println(rs.getString(1) +”\t”+ rs. getString (2));}st.close();}catch ( Exception e ){ }

Scrollable ResultSets

• The Scrollable Resultset is the first area of new functionality.• It is possible with the method next to move through the rows of

a ResultSet, which is started at the first row and going to the last row. (i.e only forward)

• But by using this scrollable ResultSet that is scrollable, you can move a ResultSet’s cursor wherever you want and also check on where it is currently positioned.

• you can move back one row at any time or start at the last row and iterate through a Resultset’s rows backwards with the method previous.

• There are also methods for moving to the nth row or moving a specified number of rows from the current row.

• It can also move the cursor to the first row, the last row, the position before the first row, and the position after the last row.

Code Snippet:ResultSet rs = st. executeQuery(“select * from committees”);While(rs.next()) { }rs.absolute(5);rs.relative(-2);rs.relative(4);rs.previous();int rowNumber = rs.getRow();rs.moveAfterLast();while(previous()){ }

Batch Updates• Batch Processing allows you to group related SQL statements into a

batch and submit them with one call to the database.• When you send several SQL statements to the database at once, you

reduce the amount of communication overhead, thereby improving performance.

• You should use the DatabaseMetaData.supportsBatchUpdates() method to determine if the target database supports batch update processing. The method returns true if your JDBC driver supports this feature.

• The addBatch() method of Statement, PreparedStatement,  and CallableStatement is used to add individual statements to the batch.

• The executeBatch() is used to start the execution of all the statements grouped together.

• The executeBatch() returns an array of integers, and each element of the array represents the update count for the respective update statement.

• Just as you can add statements to a batch for processing, you can remove them with the clearBatch() method. This method removes all the statements you added with the addBatch() method. However, you cannot selectively choose which statement to remove.

Code Snippet:con.setAutoCommit(false);Statement st = con.creatSatement();st.addBatch(“Insert into emploee values(1000, ‘Joe Jones’)”);st.addBatch(“Insert into departments values(260, ‘Shoe’)”);st.addBatch(“Insert into emp_dept values(1000, ‘260’)”);int [] updateCounts = st.executeBatch();con.commit();

Programmatic Updates ( Updatable Resultset)• Using the JDBC API, you can modify column values and insert or delete a row instead of SQL

statements. To change the address and amount columns in the fourth row, then use the following code fragment

rs.absolute(4);rs.updateString(“address”,”321 kasten”);rs.updateFloat(“amount”,10101.0f);rs.updateRow();

• To insert a new row, you have to follow certain steps. Firstly, you move the cursor to a special row, called the insert row to build the new row. Secondly, you send the new row to the database, and finally move the cursor back to the ResultSet.

rs.moveToInsertRow();rs.updateObject(1,myArray);rs.updateInt(2,3856);rs.udateString(3,”Mysteries”);rs.insertRow();rs.first();

• You move the cursor to the row you want to delete ad call the method deleteRow to delete a row

rs.first();rs.deleteRow();

Data Types and JDBC• Since SQL data types and Java data types are not identical, there

needs to be some mechanism for reading and writing data between an application using Java types and a database using SQL types.

• JDBC data types are the bridge data types between java data type and underlying database software.

• The JDBC driver converts the Java data type to the appropriate JDBC type before sending it to the database. It uses a default mapping for most data types.

• These JDBC data types are JDBC driver independent

• The OUT parameter contains the value returned by the stored procedures. The OUT parameter must be registered using the registerOutParameter() method, and then later retrieved by using the getxxx() method.

• The INOUT parameter is a single parameter that is used to pass information to the stored procedure and retrieve information from the stored procedure.

• Each parameter is denoted by “?” (question mark placeholder for each parameter) , and we will set the value for the parameters by using the setxxx() methods

Code snippet:CallableStatement cstmt = con.prepareCall( “{call getMonthDate(?,?)});cstmt.setInt(1,6);cstmt.setInt(2,1999);ResultSet rs = cstmt.executeQuery();

Callable Statement (Calling Stored Procedures)• A CallableStatement object provides a way to call stored procedures in a

standard way for all DBMSs.• A stored procedure is stored in a database and it is a block of code which is

identified by a unique name.• The stored procedure is executed by invoking the name of the stored

procedure.• The syntax for a stored procedure with no parameters would look like this:

{ call procedure_name }• CallableStatement objects are created with

the Connection method prepareCall. CallableStatement cstmt = con.prepareCall( "{call procedureName}”);• The CallableStatement object uses 3 types of parameters IN, OUT and

INOUT when calling a stored procedure.• The IN parameter contains any data that needs to be passed to the stored

procedure and whose value is assigned using the setxxx() method.

• Procedures can also have parameters for returning a result-referred to as OUT parameters

• The syntax for a procedure that returns a result parameter is: {? = call procedure_name[(?, ?, ...)]}• The placeholder for an OUT parameter is also ?• For each OUT parameter, you must identify the type of the

output value as one of the types defined in the java.sql.Types class by calling the registerOutParameter() method for the CallableStatement obejct.

cstmt.registerOutParameter(2,Types.INTEGER);• Once the OUT parameter has been registered, you can execute

the procedure and get the value from the CallableStatement int value = cstmt.getInt(2);

Mapping Relational Data onto Java Objects• Because data types in SQL and data types in the Java

programming language are not identical, there needs to be some mechanism for transferring data between an application using Java types and a database using SQL types

• In order to transfer data between a database and an application written in the Java programming language, the JDBC API provides three sets of methods:

Methods on the ResultSet class for retrieving SQL SELECT results as Java types

Methods on the PreparedStatement class for sending Java types as SQL statement parameters

Methods on the CallableStatement class for retrieving SQL OUT parameters as Java types

Mapping SQL Data Types to Java Types• When the programmers use SQL type names to create a table

using CREATE TABLE statement then they must take care to use SQL type names that are supported by their target database.

• If you want to write portable JDBC programs that can create tables on a variety of different databases, you have two main choices. First, you can use SQL type names such as INTEGER, NUMERIC, or VARCHAR, which are likely to work for all databases. Or second, you can use the DatabaseMetaData.getTypeInfo method to discover which SQL types are actually supported by a given database and select a database-specific SQL type name that matches a given JDBC type.

• 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.

Basic JDBC Data Types• The following list defines different JDBC data types which are supported by

JDBC 4.0 API and how they are related to standard SQL types and to Java types

CHAR, VARCHAR, and LONGVARCHAR• CHAR represents a small, fixed-length character string, VARCHAR represents a

small, variable- length character string, and LONGVARCHAR represents a large, variable-length character string.

• The SQL CHAR type and SQL VARCHAR type are mapped to JDBC CHAR and JDBC VARCHAR types and supported by all the major databases

• There is no consistent SQL mapping for the JDBC LONGVARCHAR type. All the major databases support some kind of very large variable-length string supporting up to at least a gigabyte of data, but the SQL type names vary.

• The recommended Java mapping is String and the recommended method is Resultset.getString

BINARY, VARBINARY, and LONGVARBINARY• BINARY represents a small, fixed-length binary value, VARBINARY represents

a small, variable-length binary value, and LONGVARBINARY represents a large, variable-length binary value.

• The use of these various BINARY types has not been standardized and support varies considerably among the major databases

• BINARY, VARBINARY, and LONGVARBINARY can all be expressed identically as byte arrays in Java.

• The method recommended for retrieving BINARY and VARBINARY values is ResultSet.getBytes

• The method getBinaryStream is recommended if a column of type JDBC LONGVARBINARY stores a byte array that is many megabytes long

BIT• The JDBC type BIT represents a single bit value that can be zero or one.• The recommended Java mapping for the JDBC BIT type is as a Java boolean.

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. 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 recommended Java mapping for the JDBC SMALLINT type is as a Java short.INTEGER• The JDBC type INTEGER represents a 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 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 and

not 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 recommended Java mapping for the FLOAT type is as a Java double. DECIMAL and NUMERIC• The JDBC types DECIMAL and NUMERIC are very similar. • The method recommended for

retrieving DECIMAL and NUMERIC values is ResultSet.getBigDecimal

DATE, TIME, and TIMESTAMP• There are three JDBC types relating to time:• The JDBC DATE type represents a date consisting of day,

month, and year. • The JDBC TIME type represents a time consisting of hours,

minutes, and seconds. • The JDBC TIMESTAMP type represents DATE plus TIME plus a

nanosecond field.• Because the standard Java class java.util.Date does not match

any of these three JDBC date-time types exactly (it includes both DATE and TIME information but has no nanoseconds), JDBC defines three subclasses of java.util.Date to correspond to the SQL types. They are:

• java.sql.Date for SQL DATE information. • java.sql.Time for SQL TIME information.

java.sql.Timestamp for SQL TIMESTAMP information

Advanced JDBC Data Types• The ISO (International Organization for Standardization) and IEC (the

International Electrotechnical Commission) have defined new data types that are commonly referred to as SQL3 types. Of these new SQL3 data types, BLOB, CLOB, ARRAY, and REF are predefined types, whereas the SQL structured type and the DISTINCT type are user-defined types (UDTs).

BLOB• The JDBC type BLOB represents an SQL3 BLOB (Binary Large Object).• A JDBC BLOB value is mapped to an instance of the Blob interface in the

Java programming language. CLOB• The JDBC type CLOB represents the SQL3 type CLOB (Character Large

Object).• A JDBC CLOB value is mapped to an instance of the Clob interface in the

Java programming language. • The BLOB and CLOB data can be retrieved by using the method

getBinaryStream() or getAsciiStream()

ARRAY• The JDBC type ARRAY represents the SQL3 type ARRAY.• An ARRAY value is mapped to an instance of the Array interface in the Java

programming language. STRUCT• The JDBC type STRUCT represents the SQL3 structured type. An SQL structured

type, which is defined by a user with a CREATE TYPE statement, consists of one or more attributes. These attributes may be any SQL data type, built-in or user-defined.

• The standard mapping for the SQL type STRUCT is to a Struct object in the Java programming language. A Struct object contains a value for each attribute of the STRUCT value it represents.

DISTINCT• The JDBC type DISTINCT represents the SQL3 type DISTINCT.• The standard mapping for a DISTINCT type is to the Java type to which the

base type of a DISTINCT object would be mapped. For example, a DISTINCT type based on a CHAR would be mapped to a String object, and a DISTINCT type based on an SQL INTEGER would be mapped to an int.

REF• The JDBC type REF represents an SQL3 type REF<structured type>. An

SQL REF references (logically points to) an instance of an SQL structured type and is a unique identifier In the Java programming language, the interface Ref represents an SQL REF.

• A REF is reference to SQL structured type and It is persistently stored with the instance it references in a special table on the server. An application can select the REF value from its special table and use it in place of the structured type instance it identifies.

JAVA_OBJECT• The JDBC type JAVA_OBJECT, added in the JDBC 2.0 core API, makes it easier

to use objects in the Java programming language as values in a database.• JAVA_OBJECT is simply a type code for an instance of a class defined in the

Java programming language that is stored as a database object.• For DBMSs that support them, values of type JAVA_OBJECT are stored in a

database table using the method PreparedStatement.setObject. They are retrieved with the methods ResultSet.getObject or CallableStatement.getObject and updated with the ResultSet.updateObject method.

Examples of Mapping• This section presents three different scenarios, describing the

data mapping and conversion required in each. Simple SQL Statement• In the most common case, a user executes a simple SQL

statement and gets back a ResultSet object with the results.• The value returned by the database and stored in

a ResultSet column will have a JDBC data type.• A call to a ResultSet.getXXX method will retrieve that value as a

Java data type.• For example, if a ResultSet column contains a JDBC FLOAT value,

the method getDouble will retrieve that value as a Java double. (A user who does not know the type of a ResultSet column can get that information by calling the method ResultSet.getMetaData and then invoking the ResultSetMetaData methods getColumnType or getColumnTypeName.)

• The following code fragment demonstrates getting the column type names for the columns in a result set:

String query = "select * from Table1"; ResultSet rs = stmt.executeQuery(query);

ResultSetMetaData rsmd = rs.getMetaData(); int columnCount = rsmd.getColumnCount(); for (int i = 1; i <= columnCount; i++) { String s = rsmd.getColumnTypeName(i);

System.out.println ("Column " + i + " is type " + s); }

SQL Statement with IN Parameters• In another possible scenario, the user sends an SQL statement which takes

input parameters. • In this case, the user calls the PreparedStatement.setXXX methods to assign a

value to each input parameter.• For example, PreparedStatement.setLong(1, 2345678) will assign the

value 2345678 to the first parameter as a Java long. The driver will convert 2345678 to a JDBC BIGINT in order to send it to the database.

SQL Statement with INOUT Parameters• In another scenario, a user wants to call a stored procedure, assign values to

its INOUT parameters, retrieve values from the results, and retrieve values from the parameters.

• In this scenario, the first thing to do is to assign values to the INOUT parameters using CallableStatement.setXXX methods.

• Each out parameter must be registered with driver by using the method CallableStatement.registerOutParameter, which takes one of the JDBC types defined in the class Types.

• A programmer retrieves the results returned to a ResultSet object with ResultSet.getXXX methods and retrieves the values stored in the output parameters with CallableStatement.getXXX methods.

Custom Mapping

• The driver will use the custom mapping instead of the standard mapping when it converts a UDT(user defined Types) from a JDBC type to a Java type or vice versa.

• All custom mapping is done using the connection’s type map • A type map is an instance of the java.util.Map interface, is

associated with every new connection when it is created• a custom mapping is to make an entry of UDT in a type map.• With the methods ResultSet.getObject and

CallableStatement.getObject, UDTs are retrieved from the database, and with PreparedSatement.setObject UDTs are sent back to the database.

• When an application calls a getObject method to retrieve a UDT, the driver will check to see if the type map associated with the connection has an entry for the UDT

• If there is a matching entry, the driver will use that type map to custom map the UDT , other wise the driver will use the standard mapping.

Handling Errors• Any JDBC object encounters an error , it halt the execution and throws

an SQLException. Ex: database connection errors , malformed SQL statements and

insufficient database privileges etc.• The SQLException class extends the normal java.lang.Exception class

and defines some additional methods like getSQLState()and getErrorCode() to provide additional information about an error.

try{ }catch(SQLException e){ System.out.println(“SQL Exception occurred”); System.out.println(e.getMessage()); System.out.println(e.getSQLState()); System.out.println(e.getErrorCode());}

SQL Warning• JDBC classes have the option of generating a SQLWarnings when something is

not right• A warning is generated if, for example, you try to connect to a database with

the create attribute set to true if the database already exists. Aggregates like sum() also raise a warning if NULL values are encountered during the evaluation.

• SQLWarnings are rare, but provide information about the database access warnings

• The following objects can receive a warning:– Connection– Statement (also, PreparedStatement, CallableStatement)– ResultSet

• Warnings are retrieved by using the getWarnings() method• Call getWarning to obtain the warning object, and getNextWarning (on

the warning object) for any additional warningsSQLWarning connectionWarning = connection.getWarnings();SQLWarning statementWarning = statement.getWarnings();SQLWarning resultsetWarning = resultSet.getWarnings();

The Interactive SQL Tool• The interactive SQL tool is a means of entering and executing

SQL statements.• It will be a simple front end to the JDBC API.• It will provide a means of entering and executing SQL statements

and at the same time display areas for viewing results.• The requirement for the Interactive SQL tool class is:

to enable the user to enter and execute an SQL command to display the ResultSet from an SQL query to display the error information where appropriate.

• This can be implement as an application with a window based by using swing class JFrame and a swing component called JTable.

• The JTable calss is defined in the javax.swing.table package • The ResultSet is generated as table of data values, so JTable

component is ideal for displaying ResultSet.

TableModel Interface• To display a rectangular array of data on the screen, we

can use JTable component. • The TableModel interface declares methods that are

used by a JTable object to access the data item to be displayed at each position in the table.

• This interface is defined in the javax.swing.table package, along with the JTable class.

• The class which encapsulating a ResultSet need to implement this interface.

• The TableModel interface enables a Java Swing application to manage data in a JTable object.

class ResultsModel extends AbstractTableModel{ public void setResultSet(ResultSet rs){ } public int getColumnCount() {} pubic int getRowCount() { } public String getColumnName(int column){ } public String getValueAt(int row, int column) { }}public int getColumnCount(){ return columns.length;}pubic int getRowcount(){ return RowData == null ? 0 : RowData.size();}

public String getValueAt(int row,int column){ return RowData.elementAt(row)[column];}public String getColumnName(int column){ return columns[column] = = null ? “No Name” : columns[column];}Vector<String[]> RowData = new Vector<String[]>(); // To store the contents of

a row as an array of string objects public void setResultset(ResultSet rs){ try { ResultSetMetaData rsmt = rs.getMetaData();

int cols = rsmt.getColumnCount();columns = new String[cols];

for(int i=0; i<cols; i++){

columns[i]=rsmt.getColumnLabel(i+1);}RowData.clear();

while(rs.next()) {

rowdata = new String[cols]; for(int i=0;i<cols;i++) { rowdata[i] = rs.getString(i+1); } RowData.addElement(rowdata);

} fireTableChanged(null); /* It notifies all listeners for JTable object

that the mode has changed, so that JTable object should redraw from the scratch */

}catch(SQLException e){

System.out.println(e); }}