Re: streaming result sets: progress - Mailing list pgsql-jdbc

This is the patch which should fix the meta data problem. It makes
the use of nic_execute (ie: the cursor based fetch) dependant on the
setting of fetch size.


I have come to the view that this has been a bit of a waste of
time. I don't think it's reasonable to put this into a release
because the block based querys will always be interfering with other
statements.

Basically, unless everything goes cursor based (not very promising
idea) or it's possible to declare a cursor in postgresql's default,
non-transactional mode (more promising idea, maybe it would be
possible to alter the backend to allow that?) I think this is a
non-starter.


It has been valuable in as much as I've had a good look at how it
might be possible to rip out some of the duplicate query execution
stuff. I believe the query execution stuff expressed by my patch is
now pretty good.


The other interesting thing is that a PGRefCursorResultSet (as
dreamed up by Barry) would be able to deal row selection, so one
could always call a proc if one wanted a batch return.



Anyway, here's the patch.


Nic


Index: org/postgresql/PGConnection.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/PGConnection.java,v
retrieving revision 1.3
diff -r1.3 PGConnection.java
79a80,89
>
>
>     // Added by Nic.
>
>     /** Create a result set for the specified statement.
>      * This is the factory method provided by the various
>      * version specific implementations of the JDBC connection
>      * classes.
>      */
>     public java.sql.ResultSet createResultSet (java.sql.Statement statement);
cvs server: Diffing org/postgresql/core
Index: org/postgresql/core/QueryExecutor.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/core/QueryExecutor.java,v
retrieving revision 1.16.2.1
diff -r1.16.2.1 QueryExecutor.java
20a21,69
>     /** nic version - statically sets up the QE correctly.
>      */
>     public static void execute (String[] p_sqlFrags,
>                     Object[] p_binds,
>                     java.sql.Statement statement,
>                     java.sql.ResultSet rs,
>                     PG_Stream pg_stream,
>                     java.sql.Connection con)
>     throws SQLException
>     {
>         QueryExecutor qe = new QueryExecutor();
>         // I think this should be a PGConnection and we should move
>         // everything we need for that from AbstractJdbc1... into PGConnection.
>         qe.connection = (org.postgresql.jdbc1.AbstractJdbc1Connection)con;
>         qe.m_sqlFrags = p_sqlFrags;
>         qe.m_binds = p_binds;
>         qe.statement = statement;
>         // Nic says: connection should wrap pg_stream.
>         qe.pg_stream = pg_stream;
>         if (statement != null)
>             qe.maxRows = statement.getMaxRows();
>         else
>             qe.maxRows = 0;
>         // The result set.
>         qe.rs = rs;
>         qe.execute();
>     }
>
>     // This is the result set used to wrap the results.
>     // The type of this is whatever is passed into the static above.
>     private java.sql.ResultSet rs;
>
>     // cons for the static above.
>     private QueryExecutor ()
>     {
>     }
>
>
>
>
>     /*** pre-nic implementation   ***/
>
>
>     /// Nic has removed the final from ALL of these (to facilitate static method).
>     private String[] m_sqlFrags;
>     private Object[] m_binds;
>     private java.sql.Statement statement;
>     private PG_Stream pg_stream;
>     private org.postgresql.jdbc1.AbstractJdbc1Connection connection;
22,26d70
<     private final String[] m_sqlFrags;
<     private final Object[] m_binds;
<     private final java.sql.Statement statement;
<     private final PG_Stream pg_stream;
<     private final org.postgresql.jdbc1.AbstractJdbc1Connection connection;
36c80
<         this.statement = statement;
---
>         this.statement = statement;
45a90
>
53a99
>
55a102
>      *
133c180,185
<             return connection.getResultSet(statement, fields, tuples, status, update_count, insert_oid,
binaryCursor);
---
>
>             // Nic changes.
>             PGResultSet resSet = ((PGResultSet)rs);
>             //  System.out.println(getClass().getName() + " resSet=" + resSet);
>             resSet.init(fields, tuples, status, update_count, insert_oid, binaryCursor);
>             return rs;
Index: org/postgresql/jdbc1/AbstractJdbc1Connection.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1Connection.java,v
retrieving revision 1.12.2.1
diff -r1.12.2.1 AbstractJdbc1Connection.java
353,354d352
<         java.sql.ResultSet resultSet =
<             ExecSQL("set datestyle to 'ISO'; select version(), " + encodingQuery + ";");
355a354,356
>         java.sql.ResultSet resultSet
>             = doQuery("set datestyle to 'ISO'; select version(), " + encodingQuery + ";");
>
376c377
<                 ExecSQL("set client_encoding = 'UNICODE'; show autocommit");
---
>                 doQuery("set client_encoding = 'UNICODE'; show autocommit");
391c392
<                 ExecSQL("set autocommit = on; commit;");
---
>                 doQuery("set autocommit = on; commit;");
412,418d412
<     // These methods used to be in the main Connection implementation. As they
<     // are common to all implementations (JDBC1 or 2), they are placed here.
<     // This should make it easy to maintain the two specifications.
<
<     public abstract java.sql.ResultSet getResultSet(Statement statement, org.postgresql.Field[] fields, Vector
tuples,String status, int updateCount, long insertOID, boolean binaryCursor) throws SQLException; 
<
<     public abstract java.sql.ResultSet getResultSet(Statement statement, org.postgresql.Field[] fields, Vector
tuples,String status, int updateCount) throws SQLException; 
448,457c442
<     /*
<      * Send a query to the backend.  Returns one of the ResultSet
<      * objects.
<      *
<      * <B>Note:</B> there does not seem to be any method currently
<      * in existance to return the update count.
<      *
<      * @param sql the SQL statement to be executed
<      * @return a ResultSet holding the results
<      * @exception SQLException if a database error occurs
---
>     /** Simple query execution.
459c444
<     public java.sql.ResultSet ExecSQL(String sql) throws SQLException
---
>     public java.sql.ResultSet doQuery (String s) throws SQLException
461c446,450
<         return ExecSQL(sql, null);
---
>         final Object[] nullarr = new Object[0];
>         java.sql.Statement stat = createStatement();
>         java.sql.ResultSet rs = createResultSet(stat);
>         execSQL(new String[] { s }, nullarr, stat, rs);
>         return rs;
464,491c453
<     /*
<      * Send a query to the backend.  Returns one of the ResultSet
<      * objects.
<      *
<      * <B>Note:</B> there does not seem to be any method currently
<      * in existance to return the update count.
<      *
<      * @param sql the SQL statement to be executed
<      * @param stat The Statement associated with this query (may be null)
<      * @return a ResultSet holding the results
<      * @exception SQLException if a database error occurs
<      */
<     public java.sql.ResultSet ExecSQL(String sql, java.sql.Statement stat) throws SQLException
<     {
<         if (isClosed())
<         {
<             throw new PSQLException("postgresql.con.closed");
<         }
<         return new QueryExecutor(new String[] {sql}, EMPTY_OBJECT_ARRAY, stat, pg_stream,
(java.sql.Connection)this).execute();
<     }
<     private static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
<
<     /*
<      * Send a query to the backend.  Returns one of the ResultSet
<      * objects.
<      *
<      * <B>Note:</B> there does not seem to be any method currently
<      * in existance to return the update count.
---
>     /** Advanced query execution.
495,496c457,458
<      * @param stat The Statement associated with this query (may be null)
<      * @return a ResultSet holding the results
---
>      * @param stat the statement associated with this query.
>      * @param rs the ResultSet which will be initied for the results.
499,505c461,472
<     public java.sql.ResultSet ExecSQL(String[] p_sqlFragments, Object[] p_binds, java.sql.Statement stat) throws
SQLException
<     {
<         if (isClosed())
<         {
<             throw new PSQLException("postgresql.con.closed");
<         }
<         return new QueryExecutor(p_sqlFragments, p_binds, stat, pg_stream, (java.sql.Connection)this).execute();
---
>     public void execSQL(String[] p_sqlFragments,
>                 Object[] p_binds,
>                 java.sql.Statement stat,
>                 java.sql.ResultSet rs)
>         throws SQLException
>     {
>         QueryExecutor.execute(p_sqlFragments,
>                       p_binds,
>                       stat,
>                       rs,
>                       pg_stream,
>                       (java.sql.Connection)this);
507a475
>
942c910
<                 ExecSQL("select 1; commit; set autocommit = on;");
---
>                 doQuery("select 1; commit; set autocommit = on;");
946c914
<                 ExecSQL("end");
---
>                 doQuery("end");
953c921
<                 ExecSQL("set autocommit = off; " + getIsolationLevelSQL());
---
>                 doQuery("set autocommit = off; " + getIsolationLevelSQL());
957c925
<                 ExecSQL("begin;" + getIsolationLevelSQL());
---
>                 doQuery("begin;" + getIsolationLevelSQL());
961,962c929,930
<                 ExecSQL("begin");
<                 ExecSQL(getIsolationLevelSQL());
---
>                 doQuery("begin");
>                 doQuery(getIsolationLevelSQL());
996c964
<             ExecSQL("commit; " + getIsolationLevelSQL());
---
>             doQuery("commit; " + getIsolationLevelSQL());
1000c968
<             ExecSQL("commit;begin;" + getIsolationLevelSQL());
---
>             doQuery("commit;begin;" + getIsolationLevelSQL());
1004,1006c972,974
<             ExecSQL("commit");
<             ExecSQL("begin");
<             ExecSQL(getIsolationLevelSQL());
---
>             doQuery("commit");
>             doQuery("begin");
>             doQuery(getIsolationLevelSQL());
1027c995
<             ExecSQL("rollback; " + getIsolationLevelSQL());
---
>             doQuery("rollback; " + getIsolationLevelSQL());
1031c999
<             ExecSQL("rollback; begin;" + getIsolationLevelSQL());
---
>             doQuery("rollback; begin;" + getIsolationLevelSQL());
1035,1037c1003,1005
<             ExecSQL("rollback");
<             ExecSQL("begin");
<             ExecSQL(getIsolationLevelSQL());
---
>             doQuery("rollback");
>             doQuery("begin");
>             doQuery(getIsolationLevelSQL());
1052c1020
<             ResultSet rs = ExecSQL(sql);
---
>             ResultSet rs = doQuery(sql);
1059c1027
<             ExecSQL(sql);
---
>             doQuery(sql);
1124c1092
<         ExecSQL(isolationLevelSQL);
---
>         doQuery(isolationLevelSQL);
1267c1235
<                 ResultSet result = ExecSQL(sql);
---
>                 ResultSet result = doQuery(sql);
1308c1276
<                 ResultSet result = ExecSQL(sql);
---
>                 ResultSet result = doQuery(sql);
Index: org/postgresql/jdbc1/AbstractJdbc1DatabaseMetaData.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1DatabaseMetaData.java,v
retrieving revision 1.10.2.1
diff -r1.10.2.1 AbstractJdbc1DatabaseMetaData.java
1916c1916,1918
<         return connection.getResultSet(null, f, v, "OK", 1);
---
>         java.sql.ResultSet retRs = connection.createResultSet(connection.createStatement());
>         ((AbstractJdbc1ResultSet)retRs).init(f, v, "OK", 1, 0, false);
>         return retRs;
2202c2204,2207
<         return connection.getResultSet(null, f, v, "OK", 1);
---
>
>         java.sql.ResultSet retRs = connection.createResultSet(connection.createStatement());
>         ((AbstractJdbc1ResultSet)retRs).init(f, v, "OK", 1, 0, false);
>         return retRs;
2369c2374,2376
<         return connection.getResultSet(null, f, v, "OK", 1);
---
>         java.sql.ResultSet retRs = connection.createResultSet(connection.createStatement());
>         ((AbstractJdbc1ResultSet)retRs).init(f, v, "OK", 1, 0, false);
>         return retRs;
2481c2488,2491
<         return connection.getResultSet(null, f, v, "OK", 1);
---
>
>         java.sql.ResultSet retRs = connection.createResultSet(connection.createStatement());
>         ((AbstractJdbc1ResultSet)retRs).init(f, v, "OK", 1, 0, false);
>         return retRs;
2583c2593,2595
<         return connection.getResultSet(null, f, v, "OK", 1);
---
>         java.sql.ResultSet retRs = connection.createResultSet(connection.createStatement());
>         ((AbstractJdbc1ResultSet)retRs).init(f, v, "OK", 1, 0, false);
>         return retRs;
2776c2788,2791
<         return connection.getResultSet(null, f, v, "OK", 1);
---
>
>         java.sql.ResultSet retRs = connection.createResultSet(connection.createStatement());
>         ((AbstractJdbc1ResultSet)retRs).init(f, v, "OK", 1, 0, false);
>         return retRs;
2846c2861,2863
<         return connection.getResultSet(null, f, v, "OK", 1);
---
>         java.sql.ResultSet retRs = connection.createResultSet(connection.createStatement());
>         ((AbstractJdbc1ResultSet)retRs).init(f, v, "OK", 1, 0, false);
>         return retRs;
3196c3213,3215
<         return connection.getResultSet(null, f, tuples, "OK", 1);
---
>         java.sql.ResultSet retRs = connection.createResultSet(connection.createStatement());
>         ((AbstractJdbc1ResultSet)retRs).init(f, tuples, "OK", 1, 0, false);
>         return retRs;
3481c3500,3503
<         return connection.getResultSet(null, f, v, "OK", 1);
---
>
>         java.sql.ResultSet retRs = connection.createResultSet(connection.createStatement());
>         ((AbstractJdbc1ResultSet)retRs).init(f, v, "OK", 1, 0, false);
>         return retRs;
Index: org/postgresql/jdbc1/AbstractJdbc1ResultSet.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1ResultSet.java,v
retrieving revision 1.7
diff -r1.7 AbstractJdbc1ResultSet.java
21c21
< public abstract class AbstractJdbc1ResultSet
---
> public abstract class AbstractJdbc1ResultSet implements org.postgresql.PGResultSet
45c45,51
<     public AbstractJdbc1ResultSet(org.postgresql.PGConnection conn, Statement statement, Field[] fields, Vector
tuples,String status, int updateCount, long insertOID, boolean binaryCursor) 
---
>     public AbstractJdbc1ResultSet(org.postgresql.PGConnection conn,
>                       Statement statement,
>                       Field[] fields,
>                       Vector tuples,
>                       String status,
>                       int updateCount,
>                       long insertOID, boolean binaryCursor)
52a59,61
>
>         System.out.println(getClass().getName() + " updateCount = " + updateCount);
>
59a69,97
>     /*** nic constructor: called by superclass which is called from Jdbc1Connection.createResultSet ***/
>     public AbstractJdbc1ResultSet(org.postgresql.PGConnection conn,
>                       Statement statement)
>     {
>         this.connection = conn;
>         this.statement = statement;
>     }
>
>     /*** nic initializer. ***/
>     public void init (Field[] fields, Vector tuples, String status,
>               int updateCount, long insertOID, boolean binaryCursor)
>     {
>         this.fields = fields;
>
>         // on a reinit the size of this indicates how many we pulled
>         // back. If it's 0 then the res set has ended.
>         this.rows = tuples;
>         this.status = status;
>         this.updateCount = updateCount;
>         this.insertOID = insertOID;
>         this.this_row = null;
>         this.current_row = -1;
>         this.binaryCursor = binaryCursor;
>     }
>
>
>
>
>     // This slightly altered by nic.
66c104,125
<             return false;
---
>         {
>             int fetchSize = ((AbstractJdbc1Statement)statement).fetchSize;
>             // Must be false if we weren't batching.
>             if (fetchSize == 0)
>                 return false;
>             // Use the ref to the statement to get
>             // the details we need to do another cursor
>             // query - it will use reinit() to repopulate this
>             // with the right data.
>             String[] sql = new String[1];
>             String[] binds = new String[0];
>             // Is this the correct query???
>             String cursorName = ((AbstractJdbc1Statement)statement).m_statementName;
>             sql[0] = "FETCH FORWARD " + fetchSize + " FROM " + cursorName + " ;";
>             ((AbstractJdbc1Connection)connection).execSQL(sql, binds, statement, (java.sql.ResultSet)this);
>
>             // Test the new rows array.
>             if (rows.size() == 0)
>                 return false;
>             // Otherwise reset the counter and let it go on...
>             current_row = 0;
>         }
Index: org/postgresql/jdbc1/AbstractJdbc1Statement.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1Statement.java,v
retrieving revision 1.12.2.1
diff -r1.12.2.1 AbstractJdbc1Statement.java
27a28,30
>     /** Number of rows to get in a batch. */
>     protected int fetchSize = 0;
>
51c54
<     private String m_statementName = null;
---
>     protected String m_statementName = null;
120c123
<
---
>
136c139
<             ((AbstractJdbc1Connection)connection).ExecSQL("DEALLOCATE " + m_statementName);
---
>             ((AbstractJdbc1Connection)connection).doQuery("DEALLOCATE " + m_statementName);
153c156,159
<         this.execute();
---
>         if (fetchSize > 0)
>             this.nic_execute();
>         else
>             this.execute();
178c184
<             ((AbstractJdbc1Connection)connection).ExecSQL("DEALLOCATE " + m_statementName);
---
>             ((AbstractJdbc1Connection)connection).doQuery("DEALLOCATE " + m_statementName);
222c228
<             ((AbstractJdbc1Connection)connection).ExecSQL("DEALLOCATE " + m_statementName);
---
>             ((AbstractJdbc1Connection)connection).doQuery("DEALLOCATE " + m_statementName);
320c326,328
<         result = ((AbstractJdbc1Connection)connection).ExecSQL(m_sqlFragments, m_binds, (java.sql.Statement)this);
---
>         result = ((AbstractJdbc1Connection)connection).createResultSet((java.sql.Statement)this);
>         ((AbstractJdbc1Connection)connection).execSQL(m_sqlFragments, m_binds,
>                                   (java.sql.Statement)this, result);
343a352,455
>     /** version of execute which converts the query to a cursor.
>      */
>     public boolean nic_execute() throws SQLException
>     {
>         if (isFunction && !returnTypeSet)
>             throw new PSQLException("postgresql.call.noreturntype");
>         if (isFunction)
>         { // set entry 1 to dummy entry..
>             m_binds[0] = ""; // dummy entry which ensured that no one overrode
>             m_bindTypes[0] = PG_TEXT;
>             // and calls to setXXX (2,..) really went to first arg in a function call..
>         }
>
>         // New in 7.1, if we have a previous resultset then force it to close
>         // This brings us nearer to compliance, and helps memory management.
>         // Internal stuff will call ExecSQL directly, bypassing this.
>         if (result != null)
>         {
>             java.sql.ResultSet rs = getResultSet();
>             if (rs != null)
>                 rs.close();
>         }
>
>         // I've pretty much ignored server prepared statements... can declare and prepare be
>         // used together?
>         // It's trivial to change this: you just have to resolve this issue
>         // of how to work out whether there's a function call. If there isn't then the first
>         // element of the array must be the bit that you extend to become the cursor
>         // decleration.
>         // The last thing that can go wrong is when the user supplies a cursor statement
>         // directly: the translation takes no account of that. I think we should just look
>         // for declare and stop the translation if we find it.
>
>         // The first thing to do is transform the statement text into the cursor form.
>         String[] origSqlFragments = m_sqlFragments;
>         if (origSqlFragments.length > 1)
>             m_sqlFragments = new String[origSqlFragments.length + 1];
>         else
>             m_sqlFragments = new String[origSqlFragments.length];
>         System.arraycopy(origSqlFragments, 0, m_sqlFragments, 0, origSqlFragments.length);
>         // Pinch the prepared count for our own nefarious purposes.
>         m_statementName = "JDBC_CURS_" + m_preparedCount++;
>         // The static bit to prepend to all querys.
>         String cursDecl = "BEGIN; DECLARE " + m_statementName + " CURSOR FOR ";
>         String endCurs = " FETCH FORWARD " + fetchSize + " FROM " + m_statementName + ";";
>
>         // Add the real query to the curs decleration.
>         // This is the bit that really makes the presumption about
>         // m_sqlFragments not being a function call.
>         if (m_sqlFragments.length < 1)
>             m_sqlFragments[0] = cursDecl + "SELECT NULL;";
>
>         else if (m_sqlFragments.length < 2)
>         {
>             if (m_sqlFragments[0].endsWith(";"))
>                 m_sqlFragments[0] = cursDecl + m_sqlFragments[0] + endCurs;
>             else
>                 m_sqlFragments[0] = cursDecl + m_sqlFragments[0] + ";" + endCurs;
>         }
>         else
>         {
>             m_sqlFragments[0] = cursDecl + m_sqlFragments[0];
>             if (m_sqlFragments[m_sqlFragments.length - 2].endsWith(";"))
>                 m_sqlFragments[m_sqlFragments.length - 1] = endCurs;
>             else
>                 m_sqlFragments[m_sqlFragments.length - 1] = ";" + endCurs;
>         }
>
>         // Make the call to the query executor.
>         AbstractJdbc1Connection execr = (AbstractJdbc1Connection)connection;
>         java.sql.Statement st = (java.sql.Statement)this;
>         result = (java.sql.ResultSet) execr.createResultSet(st);
>         // Nic says:
>         // we don't need to collect the result here, rs is altered to
>         // be the result set so "result = rs" would do ok after this call.
>         execr.execSQL(m_sqlFragments, m_binds, st, result);
>
>         //If we are executing a callable statement function set the return data
>         if (isFunction)
>         {
>             if (!((AbstractJdbc1ResultSet)result).reallyResultSet())
>                 throw new PSQLException("postgresql.call.noreturnval");
>             if (!result.next ())
>                 throw new PSQLException ("postgresql.call.noreturnval");
>             callResult = result.getObject(1);
>             int columnType = result.getMetaData().getColumnType(1);
>             if (columnType != functionReturnType)
>             {
>                 Object[] arr =
>                     { "java.sql.Types=" + columnType,
>                       "java.sql.Types=" + functionReturnType
>                     };
>                 throw new PSQLException ("postgresql.call.wrongrtntype",arr);
>             }
>             result.close ();
>             return true;
>         }
>         else
>         {
>             return (result != null && ((AbstractJdbc1ResultSet)result).reallyResultSet());
>         }
>     }
>
>
596c708
<             ((AbstractJdbc1Connection)connection).ExecSQL("DEALLOCATE " + m_statementName);
---
>             ((AbstractJdbc1Connection)connection).doQuery("DEALLOCATE " + m_statementName);
1915c2027
<                 ((AbstractJdbc1Connection)connection).ExecSQL("DEALLOCATE " + m_statementName);
---
>                 ((AbstractJdbc1Connection)connection).doQuery("DEALLOCATE " + m_statementName);
Index: org/postgresql/jdbc1/Jdbc1Connection.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/jdbc1/Jdbc1Connection.java,v
retrieving revision 1.5
diff -r1.5 Jdbc1Connection.java
48a49,54
>
>     public java.sql.ResultSet createResultSet (java.sql.Statement stat) throws SQLException
>     {
>         // This needs doing.
>         return null;
>     }
cvs server: Diffing org/postgresql/jdbc2
Index: org/postgresql/jdbc2/AbstractJdbc2Connection.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/jdbc2/AbstractJdbc2Connection.java,v
retrieving revision 1.2
diff -r1.2 AbstractJdbc2Connection.java
8a9
>
20c21
<
---
>
Index: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/jdbc2/AbstractJdbc2ResultSet.java,v
retrieving revision 1.10
diff -r1.10 AbstractJdbc2ResultSet.java
40a41,45
>
>     AbstractJdbc2ResultSet (org.postgresql.PGConnection conn, Statement statement)
>     {
>         super(conn, statement);
>     }
144a150,157
>                 else if (type.equals("refcursor"))
>                 {
>                     // We must return a ResultSet with the results packaged.
>                         // We should probably check that auto commit is turned off.
>                         String cursorName = getString(columnIndex);
>                     // return new RefCursorResultSet(cursorName);
>                     return null;
>                 }
369,371c382
<         // In this implementation we return the entire result set, so
<         // here return the number of rows we have. Sub-classes can return a proper
<         // value
---
>         // Returning the current batch size seems the right thing to do.
757d767
<
790d799
<
Index: org/postgresql/jdbc2/AbstractJdbc2Statement.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/jdbc2/AbstractJdbc2Statement.java,v
retrieving revision 1.8
diff -r1.8 AbstractJdbc2Statement.java
118c118
<         return 0;
---
>         return super.fetchSize;
133c133,135
<         throw org.postgresql.Driver.notImplemented();
---
>         // I don't think this should happen, since it's a hint it should just
>         // fail quietly.
>         //   throw org.postgresql.Driver.notImplemented();
138c140
<         throw org.postgresql.Driver.notImplemented();
---
>         super.fetchSize = rows;
Index: org/postgresql/jdbc2/Array.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/jdbc2/Array.java,v
retrieving revision 1.18
diff -r1.18 Array.java
346c346,349
<         return ((AbstractJdbc2Connection)conn).getResultSet(null, fields, rows, "OK", 1 );
---
>         java.sql.Statement stat = ((AbstractJdbc2Connection)conn).createStatement();
>         java.sql.ResultSet retRs = ((AbstractJdbc2Connection)conn).createResultSet(stat);
>         ((AbstractJdbc2ResultSet)retRs).init(fields, rows, "OK", 1, 0, false);
>         return retRs;
Index: org/postgresql/jdbc2/Jdbc2Connection.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/jdbc2/Jdbc2Connection.java,v
retrieving revision 1.5
diff -r1.5 Jdbc2Connection.java
48a49,80
>
>
>     // the new method override which re-inits existing resultsets
>     public java.sql.ResultSet getResultSet(java.sql.Statement stat,
>                            org.postgresql.jdbc1.AbstractJdbc1ResultSet rs,
>                            Field[] fields,
>                            Vector tuples,
>                            String status,
>                            int updateCount, long insertOID, boolean binaryCursor)
>         throws SQLException
>     {
>         if (rs == null)
>             return new Jdbc2ResultSet(this, stat, fields,
>                           tuples, status,
>                           updateCount, insertOID, binaryCursor);
>         else
>         {
>             rs.init(fields, tuples, status, updateCount, insertOID, binaryCursor);
>             return (java.sql.ResultSet) rs;
>         }
>     }
>
>
>
>
>     /** new nic method **/
>     public java.sql.ResultSet createResultSet (Statement statement)
>     {
>         return new Jdbc2ResultSet(this, statement);
>     }
>
>
Index: org/postgresql/jdbc2/Jdbc2ResultSet.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/jdbc2/Jdbc2ResultSet.java,v
retrieving revision 1.6
diff -r1.6 Jdbc2ResultSet.java
15a16,21
>     Jdbc2ResultSet (org.postgresql.PGConnection conn, Statement statement)
>     {
>         super (conn, statement);
>     }
>
>
Index: org/postgresql/jdbc3/AbstractJdbc3ResultSet.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/jdbc3/AbstractJdbc3ResultSet.java,v
retrieving revision 1.2
diff -r1.2 AbstractJdbc3ResultSet.java
14a15,20
>     AbstractJdbc3ResultSet (org.postgresql.PGConnection conn, Statement statement)
>     {
>         super(conn, statement);
>     }
>
>
Index: org/postgresql/jdbc3/Jdbc3Connection.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/jdbc3/Jdbc3Connection.java,v
retrieving revision 1.2
diff -r1.2 Jdbc3Connection.java
49,52d48
<     public java.sql.ResultSet getResultSet(Statement statement, Field[] fields, Vector tuples, String status, int
updateCount,long insertOID, boolean binaryCursor) throws SQLException 
<     {
<         return new Jdbc3ResultSet(this, statement, fields, tuples, status, updateCount, insertOID, binaryCursor);
<     }
54c50,56
<     public java.sql.ResultSet getResultSet(Statement statement, Field[] fields, Vector tuples, String status, int
updateCount)throws SQLException 
---
>
>
>
>
>
>     /** new nic method **/
>     public java.sql.ResultSet createResultSet (Statement statement)
56c58
<         return new Jdbc3ResultSet(this, statement, fields, tuples, status, updateCount, 0, false);
---
>         return new Jdbc3ResultSet(this, statement);
Index: org/postgresql/jdbc3/Jdbc3ResultSet.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/jdbc3/Jdbc3ResultSet.java,v
retrieving revision 1.3
diff -r1.3 Jdbc3ResultSet.java
15a16,22
>     Jdbc3ResultSet (org.postgresql.PGConnection conn, Statement statement)
>     {
>         super (conn, statement);
>     }
>
>
>
Index: org/postgresql/util/Serialize.java
===================================================================
RCS file: /projects/cvsroot/pgsql-server/src/interfaces/jdbc/org/postgresql/util/Serialize.java,v
retrieving revision 1.14
diff -r1.14 Serialize.java
408c408
<             ResultSet rs = ((org.postgresql.jdbc1.AbstractJdbc1Connection)conn).ExecSQL(sb.toString());
---
>             ResultSet rs = ((org.postgresql.jdbc1.AbstractJdbc1Connection)conn).doQuery(sb.toString());