JDBC Interview Questions and Answers for 2025

Stored procedures contain the Set of SQL queries that are compiled in the database, and it will be executed from the JDBC API. For executing stored procedures in the database, we can use JDBC callable statement. The syntax for initializing the CallableStatement is:

CallableStatement cs = con.prepareCall("{call insertEmployee(?,?,?,?,?)}"); 
stmt.setInt(1, id); 
stmt.setString(2, name); 
stmt.setString(3, role); 
stmt.setString(4, address); 
stmt.setString(5, salary); 
//registering the OUT parameter before calling the stored procedure 
cs.registerOutParameter(5, java.sql.Types.VARCHAR); 
             
cs.executeUpdate();

One of the most frequently posed Java Database Connectivity questions and answers, be ready for this conceptual question.

As we understood what Batch processing and the advantages of Batch processing in the previous questions is, now let us understand them with an example program on how to run Batch processing. 

Batch Processing has the following steps: 

1. Load the driver class 
2. Create Connection 
3. Create Statement 
4. Add query in Batch 
5. Execute Batch 
6. Close Connection 

import java.sql.*;  
class FetchRecords{   
public static void main(String args[])throws Exception{   
            Class.forName("oracle.jdbc.driver.OracleDriver");   
            Connection con = DriverManager.getConnection 
                                                       ("jdbc:oracle:thin:@localhost:1521:xe","system","oracle");   
            con.setAutoCommit(false);   
   
             Statement stmt=con.createStatement();   
stmt.addBatch("insert into user420 values(190,'abhi',40000)");   
stmt.addBatch("insert into user420 values(191,'umesh',50000)");   
   
stmt.executeBatch();//executing the batch   
   
con.commit();   
con.close();   
} 
}   

Some of the most common JDBC exceptions are: 

1. java.sql.SQLException - It is the base class for JDBC exceptions. When any of the query or SQL execution goes wrong, we get this exception. 
2. java.sql.BatchUpdateException – It occurs during the batch update operation. May depend on the JDBC driver type that the base SQLException may throw instead. 
3. java.sql.SQLWarning – It is displayed as a warning message of various SQL operations. 
4. java.sql.DataTruncation – This exception occurs when data values are unexpectedly truncated due to reasons independent of exceeding MaxFieldSize. 

The “No suitable driver error” occurs during a call to the DriverManager.getConnection() method. It occurs due to the following reasons: 

1. When the driver is unable to call the respective driver class before calling the getDriverManager() method. 
2. When user passes an invalid or wrong JDBC URL, where the driver is not able to identify JDBC driver. 
3. This error can also occur when one or more shared libraries required for the application might not load during program execution. 

This is a common yet one of the most important JDBC interview questions and answers for experienced professionals, don't miss this one. Here is the difference table for reference.

Closing any database connection is considered as one of the Best Coding standards. We must always choose to closet the ResultSet, the Statement and the Connection. In some scenarios, if the connection is coming from the connection Pool on closure, then the connection is sent back to the Connection pool for reuse. This scenario will be handled in finally{ } block of exception handling, because if any exception occurs then we can get the option to close the connection.

Dirty Read indicates that, the given read value may or may not be correct or it is considered as a temporary value. Consider in a scenario when a transaction is executing and changing the values in the fields, at the same time another transaction also executed before the first transaction is committed or rollback the value, which results in invalid value to the field. This scenario is known as Dirty Read.

source

The important features of JDBC 3.0 are: 

1. JDBC RowSet 
2. Savepoint in transaction management : it helps to create, rollback and release the savepoint by using Connection.setSavePoint(), Connection.rollBack() and Connection.relaeseSavePoint() methods 
3. Statement and ResultSet Caching for Connection Pooling 
4. Switching between Global and Local Transactions 
5. Retrieval of auto generated keys 

The important features of JDBC4.0 are: 

1. Automatic Loading of Driver class 
2. Subclasses of SQLException 
3. New methods introduced in Connection, PreparedStatement, CallableStatement, ResultSet etc. 
4. Improved DataSource 
5. Event Handling support in Statement for Connection Pooling 

A staple in JDBC interview questions and answers, be prepared to answer this one using your hands-on experience.

The Connection Interface provides set of methods for JDBC Transaction Management. They are: 

• setAutoCommit() method 
• commit() method 
• rollback() method 
• setSavePoint() method 
• releaseSavePoint() method

setAutoCommit(): The default value of autoCommit is always set to TRUE. After the execution of SQL statement, the data will be committed automatically. By using this method we can set value for autoCommit().

Syntax: 

con.setAutoCommit(boolean_value) 

a. Commit(): The commit() is used for committing the data. After SQL statement execution, we can call commit() method. It will make sure to commit the changes made by SQL statements. 

Syntax: con.commit();

b. rollback() method: The rollback() is used to undo the changes made in the last commit. If any problem occurs during the execution of a statement flow, we can call rollback()  

Syntax: con.rollBack();

