Statement vs PreparedStatements which is better in which situation

Question

Hi i read in a few forums and a few articles that PreparedStatement object performs better than the Statement object in situations where a high number of the same sqls are used because it precompiles the sql statement. such as inserting a 1000 employees into a table.
i did the following test and found that the gain for using PreparedStatements is sometimes not a gain but a loss.
What the test basically does is that it inserts an item into the table a 2000 times using both PreparedStatements and Statement objects. And it switches between which object it uses to insert item into the table. So in the end 1000 items would have been inserted using PreparedStatements and 1000 using Statement objects.
Am i doing somthing wrong with my test or is the so called gain by using PreparedStatements a fluke. Please advise.
import java.sql.*;
public class TEST {
    static int Prepcount = 1;
    static long PreptotalTime = 0;
    static long PrepstartTime = 0;
    static long PrependTime = 0;
    static long Prepavarage = 0;
    static int Stmtcount = 1;
    static long StmttotalTime = 0;
    static long StmtstartTime = 0;
    static long StmtendTime = 0;
    static long Stmtavarage = 0;
    static PreparedStatement pst;
    static Statement stmt;
    static ResultSet rs;
    static Connection conn;
    public static void usePrep() {
        try {
            pst = conn.prepareStatement("insert into Dhanu values (?,?)");
            PrepstartTime = System.currentTimeMillis();
            pst.setInt(1, Prepcount);
            pst.setInt(2, Prepcount);
            pst.executeQuery();
            PrependTime = System.currentTimeMillis();
            PreptotalTime = PreptotalTime + (PrependTime - PrepstartTime);
            Prepavarage = PreptotalTime / Prepcount;
            Prepcount++;
            pst.close();
        } catch (Exception e) {
            e.printStackTrace();
    public static void useStatement() {
        try {
            StmtstartTime = System.currentTimeMillis();
            stmt = conn.createStatement();
            rs = stmt.executeQuery("insert into Dhanu values ("+Stmtcount+","+Stmtcount+")");
            StmtendTime = System.currentTimeMillis();
            StmttotalTime = StmttotalTime + (StmtendTime - StmtstartTime);
            Stmtavarage = StmttotalTime / Stmtcount;
            Stmtcount++;
            rs.close();
            stmt.close();
        } catch (Exception e) {
            e.printStackTrace();
    public static void main(String[] args) {
        try {
            Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
            conn = DriverManager.getConnection("jdbc:oracle:thin:@XXX.XXX.XXX.XXX:1521:XXX", "XXX", "XXX");
            System.out.println("Connected to DB");
            conn.setAutoCommit(true);
            for(int x=1;x<=2000;x++){
                if(x%100==0){
                   System.out.println("Count is "+x);
                if(x%2==0){
                    usePrep();
                }else
                    useStatement();
            System.out.println("Prepcount " + Prepcount + " Prepavarage " + Prepavarage + " CurrentExecution " +(PrependTime - PrepstartTime)+ " Totaltime "+PreptotalTime);
            System.out.println("Stmtcount " + Stmtcount + " Stmtavarage " + Stmtavarage+ " CurrentExecution " +(StmtendTime - StmtstartTime)+ " Totaltime "+StmttotalTime);
            System.err.println("Statement time - Prep Time " + (StmttotalTime - PreptotalTime ));
        } catch (Exception ex) {
            ex.printStackTrace();
            System.exit(0);
}

Answer 1

sjasja wrote:
There can still be a performance advantage to PS's even when not used in a loop. Oracle in particular has a textual statement cache. When you execute
insert into foo values(1);
insert into foo values(2);
insert into foo values(3);
the three statements are textually different, so they get re-parsed and the query optimizer runs thrice. But when you prepare
insert into foo values(?);
the parsed and optimized statement remains in the statement cache for some time, and each execution with a different value for "?" can use the pre-parsed statement. The more complex the statement, the bigger the advantage.Yes they do, and so do many others. But it is only that, a cache. It will "usually" be available, not necessarily always. But, in any case, it is still best practice to prepare it, use it multiple times, and close it.
>
I have heard rumors of databases (MSSQL???) where a PS is indeed costlier, as the protocol between the JDBC driver and the DB server requires a separate compilation step. One could argue that in this world, where Java is so important in the server side, and the other advantages of PreparedStatement favor its use, any serious database has had much reason in the last decade to implement a protocol where a separate compilation step is not needed, and any other speed penalties for PSs are decidedly not a marketing advantage.One could argue that, and many have, but PreparedStatements did not spring into being with JDBC, they have existed previously. They are easier to use, however, in Java, and some sort or precompilation is required (even if it is only done the first time the statement is actually run) because at some point in time the DB must determine the paths to take when actually executing the statement, and that was the purpose behind precompiled statements in the first place, so that that determination is done once, and used multiple times. Otherwise it is done as the statement is executed, each time a statement is executed (unless, at least in Oracle, the same statement is still in the statement cache, then it is also reused, rather than redetermined).