~ubuntu-branches/ubuntu/gutsy/libpgjava/gutsy

package example;

 

import java.io.*;

import java.sql.*;

import java.text.*;

 

// rare in user code, but we use the LargeObject API in this test

import org.postgresql.largeobject.*;

 

/*

 * This example tests the thread safety of the driver.

 *

 * It does this by performing several queries, in different threads. Each

 * thread has it's own Statement object, which is (in my understanding of the

 * jdbc specification) the minimum requirement.

 *

 */

 

public class threadsafe

{

        Connection db;  // The connection to the database

        Statement st;   // Our statement to run queries with

 

        public threadsafe(String args[]) throws ClassNotFoundException, FileNotFoundException, IOException, SQLException

        {

                String url = args[0];

                String usr = args[1];

                String pwd = args[2];

 

                // Load the driver

                Class.forName("org.postgresql.Driver");

 

                // Connect to database

                System.out.println("Connecting to Database URL = " + url);

                db = DriverManager.getConnection(url, usr, pwd);

 

                System.out.println("Connected...Now creating a statement");

                st = db.createStatement();

 

                // Clean up the database (in case we failed earlier) then initialise

                cleanup();

 

                // Because we use LargeObjects, we must use Transactions

                db.setAutoCommit(false);

 

                // Now run tests using JDBC methods, then LargeObjects

                doexample();

 

                // Clean up the database

                cleanup();

 

                // Finally close the database

                System.out.println("Now closing the connection");

                st.close();

                db.close();

        }

 

        /*

         * This drops the table (if it existed). No errors are reported.

         */

        public void cleanup()

        {

                try

                {

                        st.executeUpdate("drop table basic1");

                }

                catch (Exception ex)

                {

                        // We ignore any errors here

                }

 

                try

                {

                        st.executeUpdate("drop table basic2");

                }

                catch (Exception ex)

                {

                        // We ignore any errors here

                }

        }

 

        /*

         * This performs the example

         */

        public void doexample() throws SQLException

        {

                System.out.println("\nThis test runs three Threads. Two simply insert data into a table, then\nthey perform a query. While they are running, a third thread is running,\nand it load data into, then reads from a Large Object.\n\nIf alls well, this should run without any errors. If so, we are Thread Safe.\nWhy test JDBC & LargeObject's? Because both will run over the network\nconnection, and if locking on the stream isn't done correctly, the backend\nwill get pretty confused!\n");

 

                thread3 thread3 = null;

 

                try

                {

 

                        // create the two threads

                        Thread thread0 = Thread.currentThread();

                        Thread thread1 = new thread1(db);

                        Thread thread2 = new thread2(db);

                        thread3 = new thread3(db);

 

                        // now run, and wait for them

                        thread1.start();

                        thread2.start();

                        thread3.start();

 

                        // ok, I know this is bad, but it does the trick here as our main thread

                        // will yield as long as either of the children are still running

                        System.out.println("Waiting for threads to run");

                        while (thread1.isAlive() || thread2.isAlive() || thread3.isAlive())

                                thread0.yield();

                }

                finally

                {

                        // clean up after thread3 (the finally ensures this is run even

                        // if an exception is thrown inside the try { } construct)

                        if (thread3 != null)

                                thread3.cleanup();

                }

 

                System.out.println("No Exceptions have been thrown. This is a good omen, as it means that we are\npretty much thread safe as we can get.");

        }

 

        // This is the first thread. It's the same as the basic test

        class thread1 extends Thread

        {

                Connection c;

                Statement st;

 

                public thread1(Connection c) throws SQLException

                {

                        this.c = c;

                        st = c.createStatement();

                }

 

                public void run()

