P. 1


|Views: 73|Likes:
Published by api-3749401

More info:

Published by: api-3749401 on Oct 16, 2008
Copyright:Attribution Non-commercial


Read on Scribd mobile: iPhone, iPad and Android.
download as DOC, PDF, TXT or read online from Scribd
See more
See less






SQL is a language used to create, manipulate, examine and manage relational databases. SQL was standardized in 1992 so that a program could communicate with most database systems without having to change the SQL commands. Unfortunately you must connect to a database before sending SQL commands and each database vendor has a different interface as well as different extensions of SQL Microsoft ODBC API offers connectivity to almost all databases on almost all platforms and is widely used programming interface for accessing relational databases. But ODBC cannot be directly used with Java Programs due so various reasons and hence JDBC. JDBC does the following things: a) establish connection with a database b) send SQL statements c) processes the results JDBC v/s ODBC a) ODBC cannot be directly used with Java because it uses a C interface and calls from java to native C code have a lot of drawbacks in security, implementation, and portability. b) ODBC makes use of pointers, java does not c) ODBC requires manual installation of the ODBC driver manager and driver on all client machines. JDBC drivers are written in java and JDBC code is automatically installable, secure and portable JDBC Driver Models a) Two Tier Model In this model, the java applet / application interact directly with the database. A JDBC driver is required to communicate with the particular database management system that is being accessed. The SQL statements are sent to the database and the results are given to the user. This type of model is referred to as the client / server configuration where user is the client and the machine that has the database is called the server. Three Tier Model The reason for the middle tier is and it does the following a) Collection of SQL statements from the client and handing over the same to the DB b) Receiving results from the DB to the client c) Maintaining control over accessing and updating of the data. Middle tier until recently had been written in C and C++ which enable faster performance. With the introduction of optimizing compilers that translate java byte codes into machine specific code, it is not possible to implement the middle tier in java. Different types of Driver Managers The JDBC Driver Manager is used to connect Java Applications to the correct JDBC Driver. There are 4 types of JDBC Drivers and they are: a) JDBC – ODBC Bridge plus ODBC Driver

This is a Javasoft Bridge product that provides JDBC access via ODBC drivers. But as we mentioned combining ODBC brings in a lot of drawbacks and limitations. Since the ODBC driver have to be present in all the client machines, this is not suitable for large applications. b) Native – API party – Java Driver This driver converts JDBC calls into calls on the client API for Oracle, Sybase, Informix and other DBMS. But some binary code has to be loaded on all clients like the bridge driver and again not suitable for large applications. c) JDBC Net pure Java Driver This driver translates JDBC calls into DBMS independent net protocol. A server again translates this protocol into a DBMS protocol. This net server middleware connects its pure java clients to many different databases. The type of protocol in this middleware depends on the vendor. d) Native Protocol pure Java Drivers These driers convert JDBC calls to network protocols used by the DBMS directory and the requests from client machines are made directly to the DBMS server. Accessing ODBC databases with JDBC-ODBC Bridge The ODBC Bridge is a thin layer over JDBC. All JDBC methods are mapped to ODBC calls and thus interact with ODBC driver’s thereby enabling access to a wide range of databases. DriverManager Class The DriverManager class is the primary class that has the driver information. Whenever a driver is loaded, it registers with the DriverManager class. This class enables selection of the same whenever there is a request for connection to the Database. This class has the method getConnection (). Driver Interface This is implemented by the JDBC drivers. Writing a JDBC driver consist of creating java class that implements the driver interface. Connection Interface The methods are Close() GetMetaData() – returns an object of DatabaseMetaData interface that can be used to obtain detailed information about the structure and capabilities of the database. CreateStatement() – creates a SQL PreparedStatement object using a SQL string. PrepareCall() – creates a SQL CallableStatement object using a SQL string. A Connection object represents a connection with the database. 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 multiple databases. Establishing Connection: For this you will have to a) Load the Driver and b) Make Connection.