c. setSavePoint(): If you have setSavePoint() method in the transaction, you can use rollback() method to undo all the changes done in the previous transaction, this we can do till the savePoint or after the savePoint() we can set the savePoint value which refers to the current state of the database within transaction. 

Syntax: Savepoint sp= con.setSavepoint("MysavePoint");

d. releaseSavepoint() method: The main job of releasing save point is to release or delete the data created using savePoint. 

Syntax: con.releaseSavepoint("MysavePoint");

One of the limitations of PreparedStatement is that we cannot use it directly with IN Clause statement. Some of the alternative approaches to use PreparedStatement with IN clause are: 

• Execute Single Queries 
• Using Stored Procedure 
• Creating PreparedStatement Query dynamically 
• Using NULL in PreparedStatement Query

The Two-Phase commit is used for distributed environment where multiple processes take part Distributed Transaction Management. In simple words, we can say it as if the transaction is executing and it is affecting multiple databases then the Two-phase commit will be used to make sure that all the databases are synchronized to each other.  

In Two-Phase commit, rollback and commit are performed by two phases. 

1. Commit request phase: In this process, the coordinator process takes vote from all other process, that they have completed execution. If all the votes are ‘Yes’, then it continues to the next phase. 
2. Commit Phase: The commit phase depends on the given vote in the commit request phase. If all the votes are Yes, then commit is done. 

To Connect an excel spreadsheet using JDBC we can follow the below steps: 

1. First setup the new ODBC datasource 
2. Goto Administrative tools – then datasource (ODBC) - then choose system DSN tab – Click on Add – then choose the driver do Microsoft Excel (*.xls) – finally click on finish. 
3. Now provide the datasource name and description 
4. Then click select workbook and point it to the respective excel sheet. 

Let us code the above steps here: 

Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”); 
Connection con = DriverManager.getConnection(“jdbcodbcSampleExcelTest”,””,””); 
Statement stmt = con.createStatement(); 
Sql = “Select * from [Sheet1$]”; 
Result rs = stmt.executeQuery(sql); 

A RowSet is an object that encapsulates a set of rows from JDBC ResultSet or tabular data source. 

There are 5 types of RowSet available in JDBC: 

1. JDBCRowSet: RowSet is called the connected JDBCRowSet which means it always has an active database connection. This will be having live connection with database. The JDBC calls to the rowSet are mapped to the JDBC Connection, Statement, ResultSet. The Oracle implementation of rowSet is done using the package oracle.jdbc.rowset.OracleJDBCRowSet 
2. CachedRowSet: In CachedRowSet, the rows will always be cached and the RowSet is disconnected, which means it does not maintain an active database connection. The oracle.jdbc.rowset.OracleCachedRowSet class is used as the Oracle implementation of CachedRowSet. 
3. WebRowSet: WebRowSet is an extension to CachedRowSet and it represents a set of retrieved rows of tabular data that can be used between tiers and components so that no active data source connections need to be maintained. The Oracle implementation of WebRowSet is done by using oracle.jdbc.rowset.OracleWebRowSet. 
4. FilteredRowSet: It is an extension to WebRowSet, it gives application support to filter its content. This enables us to avoid the difficulty of queries and data processin. The Oracle implementation of FilteredRowSet is done by using oracle.jdbc.rowset.OracleFilteredRowSet. 
5. JoinRowSet: It is also an extension to WebRowSet. There is no proper way to establish a SQL JOIN operation between the disconnected RowSets. To handle this case a JoinRowSet is introduced. The Oracle implementation of JoinRowSet is done by using oracle.jdbc.rowset.OracleJoinRowSet class.

To get the first 100 rows and then again going back and retrieving the next 100 rows from the 1000 rows table we can use Statement.fetchSize() method to indicate the size of each database fetch.

This, along with other interview questions on JDBC for freshers, is a regular feature in JDBC interviews, be ready to tackle it with the approach mentioned below.

• StoredProcedure is a group of SQL queries. The StoredProcedure are executed in a single logical unit of time, we do not need to execute each query separately.  
• The name of each StoredProcedure should be unique, since each procedure is represented by its name. 
• For example, consider a scenario where you need to fetch the details of an employee and then can written as a StoredProcedure as below: 

DELIMITER $$ 
DROP PROCEDURE IF EXISTS `EMP`.`GET_EMP_DETAILS` $$ 
CREATE PROCEDURE `EMP`.`GET_EMP_DETAILS`  
  (IN EMP_ID INT, OUT EMP_DETAILS VARCHAR(255)) 
BEGIN 
  SELECT first INTO EMP_DETAILS 
  FROM Employees 
  WHERE ID = EMP_ID; 
END $$ 
DELIMITER ;

• These StoredProcedure are called using the CallableStatement available in the JDBC API.  

CallableStatement cs = con.prepareCall("{call GET_EMP_DETAILS(?,?)}"); 
ResultSet rs = cs.executeQuery(); 

There are three types of Parameters used in the StoredProcedure: 

