Tue Jan 30 22:24:00 GMT 2001 peter@retep.org.uk

        - Fixed bug where Statement.setMaxRows() was a global setting. Now
          limited to just itself.
        - Changed LargeObject.read(byte[],int,int) to return the actual number
          of bytes read (used to be void).
        - LargeObject now supports InputStream's!
        - PreparedStatement.setBinaryStream() now works!
        - ResultSet.getBinaryStream() now returns an InputStream that doesn't
          copy the blob into memory first!
        - Connection.isClosed() now tests to see if the connection is still alive
          rather than if it thinks it's alive.

Author: Peter Mount

src/interfaces/jdbc/CHANGELOG

@@ -1,3 +1,14 @@
+Tue Jan 30 22:24:00 GMT 2001 peter@retep.org.uk
+        - Fixed bug where Statement.setMaxRows() was a global setting. Now
+          limited to just itself.
+        - Changed LargeObject.read(byte[],int,int) to return the actual number
+          of bytes read (used to be void).
+        - LargeObject now supports InputStream's!
+        - PreparedStatement.setBinaryStream() now works!
+        - ResultSet.getBinaryStream() now returns an InputStream that doesn't
+          copy the blob into memory first!
+        - Connection.isClosed() now tests to see if the connection is still alive
+          rather than if it thinks it's alive.
 Thu Jan 25 09:11:00 GMT 2001 peter@retep.org.uk
         - Added an alternative constructor to PGSQLException so that debugging
           some more osteric bugs is easier. If only 1 arg is supplied and it's

src/interfaces/jdbc/example/basic.java

@@ -6,7 +6,7 @@
 
 /**
  *
- * $Id: basic.java,v 1.5 2000/06/06 11:05:57 peter Exp $
+ * $Id: basic.java,v 1.6 2001/01/31 08:26:01 peter Exp $
  *
  * This example tests the basic components of the JDBC driver, and shows
  * how even the simplest of queries can be implemented.
@@ -22,40 +22,40 @@ public class basic
 {
   Connection db;	// The connection to the database
   Statement  st;	// Our statement to run queries with
-  
+
   public basic(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();
-    
+
     // Now run tests using JDBC methods
     doexample();
-    
+
     // Clean up the database
     cleanup();
-    
+
     // Finally close the database
     System.out.println("Now closing the connection");
     st.close();
     db.close();
-    
+
     //throw postgresql.Driver.notImplemented();
   }
-  
+
   /**
    * This drops the table (if it existed). No errors are reported.
    */
@@ -67,35 +67,36 @@ public void cleanup()
       // We ignore any errors here
     }
   }
-  
+
   /**
    * This performs the example
    */
   public void doexample() throws SQLException
   {
     System.out.println("\nRunning tests:");
-    
+
     // First we need a table to store data in
     st.executeUpdate("create table basic (a int2, b int2)");
-    
+
     // Now insert some data, using the Statement
     st.executeUpdate("insert into basic values (1,1)");
     st.executeUpdate("insert into basic values (2,1)");
     st.executeUpdate("insert into basic values (3,1)");
-    
+
     // This shows how to get the oid of a just inserted row
+    // updated for 7.1
     st.executeUpdate("insert into basic values (4,1)");
-    int insertedOID = ((org.postgresql.ResultSet)st.getResultSet()).getInsertedOID();
+    int insertedOID = ((org.postgresql.jdbc2.Statement)st).getInsertedOID();
     System.out.println("Inserted row with oid "+insertedOID);
-    
+
     // Now change the value of b from 1 to 8
     st.executeUpdate("update basic set b=8");
     System.out.println("Updated "+st.getUpdateCount()+" rows");
-    
+
     // Now delete 2 rows
     st.executeUpdate("delete from basic where a<3");
     System.out.println("deleted "+st.getUpdateCount()+" rows");
-    
+
     // 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
@@ -112,7 +113,7 @@ public void doexample() throws SQLException
       ps.executeUpdate();	// executeUpdate because insert returns no data
     }
     ps.close();			// Always close when we are done with it
-    
+
     // Finally perform a query on the table
     System.out.println("performing a query");
     ResultSet rs = st.executeQuery("select a, b from basic");
@@ -126,7 +127,7 @@ public void doexample() throws SQLException
       }
       rs.close();	// again, you must close the result when done
     }
-    
+
     // Now run the query again, showing a more efficient way of getting the
     // result if you don't know what column number a value is in
     System.out.println("performing another query");
@@ -140,7 +141,7 @@ public void doexample() throws SQLException
       //
       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()) {
@@ -150,11 +151,22 @@ public void doexample() throws SQLException
       }
       rs.close();	// again, you must close the result when done
     }