For Loading the dirvers, we use the JDBC-ODBC Bridge Driver and the following code with load it: Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”); For a Oraclei Driver you would use Class.forName(“oracle.jdbc.driver.OracleDriver”);


You need for create an instance of the Driver and register it with the Driver Manager because calling Class.forName() will do that for u automatically. If you were to create ur own instance, you would be creating an unnecessary duplicate, but with no harm and u do it the following way DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());

When u have loaded a driver, it is available for making a connection with a DBMS. Making the Connection The second step is establishing a connection is to have the appropriate driver connected to the DBMS. The following code will do it Connection con = DriverManager.getConnection(url,”mylogin”,”mypassword”); The JDBC URL provides a way for identifying the database so that the appropriate Driver will recognize it and establish the connection. It would be jdbc:<subprotocol>:<subname>. The protocol in JDBC is always JDBC The normal way in Oracle8 would be String url = “jdbc:odbc:Oracle8” Connection con = DriverManager.getConnection (url,”scott”,”tiger”); Accessing the Database Once we have connected to the database, we can request information on the names of the tabes and the names and contents of their columns and we can run SQL statements that either query the database or add to or modify its contents. The objects that we can use to obtain information from the database are: a) DatabasemetaData : Information about the database as a whole; tablenames, table index, database product name and version, actions supported by database. b) ResultSet – Information about a table or a result of a query. We can access the data row by row, but an access the columns in any order. c) ResultSetMetaData – Inforamtion about the column names and types in a Result Set. SQL Statements The Statement Interface defines methods that are used to interact with databases via the excution of the SQL statements. These methods also support the processing of query results returned via ResultSet objects and provide control over the mechanics of query processing.

Execute() ExecuteUpdate() ExecuteQuery() Once a connection is established, it is used to pass SQL statements to its underlying database. JDBC do not put any restriction on the kinds of SQL statements that can b send. Therefore the user must be responsible for making sure that the underlying database can process the SQL statements being send. The following are the quick way to determine which Connection method is appropriate for creating different types of SQL statements: a) createStatement method is used for simple SQL statements (no parameters) b) prepareStatement is used for SQL statements with one or more in parameters and simpl statements that are executed frequently. c) PrepareCall method is used for call to stored procedure. PreparedStatement Interface This interface defines methods that are used to work with precompiled SQL statements and this provides efficient way of executing frequently used SQL statements. Prepared Statement is useful when the same statement is to be repeated many number of times. For Example: select ? from emp and the ? mark will then be replaced by the parameter passed. The methods setInt, setString, setObject(), setDate(), setTime() etc are used to set the values to the appropriate parameters. PreparedStatement st = con.prepateStatement(“select * from item where pcode=?); st.setInt(1,100); Here the first parameter to setInt is the number of the argument i.e., only one parameter is passd. The second argument refers to the value. Here the details of the item whose product code is 100 will be contained in the result set. The CallableStatement Interface This interface is used to implement stored SQL procedure. CallableStatement objects are created via prepareCall() method of the Connection class. A Stored SQL procedure is passed as an argument to the prepareCall() method. A stored procedure is used when different types of clients need the same functionality. Another advantage of this is that it can be used to check for all types of constraints since the whole date is available to stored procedures. Creating JDBC Statements A Statement object is what sends your SQL statement to the DBMS. You simply create a Statement object and then execute it, supplying the appropriate execute method with the SQL statement you want to send. a) For SELECT statement, the method to use is executeQuery. b) For statements that create or modify tables, the method to use is executeUpdate. Statement stmt = con.createStatement().