1. IN: It is used to pass input values to the StoredProcedure using setXXX() we can set values to IN parameters 
2. OUT: It is used to fetch values from the StoredProcedure using getXXX(), we can get values from the OUT parameters 
3. IN/OUT: It is used for passing the input and output values to/ from the StoredProcedure. We can use setXXX() to set values and getXXX() to get values from StoredProcedure.

This question may not relate to JDBC interview question, but the answer will be indirectly supports JDBC so we can expect this question in an interview. 

• In the cold back process, the backup of data files is taken before restarting the database or when the database is not started.
• In the hot backup process, the backup of data is taken during the database execution or when the database is running. 

The SQL NULL and Java Null values will stand completely different to each other. There are three main things you can keep in mind. 

1. Avoid using getXXX() methods that return primitive datatypes. 
2. Use Wrapper classes for primitive datatypes and use the ResultSet object’s null() method to check whether the wrapper class variable that received the value returned by the getXXX() method is set to null. 
3. Use Wrapper classes for primitive datatypes and use the ResultSet object’s null() method to check whether the wrapper class variable that received the value returned by the getXXX() method is set to acceptable value which you have chosen to represent null. 

We can use `DatabaseMetaData` object to get the database server details. When the database connection is created successfully, we can get the meta data object by calling `getMetaData()` method. There are so many methods in DatabaseMetaData that we can use to get the database product name, it's version and configuration details.

DatabaseMetaData metaData = con.getMetaData();
String dbProduct = metaData.getDatabaseProductName();

This, along with other interview questions on JDBC for freshers, is a regular feature in JDBC interviews, be ready to tackle it with the approach mentioned below.

In the below example, we will perform the insert, update and delete operation on a table by using Java program. Here we are using the target database system as Oracle, but the same technique can be applied for another database as well because.

Following are the steps to create this application. 

Step 1: Create “Emp” table 

Create table emp (emp_id number, empname varchar2(10), email varchar2(30), city varchar2(10));  

Step 2: Develop the Java application  

import java.sql.*; 
class EmployeeRecord 
{ 
     public static final String DBURL = "jdbc:oracle:thin:@localhost:1521:XE"; 
     public static final String DBUSER = "local"; 
     public static final String DBPASS = "test"; 
     public static void main(String args[]) 
     { 
          try 
          { 
               //Loading the driver 
               Class.forName("oracle.jdbc.driver.OracleDriver"); 
               //Create the connection object 
               Connection con = DriverManager.getConnection(DBURL, DBUSER, DBPASS); 
               //Insert the record 
               String sql = "INSERT INTO emp (emp_id, empname, email, city) VALUES (?, ?, ?, ?)"; 
               PreparedStatement statement = con.prepareStatement(sql); 
               statement.setInt(1, 100); 
               statement.setString(2, "Prashant"); 
               statement.setString(3, "prasant@saxena.com"); 
               statement.setString(4, "Pune"); 
 
               int rowsInserted = statement.executeUpdate(); 
               if (rowsInserted > 0) 
               { 
                    System.out.println("A new employee was inserted successfully!\n"); 
               } 
               // Display the record 
               String sql1 = "SELECT * FROM Emp"; 
               Statement stmt = con.createStatement(); 
               ResultSet result = stmt.executeQuery(sql1); 
 
               while (result.next()) 
               { 
                    System.out.println (result.getInt(1)+" "+ 
                    result.getString(2)+" "+ 
                    result.getString(3)+" "+ 
                    result.getString(4)); 
               } 
 
               //Update the record 
               String sql2 = "Update Emp set email = ? where empname = ?"; 
               PreparedStatement pstmt = con.prepareStatement(sql2); 
               pstmt.setString(1, "Jaya@gmail.com"); 
               pstmt.setString(2, "Jaya"); 
               int rowUpdate = pstmt.executeUpdate(); 
               if (rowUpdate > 0) 
               { 
                    System.out.println("\nRecord updated successfully!!\n"); 
               } 
 
               //Delete the record 
               String sql3 = "DELETE FROM Emp WHERE empname=?"; 
               PreparedStatement statement1 = con.prepareStatement(sql3); 
               statement1.setString(1, "Prashant"); 
 
               int rowsDeleted = statement1.executeUpdate(); 
               if (rowsDeleted > 0) 
               { 
                    System.out.println("A Employee was deleted successfully!\n"); 
               } 
          } 
          catch(Exception ex) 
          { 
               ex.printStackTrace(); 
          } 
     } 
}

The best Practice to be followed while using JDBC application are listed below:

• Use the PreparedStatement
• Use the ConnectionPool
• Disable auto-commit mode
• Use JDBC Batch update methods
• Access ResultSet using column name to avoid invalidColumnIndexError
• Use data binding variables instead of String concatenation
• Always close database Statements, PreparedStatement and Connections
• Choose proper JDBC driver for your application as per the requirement
• Use standard SQL statements and try to avoid DB specific queries
• Use proper getXXX() methods and setXXX() methods