Java versus PL/SQL Stored Procedure Issues

Question

I am getting a result that is 30 times slower for Java when compared with PLSQL. Can you tell me if that is normal or am I missing something?
Thanks in advance for your help,
Gaurav Pal
Java Developer,
SCJP 1.1, SCJP 2, SCJD 2
Timing results
---------------- Java ------------------------
Total Time taken for 10 calls: 4667
Result: 466 Time: 466
---------------- PLSQL ------------------------
Total Time taken for 10 calls: 150
Result: 466 Time: 15
Java Code
public static int getCursorCount()
int count = 0;
//define iterator for select
count_iter myIter = null;
try
#sql myIter = { SELECT lastname FROM employee };
while(myIter.next())
count++;
myIter.close();
catch(SQLException excp)
return count;
PL/SQL Code
function get_count_cursor_sf
return
number
is
cursor count_cursor is
select lastname from employee;
v_return_count number := 0;
v_name employee.lastname%type;
begin
open count_cursor;
fetch count_cursor into v_name;
while (count_cursor%found) loop
fetch count_cursor into v_name;
v_return_count := v_return_count + 1;
end loop;
--Return the variable
return v_return_count;
end ;
Calling Code
public class DBCall
public static void main(String args[])
try
makeJavaCalls();
makePLSQLCalls();
catch(Exception excp)
excp.printStackTrace();
public static Connection getConnection() throws Exception
Class.forName("oracle.jdbc.driver.OracleDriver");
return DriverManager.getConnection("jdbc:oracle:thin:@10.0.0.3:1521:oracleee","rda","rdauser");
public static void makePLSQLCalls() throws Exception
int count = 10;
long time = 0;
int result = 0;
while(count > 0)
Connection conn = getConnection();
CallableStatement cs = conn.prepareCall("{? = call rda_plsql_pkg.get_count_cursor_sf()}");
cs.registerOutParameter(1, Types.INTEGER);
long before = System.currentTimeMillis();
cs.execute();
result = cs.getInt(1);
long after = System.currentTimeMillis();
time = time + (after - before);
cs.close();
conn.close();
count--;
System.out.println("---------------- PLSQL ------------------------");
System.out.println("Total Time taken for 10 calls: " + time);
System.out.println("Result: " + result + " Time: " + (time/10));
public static void makeJavaCalls() throws Exception
int count = 10;
long time = 0;
int result = 0;
while(count > 0)
Connection conn = getConnection();
CallableStatement cs = conn.prepareCall("{? = call dorknight.getcursorcount()}");
cs.registerOutParameter(1, Types.INTEGER);
long before = System.currentTimeMillis();
cs.execute();
result = cs.getInt(1);
long after = System.currentTimeMillis();
time = time + (after - before);
cs.close();
conn.close();
count--;
System.out.println("---------------- Java ------------------------");
System.out.println("Total Time taken for 10 calls: " + time);
System.out.println("Result: " + result + " Time: " + (time/10));
null

Answer 1

A big contributor to the behavior seen here is that there is a one-time overhead per session (= per database connection) to start the JavaVM and also (in 8.1.6 and earlier) to initialize the SQLJ runtime (via reflection).
Keeping the same connection for subsequent calls to Java (which is the more typical scenario, anyway) will result in a rather considerable speedup.