At this point stmt exists, but it dos not have an SQL statement to pas on to the DBMS. We need to supply that to the method we use to execute stmt. For example, in the following code, we supply executeUpdate with the SQL statement as under: Stmt.executeUpdate(“CREATE TABLE BOOKS” + “(BOOK_NAME VARCHAR(30), SUP_ID INTEGER, PRICE FLOAT,”+”SALES INTEGER, TOTAL INTEGER”); We can make a string createTableBooks and assign this query to it and then use it in this alternate form. Stmt.executeUpdate(createTableBooks); Executing Statements We have used executeUpdate() because it is a DDL statement and all create, alter, drop are examples of DDL. We most commonly use executeQuery(). An Example import java.util.*; import java.sql.*; class Jdbc { public static void main(String[] args) { try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection c = DriverManager.getConnection("jdbc:odbc:oracle","scott","tiger"); DatabaseMetaData dm = c.getMetaData(); System.out.println("Database Name "+dm.getDatabaseProductName()); System.out.println("Database Version "+dm.getDatabaseProductVersion()); System.out.println("Database URL "+dm.getURL()); System.out.println("User Name "+dm.getUserName()); System.out.println("Database Driver " + dm.getDriverName()); System.out.println("Database Driver Version "+dm.getDriverVersion()); System.out.println(" Major Version "+dm.getDriverMajorVersion()); ResultSet rs = dm.getTables(null,null,null,null); while(rs.next()) { System.out.println(rs.getString(3)); } c.close(); } catch(Exception e) { System.out.println(e);

} } ResultSet The ResultSet is one of the most important object in JDBC. It is essentially an abstraction of a table of the general width and unknown length. Nearly all methods and queries return data as a ResultSet. It contains any number of named columns that u can ask for by name. Before u can use ResultSet, we need to ask how many columns it contains. This information is stored in the ResultSetMetaData. ResultSetMetaData We can obtains ResultSetMetaData from the ResultSet using the getMetaData() method. We can use this object to discover the number and type of columns and names of each column getColumnCount() GetColumnName(int I) – returns the name of the column number I getColumnType( int I) – returns the SQL database for this column. ResultSetMetadate rsmd; Rsmd = results.getMetaData(); noofcols = getColumnCount(); When we obtain a ResultSet, it points to just before the first row. We use the next() method to obtain each additional row and method returns false when no more rows remain. Since fetching data might results in an exception, we must always enclose our result set in try block. try { rsmd = results.getMetaData(); noofcols = getColumnCount(); while(more) { for (I=1; I<nosofcols; Iee) { SOP (results.getString(I)+” “ ); SOP() More = results.next(); } results.close(); } catch(Exception e) {} ResultSet rs = stmt.executeQuery(“SELECT BOOK_NAME, PRICE FROM BOOKS”); Using getXXX methods we can use the getXXX methods of the approprate type (Sting, int) to retrieve the value in each column. The method for retrieving value of Varchar is String.

DatabaseMetaData This gives information about the entire Database. getTables – returns a descriptin of the table names for all tables matching table names and all columns matching column names. getColumns – getURL() – Gets the name of the URL you are connected to. Transaction Processing A transaction consists of a group of related database operations. The SQL statements that make up a transaction update the database at the same time. Even though statement are executed in sequence, they do not permanently update the database until they are committed. If an error happens, the SQL statements are be rolled back. The setAutoCommit(), commit() and rollback() methods of the connection interface are used to implement transaction processing. If AutoCommit is turned on, then individual statements are organized into single transaction until a commit or rollback () is invoked. The getAutoCommit() is used to know the current autocommit state. Example First of all create the following table in oracle create table item( pcode Number (3), pname varchar2(20), price Number(3) ); List out the items in the Table import java.sql.*; import java.util.*; class Jdbc1 { public static void main(String[] args) { try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection c DriverManager.getConnection("jdbc:odbc:oracle","scott","tiger"); Statement st = c.createStatement(); System.out.println("Executing SQL");


ResultSet rs = st.executeQuery("Select * from item"); try { while(rs.next()) { System.out.println(rs.getInt("pcode")+ " ; "); System.out.println(rs.getString("pname")); System.out.println(rs.getString("price")); } } catch(Exception e) { System.out.println("Inside "+e); } } catch(Exception e) { System.out.println(e); } } } Insert new values into the table using ODBC import java.sql.*; import java.util.*; import java.io.*; class Jdbc2 { public static void main(String[] args) { try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection c DriverManager.getConnection("jdbc:odbc:oracle","scott","tiger"); Statement st = c.createStatement(); DataInputStream sin = new DataInputStream(System.in); System.out.println("Enter the code for the product"); System.out.flush(); String st2 = sin.readLine(); int y = Integer.parseInt(st2); DataInputStream rin = new DataInputStream(System.in); System.out.println("Enter the name of the product"); System.out.flush(); String st1 = rin.readLine(); DataInputStream tin = new DataInputStream(System.in);


System.out.println("Enter the price of the product"); System.out.flush(); String st3 = tin.readLine(); int z = Integer.parseInt(st3); try { int "+st1+","+z+")"); System.out.println("Number of rows affected = "+x); } catch(Exception e) { System.out.println("Inside "+e); } } catch (Exception e) { System.out.println(e); } } } The above example does not make use of prepared statement. Update a Record in the Table import java.sql.*; import java.util.*; class Jdbc3 { public static void main(String[] args) { try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection c DriverManager.getConnection("jdbc:odbc:oracle","scott","tiger"); Statement st = c.createStatement(); try { int x = st.executeUpdate("update item set pname = 'Margao' where pname='lux'"); System.out.println("Number of rows affected = "+x); } catch(Exception e) { System.out.println("Inside "+e); } } x = st.executeUpdate("insert into item values("+y+",


catch(Exception e) { System.out.println(e); } } } Delete a Row from the Table import java.sql.*; import java.util.*; class Jdbc4 { public static void main(String[] args) { try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection c DriverManager.getConnection("jdbc:odbc:oracle","scott","tiger"); Statement st = c.createStatement(); try { int x = st.executeUpdate("delete from item where pname = 'Margao'"); System.out.println("Number of rows affected = "+x); } catch(Exception e) { System.out.println("Inside "+e); } } catch(Exception e) { System.out.println(e); } } } Example of Prepared Statement import java.sql.*; import java.util.*; import java.io.*; class Jdbc5 { public static void main(String[] args) throws Exception { if( arg.length<3)


{ System.out.println("Pass pcode, pname and price as arguments"); } try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection c DriverManager.getConnection("jdbc:odbc:oracle","scott","tiger"); PreparedStatement values(?,?,?"+" )"); st.setInt(1,Integer.parseInt(arg[0]); st.setString(2,arg[1]); st.setInt(3,Integer.parseInt(arg[2]); try { int z = st.executeUpdate(); System.out.println("Number of rows affected = "+x); } catch(Exception e) { System.out.println("Inside "+e); } st.close(); c.clost() } catch(Exception e) { System.out.println(e); } } } Prepared Statement for Updating the Database import java.sql.*; import java.util.*; import java.io.*; class Jdbc6 { public static void main(String[] args) throws Exception { if( arg.length<2) { System.out.println("Pass pcode, pname and price as arguments"); } try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); st = c.createStatement("insert into = item

Connection c DriverManager.getConnection("jdbc:odbc:oracle","scott","tiger"); where code = ?"); st.setString(2,arg[1]); st.setInt(2,Integer.parseInt(arg[0]); try { int z = st.executeUpdate(); System.out.println("Number of rows affected = "+x); } catch(Exception e) { System.out.println("Inside "+e); } st.close(); c.clost() } catch(Exception e) { System.out.println(e); } } } Taking Records from Access Database


PreparedStatement st = c.createStatement("update item set pname=?

Make a Database in Access called as Book, with Bookname, Price and Bookcode. Insert some records and then run this program. import java.sql.*; import java.util.*; class JdbcAccess { public static void main(String[] args) { try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection c = DriverManager.getConnection("jdbc:odbc:access"); Statement st = c.createStatement(); System.out.println("Executing SQL"); ResultSet rs = st.executeQuery("Select * from Book"); try { while(rs.next()) { System.out.println(rs.getString("Bookname"));

System.out.println(rs.getInt("Price")); } } catch(Exception e) { System.out.println("Inside "+e); } } catch(Exception e) { System.out.println(e); } } }

JDBC Interface Level There are two JDBC interface levels: The Application layer is where the developer uses the API to make calls to the database via SQL and retrieve the results. The Driver layer handles all communication with a specific driver implementation. The driver layer is responsible for developing code that interfaces to the database and supports the JDBC application level calls. There are 4 main interfaces that every driver layer must implement and one class that bridges the Application and Driver layers. The 4 interfaces are Driver, Connection, Statement and Resultset. The Driver interface implementation is where the connection to the database is made. In most applications, the Driver is accessed through the DriverManager class – providing one more layer of abstraction for the developers. The Connection, Statement and Resultset interfaces are implemented by the driver vendor but these interfaces specify the methods that the developer can use. They allow the developer to create statements and retrieve results without having to think about where the objects are coming from or worry about what specific driver the application will use. Driver is an interface. Each vendor supplies a class that implements this interface. The other important class is the DriverManager class, which sits above the Driver and Application layers. The DriverManager class is responsible for loading and unloading drivers and making connections through drivers. The DriverManager class also provides features for logging and database login timeouts. Imp: The driver does not need to connect directly to a database and can support a new protocol for a multi tier database design. Every JDBC application must have atleast one JDBC driver implementation. The Driver interface allows the DriverManager and JDBC Application layers to exist independently of the particular database used. A JDBC driver is an implementation of the Driver interface class. Drivers use a string to locate and access database. The syntax is jdbc:drivername:password.

In this the database driver is oracle driver and the subname is a local database called products. This driver is designed to known how to use the subname when making the connection to the oracle database. A network naming service may also be specified as the subprotocol rather than using a specific database driver name. In this case, the subprotocol would define the naming service : jdbc:localnaming:human-resource. In this example, the subprotocol defines a local service that an resolve the subname humanresource to a database driver. This approach can be very useful when the developer wants to isolate the user from the actual location, name, database username and database password. This URL specifies a driver named localnaming this could be java program that contains a simple flat file lookup translates human-resource into hrddatabase1:eng:888/personnel and know to use the username user and password xyz. The details of the connection are hidden from the user. The Driver interface methods: public Connection connect (String url, Properties info) throws SQLException : This checks the subprotocol name of the URL string passed for a match with this driver. If there is a match the driver should then attempt to make a connection to the database using the information passed in the remainder of the URL. A successful database connection will return an instance of the driver’s implementation of a Connection interface. The SQLException will be through only if the driver recognizes the URL subprotocol but cannot make the database connection. A null is returned if the URL does not match a URL the driver expected. The username and password are included in an instance of the Properties container class. public boolean acceptsURL (String url) throws SQLException: Explicitly asks the driver if the URL is valid. Note that typically the implementation of this method checks only the subprotocol specified in the URL and not whether the connection can be made. The Connection object is used to create Statement object that perform queries. The Driver connect () typically performs the following steps: checks to see if the given URL is valid opens a TCP connection to the host and port number specified attempts to access the named database table returns an instance of a Connection Since Connection is a java interface, so the object returned is actually an instance of the vendor’s implementation of the Connection interface. DriverManager Class This is actually a utility class used to manage JDBC Drivers. The class provides methods to obtain a connection through a driver, register and deregister drivers, set up logging and set login timeouts for database access. synchronized Connection getConnection (String url, Properties info) throws SQL: This attempts to return a reference to an object implemented from the Connection interface. The method sweeps through a vector of stored Driver classes passing the URL string and Properties

object to each in turn. The first Driver class that returns a Connection is used and info is a reference to a Properties container object of username/password. Drivers are registered with the DriverManager class either at initialisation of the DriverManager class or when an instance of the driver is created. When the DriverManager class is loaded, a section of static code in the class is run and the class names of drivers listed in a java property named jdbc.drivers are loaded, which contains a list of colon seperated driver class names. Driver class implementation must explicitly register itself with the DriverManager by calling: DriverManager.registerDriver (this). Application Layer The Application layer encompasses 3 interfaces that are implemented by the Driver layer but are used by the developer. Once a Connection object returned, the developer may create a Statement object to issue SQL against the database. If the SQL that was submitted was a select query, then the result set is returned in a ResultSet Object. Connection Interface: The Connection interface represents a session with the database connection provided by the Driver. Typical database connections include the ability to control changes made to the actual data stored through transactions. On creation, the JDBC connections are in a auto commit mode – there is no rollback possible. So after getting a Connection object from the driver, the developer should consider setting auto commit to disable with a setAutoCommit (boolean b) method and then the Connection will support Connection.commit() and Connection.rollback(). The methods are Statement createStatement: The Connection object implementation will return an instance of a Statement object, which is then used to issue queries. PreparedStatement prepareStatement (String sql): The Connection object implementation will return an instance of a PreparedStatement object that is configured with the sql String passed. The Driver may then send the statement to the database, if the database driver handled precompiled statements. Otherwise the driver may wait until the PreparedStatement is executed by an execute statement. CallableStatement prepareCall (String sql): The Connection object implementation will return an instance of a CallableStatement. CallableStatements are optimised for handling stored procedures. The driver implementation may send the sql string immediately when prepareCall () is complete or may wait until an execute method occurs. The primary use of the Connection Interface is to create a statement: Connection c; Statement s; c = DriverManager.getConnection(url); s = c.createStatement(); This statement may be used to send SQL statements that return a single result set in a ResultSet object reference. Statements that need to be called a number of times with a slight variations may be executed more efficiently using a PreparedStatement. The Connection interface is also used to create a CallableStatement whose purpose is to execute stored procedures.

Statement Interface: A Statement is the vehicle for sending SQL queries to the database and retrieving a set of results. ResultSet executeQuery (String url): This executes a single query and returns the results in an object of type ResultSet. int executeUpdate (String s): This executes a single SQL update that returns a count of rows affected rather than a set of results. ResultSet getResultSet (): This returns the result of a statement execution as a ResultSet object. Note that if there are no results to be read or if the result is an update count, this method return null. Also note that once read, the results are cleared. int getUpdateCount(): This returns the status of an Update, an Insert or a Delete query, a stored procedure or a DLL statement. The value returned is the number of rows affected. boolean getMoreResults (): Moves to the next results in a set of multiple results / update counts. This method returns true if the next result is a ResultSet object. This method will also close any previous ResultSet read. PreparedStatement Interface The PreparedStatement interface extends the Statement interface. When there is a SQL statement that requires repetition with minor variations, the PreparedStatement provides the mechanism for passing a precompiled SQL statement that uses parameters. The setType methods fill the value of parameters (marked by question marks) in a PreparedStatement. These parameters are indexed from 1 to n. Parameters hold their current values until either a new setType method is called or the method clearParameters() is called for the PreparedStatement object. CallableStatement interface The CallableStatement interface is used to execute SQL stored produres. Callable Statement inherits from the PreparedStatement interface, so all of the execute and setType methods are avaliable. The syntax of stored Procedures varies among database vendors, so JDBC defines a standard way to call stored procedures in all RDBMS. public interface CallableStatement extends PreparedStatement The JDBC uses an escape syntax that allow parameters to be passed as in parameters and out parameters. The syntax also allow a result to be returned. If this syntax is used, the parameter must be registered as an out parameter. The ResultSet Interface The ResultSet interface defines methods for accessing tables of data generated as a result of executing a Statement. ResultSet column values may be accessed in any order – they are indexed and may be selected by either the name or the number (1 to n) of the column. ResultSet maintains the position of the current row, starting with the first row of data returned. The next () moves to the next row of data.

ResultSetMetaData get MetaData(): Returns an object that contains a description of the current result set including the number of columns the type of each column and properties of the results. JDBC Package java.sql contains classes and interfaces for manipulating relational databases in Java. Interface Connection helps manage the connection between the Java program and the database. It also provides support for executing SQL statements to manipulate the database and transaction processing. Connecting to a database requires the database URL (Uniform Resource Locator) that helps the program to locate the database (possibly on a network or in the local file system of the computer) and may require a username and password for logging in to the database. The database URL specifies the protocol for communication, the subprotocol for communication and the name of the database. The subprotocol odbc indicates that the program will be using jdbc and JDBC-to-ODBC bridge driver to connect to a Microsoft ODBC data source. ODBC is a technology developed by Microsoft to allow generic access to disparate database systems on the windows platform. The Java 2 SDK comes with a JDBC-to-ODBC bridge database driver to allow any java program to access any ODBC data source. The driver is defined by class JdbcOdbcDriver in package sun.jdbc.odbc. Method forName of class Class is used to load the class definition for a database driver. Class sun.jdbc.odbc.JdbcOdbcDriver represents the JDBC-to-ODBC bridge driver. Method getConnection of class DriverManager attempts a connection to the database specified by its argument (the database URL). If the DriverManager cannot connect to the database, method getConnection throws a java.sql.SQLException. A statement (package java.sql) object is used to submit a query to a database. When a query is performed on a database, a ResultSet object is returned containing the results of the query. The methods of interface ResultSet allow the programmer to manipulate the query results. Connection method createStatement obtains a Statement object that will be used to manipulate the database. Statement method executeQuery returns an object that implements interface ResultSet and contains the result of a query. ResultSet method next positions the cursor to the next record in the ResultSet. Initially the ResultSet cursor is positioned before the first record, so this method must be called before you can access the results. Method next returns a boolean value indicating if it was able to position to the next record. If the method returns false, there is no more records to process. ResultSet method getMetaData return the meta data for the ResultSet in a ResultSetMetaData object. The meta data for the ResultSet describes the contents of a ResultSet. This information can be used to obtain information about the names and types of the ResultSet columns and can help the programmer process a ResultSet dynamically when detailed information about the ResultSet is not known in advance of the query.

ResultSetMetaData method getColumnCount returns the number of columns in the ResultSet. ResultSetMetaData method getColumnName returns the name of the specified column. ResultsSetMetaData method getColumnType returns a constant integer from class Types indicating the type of the data. To connect to an ODBC data source the database must be registered with the system through the ODBC Data Sources option in the windows control panel. The basic format of an INSERT INTO SQL statement is “ INSERT INTO tablename (Column1, Column2..) VALUES (‘value1’, ‘value2’..), where tablename is the table in which the data will be inserted. Each column name to be updated is specified in a comma-separated list in parentheses. The value for each column is specified after the SQL keywords VALUES in another comma separated list in parentheses. Statement method executeUpdate sends a SQL statement into the database that updates a record or adds a new record. The method returns an int indicating the success or failure of the update operation. The basic Update SQL statement has the form: UPDATA tablename SET column1=’value1’, column2=’value2’ WHERE criteria. If the database supports transaction processing – changes made to the database can be undone. Java provides transaction processing via several methods of interface Connection. Method setAutoCommit determines if each individual SQL statement should be performed and committed individually or in several SQL statements should be grouped as a transaction. If the argument to setAutoCommit is false, the Statement used to executed the SQL statements must be terminated with a call to Connection method commit or method rollback. Interface Connection also provides method getAutoCommit that returns to determine the auto commit state.

You're Reading a Free Preview

/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->