-    
+
+    // Now test maxrows by setting it to 3 rows
+    st.setMaxRows(3);
+    System.out.println("performing a query limited to "+st.getMaxRows());
+    rs = st.executeQuery("select a, b from basic");
+    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);
+    }
+    rs.close();	// again, you must close the result when done
+
     // The last thing to do is to drop the table. This is done in the
     // cleanup() method.
   }
-  
+
   /**
    * Display some instructions on how to run the example
    */
@@ -164,22 +176,22 @@ public static void instructions()
     System.out.println("Useage:\n java example.basic 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 basic test v6.3 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 {
       basic test = new basic(args);

src/interfaces/jdbc/jdbc.jpx

@@ -9,7 +9,7 @@
   <property category="sys" name="CheckStable" value="1" />
   <property category="sys" name="Company" value="" />
   <property category="sys" name="Copyright" value="Copyright (c) 2001" />
-  <property category="sys" name="DefaultPackage" value="org.postgresql.core" />
+  <property category="sys" name="DefaultPackage" value="org.postgresql.largeobject" />
   <property category="sys" name="Description" value="" />
   <property category="sys" name="DocPath" value="doc" />
   <property category="sys" name="ExcludeClassEnabled" value="0" />

src/interfaces/jdbc/org/postgresql/Connection.java

@@ -10,7 +10,7 @@
 import org.postgresql.util.*;
 
 /**
- * $Id: Connection.java,v 1.13 2001/01/18 17:37:12 peter Exp $
+ * $Id: Connection.java,v 1.14 2001/01/31 08:26:01 peter Exp $
  *
  * This abstract class is used by org.postgresql.Driver to open either the JDBC1 or
  * JDBC2 versions of the Connection class.
@@ -22,7 +22,7 @@ public abstract class Connection
   public PG_Stream pg_stream;
 
   // This is set by org.postgresql.Statement.setMaxRows()
-  public int maxrows = 0;		// maximum no. of rows; 0 = unlimited
+  //public int maxrows = 0;		// maximum no. of rows; 0 = unlimited
 
   private String PG_HOST;
   private int PG_PORT;
@@ -414,6 +414,11 @@ public java.sql.ResultSet ExecSQL(String sql) throws SQLException
      */
     public java.sql.ResultSet ExecSQL(String sql,java.sql.Statement stat) throws SQLException
     {
+      // added Jan 30 2001 to correct maxrows per statement
+      int maxrows=0;
+      if(stat!=null)
+        maxrows=stat.getMaxRows();
+
 	// added Oct 7 1998 to give us thread safety.
 	synchronized(pg_stream) {
  	    // Deallocate all resources in the stream associated

src/interfaces/jdbc/org/postgresql/jdbc1/Statement.java

@@ -29,6 +29,7 @@ public class Statement implements java.sql.Statement
     SQLWarning warnings = null;	// The warnings chain.
     int timeout = 0;		// The timeout for a query (not used)
     boolean escapeProcessing = true;// escape processing flag
+    int maxrows=0;
 
 	/**
 	 * Constructor for a Statement.  It simply sets the connection
@@ -129,7 +130,7 @@ public void setMaxFieldSize(int max) throws SQLException
 	 */
 	public int getMaxRows() throws SQLException
 	{
-		return connection.maxrows;
+		return maxrows;
 	}
 
 	/**
@@ -141,7 +142,7 @@ public int getMaxRows() throws SQLException
 	 */
 	public void setMaxRows(int max) throws SQLException
 	{
-	  connection.maxrows = max;
+	  maxrows = max;
 	}
 
 	/**

src/interfaces/jdbc/org/postgresql/jdbc2/Connection.java

@@ -17,7 +17,7 @@
 import org.postgresql.util.*;
 
 /**
- * $Id: Connection.java,v 1.5 2001/01/18 17:37:14 peter Exp $
+ * $Id: Connection.java,v 1.6 2001/01/31 08:26:02 peter Exp $
  *
  * A Connection represents a session with a specific database.  Within the
  * context of a Connection, SQL statements are executed and results are
@@ -265,7 +265,27 @@ public void close() throws SQLException
    */
   public boolean isClosed() throws SQLException
   {
-    return (pg_stream == null);
+    // If the stream is gone, then close() was called
+    if(pg_stream == null)
+      return true;
+
+    // ok, test the connection
+    try {
+      // by sending an empty query. If we are dead, then an SQLException should
+      // be thrown
+      java.sql.ResultSet rs = ExecSQL(" ");
+      if(rs!=null)
+        rs.close();
+
+      // By now, we must be alive
+      return false;
+    } catch(SQLException se) {
+      // Why throw an SQLException as this may fail without throwing one,
+      // ie isClosed() is called incase the connection has died, and we don't
+      // want to find out by an Exception, so instead we return true, as its
+      // most likely why it was thrown in the first place.
+      return true;
+    }
   }
 
   /**