File
Java MS Access database connectivity
Follow these steps:
1)Go to the start->Control Panel->Administrative Tools-
> data sources.
2)Click Add button and select the driver Microsoft
Access Driver(*.mdb).
3)After selecting the driver, click finish button.
4)Then give Data Source Name and click ok button.
5)Your DSN will get created.
6) Restart your compiler and compile your java code.
DBC Steps to be followed while writing JDBC program:
Loading Driver
Establishing Connection
Executing Statements
Getting Results
Closing Database Connection
Loading Driver
Loading Database driver is very first step towards making JDBC connectivity with the database. It is necessary to load the JDBC drivers before attempting to connect to the
database. The JDBC drivers automatically register themselves with the JDBC system when loaded. Here is the code for loading the JDBC driver:
Class.forName(driver).newInstance();
Establishing Connection
In the above step we have loaded the database driver to be used. Now its time to make the connection with the database server. In the Establishing Connection step we will logon to the database with user name and password. Following code we have used to make the connection with the database: con = DriverManager.getConnection(url+db, user, p ass);
Executing Statements
In the previous step we established the connection with the database, now its time to execute query against database. You can run any type of query against database to perform database operations. In this example we will select all the rows from employee table. Here is the code that actually execute the statements against database:
ResultSet rs = st.executeQuery(
"SELECT * FROM Hi" );
Getting Results
In this step we receives the result of execute statement. In this case we will fetch the employees records from the recordset object and show on the console. Here is the code:
while (rs.next()) {
String Name = res.getInt( " name " );
System.out.println( Name );
}
Closing Database Connection
Finally it is necessary to disconnect from the database and release resources being used. If you don’t close the connection then in the production environment your application will fail due to hanging database connections.
Here is the code for disconnecting the application from database: con.close();
Ms Access
import java.sql.*; class Search{ public static void main(String[] args){ try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection con =
DriverManager.getConnection("jdbc:odbc:Data");
Statement st=con.createStatement();
ResultSet rs=st.executeQuery("select * from
Hi");
while(rs.next()){
System.out.println(rs.getString("ID")+"
"+rs.getString("Name"));
}
} catch(Exception e){
System.out.println(e);
}
}
}
Insert
import java.sql.*; class JavaApplication1{ public static void main(String[] args){ try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection con =
DriverManager.getConnection("jdbc:odbc:Data");
Statement st=con.createStatement(); int ID=5;
String Name ="Meena";
int i=st.executeUpdate("insert into Hi(ID,Name) values('"+ ID
+"','"+ Name +"')");
System.out.println("Row is added"); ResultSet rs=st.executeQuery("select * from Hi"); while(rs.next()){
System.out.println(rs.getString("ID")+"
"+rs.getString("Name"));
}
} catch(Exception e){
System.out.println(e);
}
}
}
Update
import java.sql.*; class Update{ public static void main(String[] args){ try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection con =
DriverManager.getConnection("jdbc:odbc:Data");
Statement st=con.createStatement();
int i=st.executeUpdate("update Hi set name='Reena' where ID = 3");
System.out.println("Row is updated");
}
}
ResultSet rs=st.executeQuery("select * from Hi"); while(rs.next()){
System.out.println(rs.getString("ID")+" "+rs.getString("Name"));
}
} catch(Exception e){
System.out.println(e);
}
Delete
import java.sql.*; class Delete{ public static void main(String[] args){ try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection con =
DriverManager.getConnection("jdbc:odbc:Data");
Statement st=con.createStatement();
int i=st.executeUpdate("delete from Hi where id=3");
System.out.println("Row is deleted");
ResultSet rs=st.executeQuery("select * from Hi"); while(rs.next()){
System.out.println(rs.getString("ID")+"
"+rs.getString("Name"));
}
} catch(Exception e){
System.out.println(e);
}
}
}
Difference between Statement & PreparedStatement
There are four steps for the execution of query :
• Query is parsed,
• Query is compile,
• Query is optimized and
• Query is executed.
In case of statement interface these four steps are performed ,each time when query is submitted for execution.
But in case of prepared statement first three steps are performed only once, when the query in initially submitted. Only the last step is performed each time query is submitted(in subsequence submissions), i.e if same query is submitted to be execute with different values multiple times then prepared statement interface provides better perfromance as compared to statement interface.*
•Comparing with the execution control of Statement
–
1) executeXXX() method is invoked on the SQL statement executeUpdate(), executeQuery()
2) The Statement object submits SQL Statement to DB
3) The DB compiles the given SQL statement
4) An execution plan is prepared by DB to execute the statement
5) Execution plan is then executed.
If SQL contains SELECT, the results are cached in buffer–
Results are sent to the Statement object
6) Finally, response is sent to java application executeUpdate() methods
Normal statement execution
–Compilation includes syntax check, name validation etc.–After validation, query optimizer prepares execution plan
•Returns best execution plan
•SQL statement goes thru above every time it is executed
•If same query is executed multiple times,
– Then execution plan can be saved and reuse it– This stored execution plan is known as pre-compiled statement
• The PreparedStatement interface is designed for it –Hence, their execution is much faster compared to statement
when using PreparedStatement
–Must be associated with one connection
–It represents the execution plan, need to pass parameters
–On connection close, it implicitly gets closed
–Execution of query is processed as follows
The connection object submits the SQL statement todatabase
Database compiles the given statement
•Execution plan is prepared by the database
•Database returns the execution plan with unique id–Connection object– The setXXX() methods are used to set the parameters of
SQL– executeXXX () method is invoked to execute the SQL
–Database executes the execution plan with supplied parameters–Finall the result is sent to the java application
Advantages
–Improves the application performance compared to
Statement()
–Inserts or updates SQL99 data types
•CLOB, BLOB
–Provides a programming approach to set the values
•Disadvantages
–Can represent only one SQL statement at a time
–Can not execute more than one SQL statement in a single
PreparedStatement
•
Situations when it is useful to use
–A single query is executed multiple times
–When a query consists of numerous parameters and complex types
Preapre Statement Example
import java.sql.*;
public class Prepare {
static private final String driver =
"sun.jdbc.odbc.JdbcOdbcDriver"; static private final String connection = "jdbc:odbc:emp";
public static void main(String args[]) {
Connection con = null;
PreparedStatement pst = null;
ResultSet rs = null;
try {
Class.forName(driver); con = DriverManager.getConnection(connection); con.setAutoCommit(false);
String sql =
"insert into Employees (ID,FirstName,LastName) values(?,?,?)"; pst = con.prepareStatement(sql); pst.setInt(1,4); pst.setString(2, "DDD"); pst.setString(3, "JOSHI");
pst.executeUpdate(); pst.close(); sql = "select * from Employees"; pst = con.prepareStatement(sql); rs = pst.executeQuery(); while (rs.next()) {
System.out.print(rs.getString(1) + "\t");
System.out.print(rs.getString(2) + "\t");
System.out.println(rs.getString(3));
}
rs.close(); pst.close(); con.close();
}
} catch (Exception e) {
}
}
Preapre Statement Update Example
import java.sql.*;
public class UpdatePre {
static private final String driver =
"sun.jdbc.odbc.JdbcOdbcDriver"; static private final String connection = "jdbc:odbc:emp";
public static void main(String args[]) {
Connection con = null;
PreparedStatement pst = null;
ResultSet rs = null;
try {
Class.forName(driver); con = DriverManager.getConnection(connection); con.setAutoCommit(false);
String sql = "update Employees set LastName = ? where id =?"; pst = con.prepareStatement(sql); pst.setString(1,"DAVE"); pst.setInt(2, 2); pst.executeUpdate(); pst.close();
// System.out.println("updated"); sql = "select * from Employees";
pst = con.prepareStatement(sql);
rs = pst.executeQuery();
while (rs.next()) {
System.out.print(rs.getString(1) + "\t");
System.out.print(rs.getString(2) + "\t");
System.out.println(rs.getString(3));
} rs.close(); pst.close(); con.close();
}
} catch (Exception e) {
}
}
JDBC with MySQL
To connect java application to MySQL database we must have at least one database created in MySQL.
And to create database in MySQL, it should be installed on your system.
So first of all install MySQL database in your system.
After installing it open MySQL console.
Create database with syntax create database databasename; and press enter.
You can see message like Query OK, 1 row affected
(0.03 sec)
Now our database is created in MySQL. Second step is to create table in our database.
For creating table in particular database type
Use databasename; and press enter and you can see message like database changed.
Now for creating table type create table tablename
(field1 type of field1, field2 type of field2, field3 type of field3);
Now press enter again you can see the message like
Query OK, 0 row affected (0.01 sec).
EX:
Create database java;
Use java;
Create table data (id int,name char(20),city char(20),age int);
Now the next step is to insert data into our table.
For inserting data simply type insert into table name (field1,field2,field3) values (value1,value2,value3);
EX:
insert into data (id,name,city,age) values (1,“ROMA",”AHM",30);
So by that’s way you can insert as many data as you want in your table. Now for viewing our data from table just type
select * from tablename;
EX:
select * from data;
String which we are writing in
Class.forName("com.mysql.jdbc.Driver"); to load the driver.
String which we are writing in Connection con =
DriverManager.getConnection("jdbc:mysql://localhost:3
306/java","root",”Root") to create connection with particular database.
Here the string jdbc:mysql://localhost:3306 is for connecting
MySQL to JDBC in our local system and the name /java is our database name and 1st "root" is username of MySQL and 2nd
“Root" is password of MySQL.
Here no need of Data Source Name as in access but one jar file named mysql-connector-java-5.1.6bin.jar must be loded in your java IDE.
For adding jar file simply right click on your project and select Set configuration Customize library and you can see window like this.
Select option add JAR/Folder.
JDBC
import java.sql.*; public class MySqlDemo1
{ public static void main(String[] args)
{ try
{
Class.forName("com.mysql.jdbc.Driver");
System.out.println("Driver is loaded");
Connection c =
DriverManager.getConnection("jdbc:mysql://localhost:3306/java",
"root","Root");
System.out.println("Connection created");
Statement s = c.createStatement();
ResultSet rs = s.executeQuery("select * from data");
System.out.println("ID\tName\tCity\tAge"); while(rs.next()) // Retrieve data from ResultSet
{
System.out.println(rs.getString(1)+"\t"+rs.getString(2)+"\t"+rs.getString(3)+"\t"+r s.getString(4));
}
}}
} catch(Exception e)
{
System.out.println("Exception : " +e);
}
Stored procedure in MySql
Now we all know that for CallableStatement first of all we must have stored procedure in our database.
Now how can we create stored procedure in MySQL.
For that follow the steps given below.
We already create a database in MySQL now for creating stored procedure for that particular database
Use java; (use databasename;)
Example stored procedure for addition of two numbers.
DELIMITER $$
CREATE PROCEDURE `addproc`( IN a INT, IN b
INT, OUT c INT)
BEGIN
SET c = a + b;
END$$
You can get message like Query OK, 0 rows affected
(0.00 sec)
It means your stored procedure is created successfully.
Here we create stored procedure for add two int number.
The stored procedure has 2 IN parameter and 1 OUT parameter so total 3 parameters
JDBC program for Callable
mport java.sql.*; public class Mysql_CallableDemo
{ public static void main(String[] args)
{ try
{
Class.forName("com.mysql.jdbc.Driver");
System.out.println("Driver is loaded");
Connection c =
DriverManager.getConnection("jdbc:mysql://localhost:3306/ java","root","Root");
System.out.println("Connection created");
}
String q = "call addproc(?,?,?)";
CallableStatement cs = c.prepareCall(q); cs.setInt(1, 10); cs.setInt(2, 20); cs.registerOutParameter(3, Types.INTEGER); cs.execute();
} catch(Exception e)
{ int add = cs.getInt(3);
System.out.println("addition = "+add);
System.out.println("Exception : " +e);
}
}
Using finally()
import java.sql.*; public class Mydemo
{ public static void main(String[] args) throws SQLException
{
Connection c = null; try
{
Class.forName("com.mysql.jdbc.Driver");
System.out.println("Driver is loaded"); c =
DriverManager.getConnection("jdbc:mysql://localhost:3306/java","root","
Root");
System.out.println("Connection created");
Statement s = c.createStatement();
ResultSet rs = s.executeQuery("select * from data");
System.out.println("ID\tName\tCity\tAge"); while(rs.next()) // Retrieve data from ResultSet
{
System.out.println(rs.getString(1)+"\t"+rs.getString(2)+"\t"+r s.getString(3)+"\t"+rs.getString(4));
}
}}
} catch(Exception e)
{
System.out.println("Exception : " +e);
} finally
{ c.close();
}
