diff -Nacr -X /tmp/exclude.6843 jdbc.004_reenable_tests/org/postgresql/jdbc1/AbstractJdbc1Statement.java jdbc.006_scrollable_resultsets/org/postgresql/jdbc1/AbstractJdbc1Statement.java *** jdbc.004_reenable_tests/org/postgresql/jdbc1/AbstractJdbc1Statement.java Wed Oct 29 15:39:09 2003 --- jdbc.006_scrollable_resultsets/org/postgresql/jdbc1/AbstractJdbc1Statement.java Wed Nov 5 14:03:35 2003 *************** *** 133,138 **** --- 133,143 ---- return fetchSize; } + // Overridden by JDBC2 code. + protected boolean wantsScrollableResultSet() { + return false; + } + protected void parseSqlStmt (String p_sql) throws SQLException { String l_sql = p_sql; *************** *** 466,472 **** // We prefer cursor-based-fetch over server-side-prepare here. // Eventually a v3 implementation should let us do both at once. ! if (fetchSize > 0 && !connection.getAutoCommit() && isSingleSelect()) return transformToCursorFetch(); if (isUseServerPrepare() && isSingleDML()) --- 471,477 ---- // We prefer cursor-based-fetch over server-side-prepare here. // Eventually a v3 implementation should let us do both at once. ! if (fetchSize > 0 && !wantsScrollableResultSet() && !connection.getAutoCommit() && isSingleSelect()) return transformToCursorFetch(); if (isUseServerPrepare() && isSingleDML()) diff -Nacr -X /tmp/exclude.6843 jdbc.004_reenable_tests/org/postgresql/jdbc2/AbstractJdbc2Connection.java jdbc.006_scrollable_resultsets/org/postgresql/jdbc2/AbstractJdbc2Connection.java *** jdbc.004_reenable_tests/org/postgresql/jdbc2/AbstractJdbc2Connection.java Tue Jul 1 09:10:55 2003 --- jdbc.006_scrollable_resultsets/org/postgresql/jdbc2/AbstractJdbc2Connection.java Wed Nov 5 14:03:35 2003 *************** *** 21,43 **** public java.sql.Statement createStatement() throws SQLException { ! // The spec says default of TYPE_FORWARD_ONLY but everyone is used to ! // using TYPE_SCROLL_INSENSITIVE ! return createStatement(java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE, java.sql.ResultSet.CONCUR_READ_ONLY); } public abstract java.sql.Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException; public java.sql.PreparedStatement prepareStatement(String sql) throws SQLException { ! return prepareStatement(sql, java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE, java.sql.ResultSet.CONCUR_READ_ONLY); } public abstract java.sql.PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException; public java.sql.CallableStatement prepareCall(String sql) throws SQLException { ! return prepareCall(sql, java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE, java.sql.ResultSet.CONCUR_READ_ONLY); } public abstract java.sql.CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException; --- 21,42 ---- public java.sql.Statement createStatement() throws SQLException { ! // We now follow the spec and default to TYPE_FORWARD_ONLY. ! return createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY, java.sql.ResultSet.CONCUR_READ_ONLY); } public abstract java.sql.Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException; public java.sql.PreparedStatement prepareStatement(String sql) throws SQLException { ! return prepareStatement(sql, java.sql.ResultSet.TYPE_FORWARD_ONLY, java.sql.ResultSet.CONCUR_READ_ONLY); } public abstract java.sql.PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException; public java.sql.CallableStatement prepareCall(String sql) throws SQLException { ! return prepareCall(sql, java.sql.ResultSet.TYPE_FORWARD_ONLY, java.sql.ResultSet.CONCUR_READ_ONLY); } public abstract java.sql.CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException; diff -Nacr -X /tmp/exclude.6843 jdbc.004_reenable_tests/org/postgresql/jdbc2/AbstractJdbc2Statement.java jdbc.006_scrollable_resultsets/org/postgresql/jdbc2/AbstractJdbc2Statement.java *** jdbc.004_reenable_tests/org/postgresql/jdbc2/AbstractJdbc2Statement.java Tue Sep 9 22:49:16 2003 --- jdbc.006_scrollable_resultsets/org/postgresql/jdbc2/AbstractJdbc2Statement.java Wed Nov 5 14:03:35 2003 *************** *** 25,31 **** public AbstractJdbc2Statement (AbstractJdbc2Connection c) { super(c); ! resultsettype = ResultSet.TYPE_SCROLL_INSENSITIVE; concurrency = ResultSet.CONCUR_READ_ONLY; } --- 25,31 ---- public AbstractJdbc2Statement (AbstractJdbc2Connection c) { super(c); ! resultsettype = ResultSet.TYPE_FORWARD_ONLY; concurrency = ResultSet.CONCUR_READ_ONLY; } *************** *** 34,39 **** --- 34,44 ---- super(connection, sql); } + // Overriddes JDBC1 implementation. + protected boolean wantsScrollableResultSet() { + return resultsettype != ResultSet.TYPE_FORWARD_ONLY; + } + /* * Execute a SQL statement that may return multiple results. We * don't have to worry about this since we do not support multiple diff -Nacr -X /tmp/exclude.6843 jdbc.004_reenable_tests/org/postgresql/test/jdbc2/CursorFetchTest.java jdbc.006_scrollable_resultsets/org/postgresql/test/jdbc2/CursorFetchTest.java *** jdbc.004_reenable_tests/org/postgresql/test/jdbc2/CursorFetchTest.java Wed Nov 5 14:03:35 2003 --- jdbc.006_scrollable_resultsets/org/postgresql/test/jdbc2/CursorFetchTest.java Wed Nov 5 14:05:02 2003 *************** *** 66,71 **** --- 66,143 ---- } } + + // Similar, but for scrollable resultsets. + public void testScrollableFetch() throws Exception + { + createRows(100); + + PreparedStatement stmt = con.prepareStatement("select * from test_fetch order by value", + ResultSet.TYPE_SCROLL_INSENSITIVE, + ResultSet.CONCUR_READ_ONLY); + + int[] testSizes = { 0, 1, 49, 50, 51, 99, 100, 101 }; + for (int i = 0; i < testSizes.length; ++i) { + stmt.setFetchSize(testSizes[i]); + assertEquals(testSizes[i], stmt.getFetchSize()); + + ResultSet rs = stmt.executeQuery(); + assertEquals(testSizes[i], rs.getFetchSize()); + + for (int j = 0; j <= 50; ++j) { + assertTrue("ran out of rows at position " + j + " with fetch size " + testSizes[i], rs.next()); + assertEquals("query value error with fetch size " + testSizes[i], j, rs.getInt(1)); + } + + int position = 50; + for (int j = 1; j < 100; ++j) { + for (int k = 0; k < j; ++k) { + if (j % 2 == 0) { + ++position; + assertTrue("ran out of rows doing a forward fetch on iteration " + j + "/" + k + " at position " + position + " with fetch size " + testSizes[i], rs.next()); + } else { + --position; + assertTrue("ran out of rows doing a reverse fetch on iteration " + j + "/" + k + " at position " + position + " with fetch size " + testSizes[i], rs.previous()); + } + + assertEquals("query value error on iteration " + j + "/" + k + " with fetch size " + testSizes[i], position, rs.getInt(1)); + } + } + } + } + + public void testScrollableAbsoluteFetch() throws Exception + { + createRows(100); + + PreparedStatement stmt = con.prepareStatement("select * from test_fetch order by value", + ResultSet.TYPE_SCROLL_INSENSITIVE, + ResultSet.CONCUR_READ_ONLY); + + int[] testSizes = { 0, 1, 49, 50, 51, 99, 100, 101 }; + for (int i = 0; i < testSizes.length; ++i) { + stmt.setFetchSize(testSizes[i]); + assertEquals(testSizes[i], stmt.getFetchSize()); + + ResultSet rs = stmt.executeQuery(); + assertEquals(testSizes[i], rs.getFetchSize()); + + int position = 50; + assertTrue("ran out of rows doing an absolute fetch at " + position + " with fetch size " + testSizes[i], rs.absolute(position+1)); + assertEquals("query value error with fetch size " + testSizes[i], position, rs.getInt(1)); + + for (int j = 1; j < 100; ++j) { + if (j % 2 == 0) + position += j; + else + position -= j; + + assertTrue("ran out of rows doing an absolute fetch at " + position + " on iteration " + j + " with fetchsize" + testSizes[i], rs.absolute(position+1)); + assertEquals("query value error with fetch size " + testSizes[i], position, rs.getInt(1)); + } + } + } + // // Tests for ResultSet.setFetchSize(). //