                {

                        try

                        {

                                System.out.println("Thread 1 running...");

 

                                // First we need a table to store data in

                                st.executeUpdate("create table basic1 (a int2, b int2)");

 

                                // Now insert some data, using the Statement

                                st.executeUpdate("insert into basic1 values (1,1)");

                                st.executeUpdate("insert into basic1 values (2,1)");

                                st.executeUpdate("insert into basic1 values (3,1)");

 

                                // For large inserts, a PreparedStatement is more efficient, because it

                                // supports the idea of precompiling the SQL statement, and to store

                                // directly, a Java object into any column. PostgreSQL doesnt support

                                // precompiling, but does support setting a column to the value of a

                                // Java object (like Date, String, etc).

                                //

                                // Also, this is the only way of writing dates in a datestyle independent

                                // manner. (DateStyles are PostgreSQL's way of handling different methods

                                // of representing dates in the Date data type.)

                                PreparedStatement ps = db.prepareStatement("insert into basic1 values (?,?)");

                                for (int i = 2;i < 2000;i++)

                                {

                                        ps.setInt(1, 4);                // "column a" = 5

                                        ps.setInt(2, i);                // "column b" = i

                                        ps.executeUpdate(); // executeUpdate because insert returns no data

                                        //        c.commit();

                                        if ((i % 50) == 0)

                                                DriverManager.println("Thread 1 done " + i + " inserts");

                                }

                                ps.close();                     // Always close when we are done with it

 

                                // Finally perform a query on the table

                                DriverManager.println("Thread 1 performing a query");

                                ResultSet rs = st.executeQuery("select a, b from basic1");

                                int cnt = 0;

                                if (rs != null)

                                {

                                        // Now we run through the result set, printing out the result.

                                        // Note, we must call .next() before attempting to read any results

                                        while (rs.next())

                                        {

                                                int a = rs.getInt("a"); // This shows how to get the value by name

                                                int b = rs.getInt(2);   // This shows how to get the value by column

                                                //System.out.println("  a="+a+" b="+b);

                                                cnt++;

                                        }

                                        rs.close(); // again, you must close the result when done

                                }

                                DriverManager.println("Thread 1 read " + cnt + " rows");

 

                                // The last thing to do is to drop the table. This is done in the

                                // cleanup() method.

                                System.out.println("Thread 1 finished");

                        }

                        catch (SQLException se)

                        {

                                System.err.println("Thread 1: " + se.toString());

                                se.printStackTrace();

                                System.exit(1);

                        }

                }

        }

 

        // This is the second thread. It's the similar to the basic test, and thread1

        // except it works on another table.

        class thread2 extends Thread

        {

                Connection c;

                Statement st;

 

                public thread2(Connection c) throws SQLException

                {

                        this.c = c;

                        st = c.createStatement();

                }

 

                public void run()

                {

                        try

                        {

                                System.out.println("Thread 2 running...");

 

                                // First we need a table to store data in

                                st.executeUpdate("create table basic2 (a int2, b int2)");

 

                                // For large inserts, a PreparedStatement is more efficient, because it

                                // supports the idea of precompiling the SQL statement, and to store

                                // directly, a Java object into any column. PostgreSQL doesnt support

                                // precompiling, but does support setting a column to the value of a

                                // Java object (like Date, String, etc).

                                //

                                // Also, this is the only way of writing dates in a datestyle independent

                                // manner. (DateStyles are PostgreSQL's way of handling different methods

                                // of representing dates in the Date data type.)

                                PreparedStatement ps = db.prepareStatement("insert into basic2 values (?,?)");

                                for (int i = 2;i < 2000;i++)

                                {

                                        ps.setInt(1, 4);                // "column a" = 5

                                        ps.setInt(2, i);                // "column b" = i

                                        ps.executeUpdate(); // executeUpdate because insert returns no data

                                        //        c.commit();

                                        if ((i % 50) == 0)

                                                DriverManager.println("Thread 2 done " + i + " inserts");

                                }

                                ps.close();                     // Always close when we are done with it

 

                                // Finally perform a query on the table

                                DriverManager.println("Thread 2 performing a query");

                                ResultSet rs = st.executeQuery("select * from basic2 where b>1");

                                int cnt = 0;

                                if (rs != null)

                                {

                                        // First find out the column numbers.

                                        //

                                        // It's best to do this here, as calling the methods with the column

                                        // numbers actually performs this call each time they are called. This

                                        // really speeds things up on large queries.

                                        //

                                        int col_a = rs.findColumn("a");

                                        int col_b = rs.findColumn("b");

 

                                        // Now we run through the result set, printing out the result.

                                        // Again, we must call .next() before attempting to read any results

                                        while (rs.next())

                                        {

                                                int a = rs.getInt(col_a); // This shows how to get the value by name

                                                int b = rs.getInt(col_b); // This shows how to get the value by column

                                                //System.out.println("  a="+a+" b="+b);

                                                cnt++;

                                        }

                                        rs.close(); // again, you must close the result when done

                                }

                                DriverManager.println("Thread 2 read " + cnt + " rows");

 

                                // The last thing to do is to drop the table. This is done in the

                                // cleanup() method.

                                System.out.println("Thread 2 finished");

                        }

                        catch (SQLException se)

                        {

                                System.err.println("Thread 2: " + se.toString());

                                se.printStackTrace();

                                System.exit(1);

                        }

                }

        }

 

        // This is the third thread. It loads, then reads from a LargeObject, using

        // our LargeObject api.

        //

        // The purpose of this is to test that FastPath will work in between normal

        // JDBC queries.

        class thread3 extends Thread

        {

                Connection c;

                Statement st;

                LargeObjectManager lom;

                LargeObject lo;

                int oid;

 

                public thread3(Connection c) throws SQLException

                {

                        this.c = c;

                        //st = c.createStatement();

 

                        // create a blob

                        lom = ((org.postgresql.Connection)c).getLargeObjectAPI();

                        oid = lom.create();

                        System.out.println("Thread 3 has created a blob of oid " + oid);

                }

 

                public void run()

                {

                        try

                        {

                                System.out.println("Thread 3 running...");

 

                                DriverManager.println("Thread 3: Loading data into blob " + oid);

                                lo = lom.open(oid);

                                FileInputStream fis = new FileInputStream("example/threadsafe.java");

                                // keep the buffer size small, to allow the other thread a chance

                                byte buf[] = new byte[128];

                                int rc, bc = 1, bs = 0;

                                while ((rc = fis.read(buf)) > 0)

                                {

                                        DriverManager.println("Thread 3 read block " + bc + " " + bs + " bytes");

                                        lo.write(buf, 0, rc);

                                        bc++;

                                        bs += rc;

                                }

                                lo.close();

                                fis.close();

 

                                DriverManager.println("Thread 3: Reading blob " + oid);

                                lo = lom.open(oid);

                                bc = 0;

                                while (buf.length > 0)

                                {

                                        buf = lo.read(buf.length);

                                        if (buf.length > 0)

                                        {

                                                String s = new String(buf);

                                                bc++;

                                                DriverManager.println("Thread 3 block " + bc);

                                                DriverManager.println("Block " + bc + " got " + s);

                                        }

                                }

                                lo.close();

 

                                System.out.println("Thread 3 finished");

                        }

                        catch (Exception se)

                        {

                                System.err.println("Thread 3: " + se.toString());

                                se.printStackTrace();

                                System.exit(1);

                        }

                }

 

                public void cleanup() throws SQLException

                {

                        if (lom != null && oid != 0)

                        {

                                System.out.println("Thread 3: Removing blob oid=" + oid);

                                lom.delete(oid);

                        }

                }

        }

 

        /*

         * Display some instructions on how to run the example

         */

        public static void instructions()

        {

                System.out.println("\nThis tests the thread safety of the driver.\n\nThis is done in two parts, the first with standard JDBC calls, and the\nsecond mixing FastPath and LargeObject calls with queries.\n");

                System.out.println("Useage:\n java example.threadsafe jdbc:postgresql:database user password [debug]\n\nThe debug field can be anything. It's presence will enable DriverManager's\ndebug trace. Unless you want to see screens of items, don't put anything in\nhere.");

                System.exit(1);

        }

 

        /*

         * This little lot starts the test

         */

        public static void main(String args[])

        {

                System.out.println("PostgreSQL Thread Safety test v6.4 rev 1\n");

 

                if (args.length < 3)

                        instructions();

 

                // This line outputs debug information to stderr. To enable this, simply

                // add an extra parameter to the command line

                if (args.length > 3)

                        DriverManager.setLogStream(System.err);

 

                // Now run the tests

                try

                {

                        threadsafe test = new threadsafe(args);

                }

                catch (Exception ex)

                {

                        System.err.println("Exception caught.\n" + ex);

                        ex.printStackTrace();

                }

        }

}