--no commit message

--no commit message

h2/src/test/org/h2/test/jdbc/TestCancel.java

+/*
+ * Copyright 2004-2006 H2 Group. Licensed under the H2 License, Version 1.0 (http://h2database.com/html/license.html). 
+ * Initial Developer: H2 Group 
+ */
+package org.h2.test.jdbc;
+
+import java.sql.*;
+
+import org.h2.test.TestBase;
+
+/**
+ * @author Thomas
+ */
+
+public class TestCancel extends TestBase {
+    
+    class Canceller extends Thread {
+        private Statement cancel;
+        private int wait;
+        Canceller(Statement cancel, int wait) {
+            this.cancel = cancel;
+            this.wait = wait;
+        }
+        public void run() {
+            try {
+                Thread.sleep(wait);
+                cancel.cancel();
+                Thread.yield();
+            } catch (SQLException e) {
+                // ignore errors on closed statements
+            } catch(Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+    
+    public void test() throws Exception {
+        deleteDb("cancel");
+        Connection conn = getConnection("cancel");
+        Statement stat = conn.createStatement();
+        stat.execute("DROP TABLE IF EXISTS TEST");
+        stat.execute("CREATE  MEMORY TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))");
+        PreparedStatement prep = conn.prepareStatement("INSERT INTO TEST VALUES(?, ?)");
+        trace("insert");
+        int len = getSize(1, 1000);
+        for(int i=0; i<len; i++) {
+            prep.setInt(1, i);
+            //prep.setString(2, "Test Value "+i);
+            prep.setString(2, "hi");
+            prep.execute();
+        }
+        trace("inserted");
+        // TODO test insert.. select
+        for (int i = 1;;) {
+            Statement query = conn.createStatement();
+            Canceller canceller = new Canceller(query, i);
+            canceller.start();
+            Thread.yield();
+            int j=0;
+            try {
+                ResultSet rs = query.executeQuery("SELECT * FROM TEST");                
+                while(rs.next()) {
+                    j++;
+                }
+                trace("record count: "+j);
+            } catch(SQLException e) {
+                checkNotGeneralException(e);
+                // ignore cancelled statements
+                trace("record count: "+j);
+            }
+            if(j == 0) {
+                i += 10;
+            } else if(j == len) {
+                break;
+            }
+        }
+        conn.close();
+    }
+
+}

h2/src/test/org/h2/test/jdbc/TestDataSource.java

+/*
+ * Copyright 2004-2006 H2 Group. Licensed under the H2 License, Version 1.0 (http://h2database.com/html/license.html).
+ * Initial Developer: H2 Group
+ */
+package org.h2.test.jdbc;
+
+import java.sql.Connection;
+import java.sql.Statement;
+
+import org.h2.jdbcx.JdbcDataSource;
+import org.h2.test.TestBase;
+
+public class TestDataSource extends TestBase {
+
+    
+//    public static void main(String[] args) throws Exception {
+//        
+//        // first, need to start on the command line:
+//        // rmiregistry 1099
+//        
+//        // System.setProperty(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
+//        System.setProperty(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");
+//        System.setProperty(Context.PROVIDER_URL, "rmi://localhost:1099");
+//        
+//        JdbcDataSource ds = new JdbcDataSource();
+//        ds.setURL("jdbc:h2:test");
+//        ds.setUser("test");
+//        ds.setPassword("");
+//
+//        Context ctx = new InitialContext();
+//        ctx.bind("jdbc/test", ds);        
+//        
+//        DataSource ds2 = (DataSource)ctx.lookup("jdbc/test");
+//        Connection conn = ds2.getConnection();
+//        conn.close();
+//    } 
+    
+    public void test() throws Exception {
+        deleteDb("datasource");
+
+        JdbcDataSource ds = new JdbcDataSource();
+        ds.setURL("jdbc:h2:"+BASE_DIR+"/datasource");
+        ds.setUser("sa");
+        ds.setPassword("");
+        Connection conn = ds.getConnection();
+        Statement stat = conn.createStatement();
+        stat.execute("SELECT * FROM DUAL");
+        conn.close();
+    }
+
+}

h2/src/test/org/h2/test/jdbc/TestManyJdbcObjects.java

+/*
+ * Copyright 2004-2006 H2 Group. Licensed under the H2 License, Version 1.0 (http://h2database.com/html/license.html). 
+ * Initial Developer: H2 Group 
+ */
+package org.h2.test.jdbc;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.Statement;
+
+import org.h2.engine.Constants;
+import org.h2.test.TestBase;
+
+public class TestManyJdbcObjects extends TestBase {
+
+    public void test() throws Exception {
+        testNestedResultSets();
+        testManyConnections();
+        testOneConnectionPrepare();
+    }
+    
+    private void testNestedResultSets() throws Exception {
+        if(config.networked == false) {
+            return;
+        }
+        deleteDb("manyObjects");
+        Connection conn = getConnection("manyObjects");
+        DatabaseMetaData meta = conn.getMetaData();
+        ResultSet rsTables = meta.getColumns(null, null, null, null);        
+        while(rsTables.next()) {
+            meta.getExportedKeys(null, null, null);
+            meta.getImportedKeys(null, null, null);
+        }
+        conn.close();
+    }
+    
+    private void testManyConnections() throws Exception {
+        if(config.networked == false || config.memory) {
+            return;
+        }
+        // SERVER_CACHED_OBJECTS = 1000: connections = 20 (1250)
+        // SERVER_CACHED_OBJECTS = 500: connections = 40
+        // SERVER_CACHED_OBJECTS = 50: connections = 120
+        deleteDb("manyObjects");
+        Constants.RUN_FINALIZERS = false;
+        int connCount = getSize(4, 40);
+        Connection[] conn = new Connection[connCount];
+        for(int i=0; i<connCount; i++) {
+            conn[i] = getConnection("manyObjects");
+        }
+        int len = getSize(50, 500);
+        for (int j=0;j<len;j++) {
+            if((j % 10) == 0) {
+                trace("j=" + j);
+            }
+            for(int i=0; i<connCount; i++) {
+                conn[i].getMetaData().getSchemas().close();
+            }
+        }
+        for(int i=0; i<connCount; i++) {
+            conn[i].close();
+        }
+        Constants.RUN_FINALIZERS = true;
+    }
+    
+    private void testOneConnectionPrepare() throws Exception {
+        deleteDb("manyObjects");
+        Constants.RUN_FINALIZERS = false;
+        Connection conn = getConnection("manyObjects");
+        PreparedStatement prep;
+        Statement stat;
+        int size = getSize(10, 1000);
+        for(int i=0; i<size; i++) {
+            conn.getMetaData();
+        }
+        for(int i=0; i<size; i++) {
+            conn.createStatement();
+        }
+        stat = conn.createStatement();
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR)");
+        stat.execute("INSERT INTO TEST VALUES(1, 'Hello')");
+        for(int i=0; i<size; i++) {
+            stat.executeQuery("SELECT * FROM TEST WHERE 1=0");
+        }
+        for(int i=0; i<size; i++) {
+            stat.executeQuery("SELECT * FROM TEST");
+        }
+        for(int i=0; i<size; i++) {
+            conn.prepareStatement("SELECT * FROM TEST");
+        }
+        prep = conn.prepareStatement("SELECT * FROM TEST WHERE 1=0");
+        for(int i=0; i<size; i++) {
+            prep.executeQuery();
+        }
+        prep = conn.prepareStatement("SELECT * FROM TEST");
+        for(int i=0; i<size; i++) {
+            prep.executeQuery();
+        }
+        Constants.RUN_FINALIZERS = true;        
+        conn.close();
+    }
+
+}

h2/src/test/org/h2/test/jdbc/TestNativeSQL.java

+/*
+ * Copyright 2004-2006 H2 Group. Licensed under the H2 License, Version 1.0 (http://h2database.com/html/license.html). 
+ * Initial Developer: H2 Group 
+ */
+package org.h2.test.jdbc;
+
+import java.sql.*;
+
+import org.h2.test.TestBase;
+
+/**
+ * @author Thomas
+ */
+
+public class TestNativeSQL extends TestBase {
+
+    public void test() throws Exception {
+        deleteDb("nativeSql");
+        Connection conn = getConnection("nativeSql");
+
+        for(int i=0;i<PAIRS.length;i+=2) {
+            test(conn, PAIRS[i], PAIRS[i+1]);
+        }
+        conn.nativeSQL("TEST");
+        conn.nativeSQL("TEST--testing");
+        conn.nativeSQL("TEST--testing{oj }");
+        conn.nativeSQL("TEST/*{fn }*/");
+        conn.nativeSQL("TEST//{fn }");        
+        conn.nativeSQL("TEST-TEST/TEST/*TEST*/TEST--\rTEST--{fn }");
+        conn.nativeSQL("TEST-TEST//TEST");
+        conn.nativeSQL("'{}' '' \"1\" \"\"\"\"");
+        conn.nativeSQL("{?= call HEELO{t '10'}}");
+        conn.nativeSQL("TEST 'test'{OJ OUTER JOIN}'test'{oj OUTER JOIN}");
+        conn.nativeSQL("{call {ts '2001-01-10'}}");
+        conn.nativeSQL("call ? { 1: '}' };");
+        conn.nativeSQL("TEST TEST TEST TEST TEST 'TEST' TEST \"TEST\"");
+        conn.nativeSQL("TEST TEST TEST  'TEST' TEST \"TEST\"");
+        Statement stat = conn.createStatement();
+        stat.setEscapeProcessing(true);
+        stat.execute("CALL {d '2001-01-01'}");
+        stat.setEscapeProcessing(false);
+        try {
+            stat.execute("CALL {d '2001-01-01'} // this is a test");
+            error("expected error if setEscapeProcessing=false");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+        }
+        checkFalse(conn.isClosed());
+        conn.close();
+        check(conn.isClosed());
+    }
+    
+
+    static final String[] PAIRS=new String[]{
+        "CREATE TABLE TEST(ID INT PRIMARY KEY)",
+        "CREATE TABLE TEST(ID INT PRIMARY KEY)",
+        
+        "INSERT INTO TEST VALUES(1)",
+        "INSERT INTO TEST VALUES(1)",
+        
+        "SELECT '{nothing}' FROM TEST",
+        "SELECT '{nothing}' FROM TEST",
+        
+        "SELECT '{fn ABS(1)}' FROM TEST",
+        "SELECT '{fn ABS(1)}' FROM TEST",
+        
+        "SELECT {d '2001-01-01'} FROM TEST",
+        "SELECT    '2001-01-01'  FROM TEST",
+        
+        "SELECT {t '20:00:00'} FROM TEST",
+        "SELECT    '20:00:00'  FROM TEST",
+        
+        "SELECT {ts '2001-01-01 20:00:00'} FROM TEST",
+        "SELECT     '2001-01-01 20:00:00'  FROM TEST",
+        
+        "SELECT {fn CONCAT('{fn x}','{oj}')} FROM TEST",
+        "SELECT     CONCAT('{fn x}','{oj}')  FROM TEST",
+        
+        "SELECT * FROM {oj TEST T1 LEFT OUTER JOIN TEST T2 ON T1.ID=T2.ID}",
+        "SELECT * FROM     TEST T1 LEFT OUTER JOIN TEST T2 ON T1.ID=T2.ID ",
+        
+        "SELECT * FROM TEST WHERE '{' LIKE '{{' {escape '{'}",
+        "SELECT * FROM TEST WHERE '{' LIKE '{{'  escape '{' ",
+                        
+        "SELECT * FROM TEST WHERE '}' LIKE '}}' {escape '}'}",
+        "SELECT * FROM TEST WHERE '}' LIKE '}}'  escape '}' ",
+        
+        "{call TEST('}')}",
+        " call TEST('}') ",
+
+        "{?= call TEST('}')}",
+        "    call TEST('}') ",
+
+        "{? = call TEST('}')}",
+        "     call TEST('}') ",
+
+        "{{{{this is a bug}",
+        null,
+    };
+
+    void test(Connection conn, String original,String expected) throws Exception {
+        trace("original: <"+original+">");
+        trace("expected: <"+expected+">");
+        try {
+            String result=conn.nativeSQL(original);
+            trace("result: <"+result+">");
+            check(expected, result);
+        } catch(SQLException e) {
+            check(expected, null);
+            checkNotGeneralException(e);
+            trace("got exception, good");
+        }
+    }    
+
+}

h2/src/test/org/h2/test/jdbc/TestTransactionIsolation.java

+/*
+ * Copyright 2004-2006 H2 Group. Licensed under the H2 License, Version 1.0 (http://h2database.com/html/license.html).
+ * Initial Developer: H2 Group
+ */
+package org.h2.test.jdbc;
+
+import java.sql.*;
+
+import org.h2.test.TestBase;
+
+public class TestTransactionIsolation extends TestBase {
+    
+    Connection conn1, conn2;
+
+    public void test() throws Exception {
+        deleteDb("transactionIsolation");
+        conn1 = getConnection("transactionIsolation");
+        check(conn1.getTransactionIsolation(), Connection.TRANSACTION_SERIALIZABLE);
+        conn1.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
+        check(conn1.getTransactionIsolation(), Connection.TRANSACTION_READ_UNCOMMITTED);
+        checkSingleValue(conn1.createStatement(), "CALL LOCK_MODE()", 0);
+        conn1.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
+        checkSingleValue(conn1.createStatement(), "CALL LOCK_MODE()", 3);
+        check(conn1.getTransactionIsolation(), Connection.TRANSACTION_READ_COMMITTED);
+        conn1.createStatement().execute("SET LOCK_MODE 1");
+        check(conn1.getTransactionIsolation(), Connection.TRANSACTION_SERIALIZABLE);
+        conn1.createStatement().execute("CREATE TABLE TEST(ID INT)");
+        conn1.createStatement().execute("INSERT INTO TEST VALUES(1)");
+        conn1.setAutoCommit(false);
+        
+        conn2 = getConnection("transactionIsolation");
+        conn2.setAutoCommit(false);
+
+        conn1.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
+
+        // serializable: just reading
+        checkSingleValue(conn1.createStatement(), "SELECT * FROM TEST", 1);
+        checkSingleValue(conn2.createStatement(), "SELECT * FROM TEST", 1);
+        conn1.commit();
+        conn2.commit();
+        
+        // serializable: write lock
+        conn1.createStatement().executeUpdate("UPDATE TEST SET ID=2");
+        try {
+            checkSingleValue(conn2.createStatement(), "SELECT * FROM TEST", 1);
+            error("Expected lock timeout");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+        }
+        conn1.commit();
+        conn2.commit();
+        
+        conn1.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
+        
+        // read-committed: #1 read, #2 update, #1 read again
+        checkSingleValue(conn1.createStatement(), "SELECT * FROM TEST", 2);
+        conn2.createStatement().executeUpdate("UPDATE TEST SET ID=3");
+        conn2.commit();
+        checkSingleValue(conn1.createStatement(), "SELECT * FROM TEST", 3);
+        conn1.commit();
+        
+        // read-committed: #1 read, #2 read, #2 update, #1 delete
+        checkSingleValue(conn1.createStatement(), "SELECT * FROM TEST", 3);
+        checkSingleValue(conn2.createStatement(), "SELECT * FROM TEST", 3);
+        conn2.createStatement().executeUpdate("UPDATE TEST SET ID=4");
+        try {
+            conn1.createStatement().executeUpdate("DELETE FROM TEST");
+            error("Expected lock timeout");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+        }
+        conn2.commit();
+        conn1.commit();
+        checkSingleValue(conn1.createStatement(), "SELECT * FROM TEST", 4);
+        checkSingleValue(conn2.createStatement(), "SELECT * FROM TEST", 4);
+        
+        conn1.close();
+        conn2.close();
+    }
+
+}

h2/src/test/org/h2/test/jdbc/TestXA.java

+/*
+ * Copyright 2004-2006 H2 Group. Licensed under the H2 License, Version 1.0 (http://h2database.com/html/license.html).
+ * Initial Developer: H2 Group
+ */
+package org.h2.test.jdbc;
+
+import java.sql.Connection;
+import org.h2.jdbcx.JdbcDataSource;
+
+public class TestXA {
+    
+    int notYetImplemented;
+    
+    public static void main(String[] args) throws Exception {
+        Class.forName("org.h2.Driver");
+
+
+//        InitialContext ictx = new InitialContext();
+//        ictx.rebind(USER_TRANSACTION_JNDI_NAME, jotm.getUserTransaction());
+
+        JdbcDataSource ds1 = new JdbcDataSource();
+        ds1.setPassword("");
+        ds1.setUser("sa");
+        ds1.setURL("jdbc:h2:db1H2");
+
+        JdbcDataSource ds2 = new JdbcDataSource();
+        ds2.setPassword("");
+        ds2.setUser("sa");
+        ds2.setURL("jdbc:h2:db2H2");
+
+//        UserTransaction ut = (UserTransaction) ictx.lookup("UserTransaction");
+//        ut.begin();
+
+        Connection c1 = ds1.getXAConnection().getConnection();
+        c1.setAutoCommit(false);
+        Connection c2 = ds2.getXAConnection().getConnection();
+        c2.setAutoCommit(false);
+
+        c1.createStatement().executeUpdate("create table test(id int, teste varchar(255))");
+        c2.createStatement().executeUpdate("create table test(id int, teste varchar(255))");
+
+
+//        ut.rollback();
+        c1.close();
+        c2.close();
+
+//        jotm.stop();
+//        System.exit(0);
+        
+    }
+}

h2/src/test/org/h2/test/poweroff/Listener.java

+/*
+ * Copyright 2004-2006 H2 Group. Licensed under the H2 License, Version 1.0 (http://h2database.com/html/license.html).
+ * Initial Developer: H2 Group
+ */
+package org.h2.test.poweroff;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+public class Listener implements Runnable {
+
+    public static void main(String[] args) throws Exception {
+        new Listener().test(args);
+    }
+
+    volatile int maxValue;
+
+    void test(String[] args) throws Exception {
+        int port = 9099;
+        for (int i = 0; i < args.length; i++) {
+            if (args[i].equals("-port")) {
+                port = Integer.parseInt(args[++i]);
+            }
+        }
+        listen(port);
+    }
+
+    public void run() {
+        while(true) {
+            try {
+                Thread.sleep(10000);
+            } catch(Exception e) {
+                // ignore
+            }
+            System.out.println("Max=" + maxValue);
+        }
+    }
+
+    void listen(int port) throws Exception {
+        new Thread(this).start();
+        ServerSocket serverSocket = new ServerSocket(port);
+        System.out.println("Listening on " + serverSocket.toString());
+        long time;
+        maxValue = 0;
+        while (true) {
+            Socket socket = serverSocket.accept();
+            DataInputStream in = new DataInputStream(socket.getInputStream());
+            System.out.println("Connected");
+            time = System.currentTimeMillis();
+            try {
+                while (true) {
+                    int value = in.readInt();
+                    if (value < 0) {
+                        break;
+                    }
+                    maxValue = Math.max(maxValue, value);
+                }
+            } catch (IOException e) {
+                System.out.println("Closed with Exception: " + e);
+            }
+            time = System.currentTimeMillis() - time;
+            int ops = (int) (1000 * maxValue / time);
+            System.out.println("Max=" + maxValue + " operations/sec=" + ops);
+        }
+    }
+
+}

h2/src/test/org/h2/test/poweroff/Test.java

+/*
+ * Copyright 2004-2006 H2 Group. Licensed under the H2 License, Version 1.0 (http://h2database.com/html/license.html).
+ * Initial Developer: H2 Group
+ */
+package org.h2.test.poweroff;
+
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileDescriptor;
+import java.io.RandomAccessFile;
+import java.net.Socket;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import org.h2.util.FileUtils;
+
+public class Test {
+
+    String driver;
+    String url;
+    String user;
+    String password;
+    Connection conn;
+    Statement stat;
+    PreparedStatement prep;
+
+    private Test() {
+    }
+
+    private Test(String driver, String url, String user, String password, boolean writeDelay0) {
+        this.driver = driver;
+        this.url = url;
+        this.user = user;
+        this.password = password;
+        try {
+            Class.forName(driver);
+            conn = DriverManager.getConnection(url, user, password);
+            stat = conn.createStatement();
+            if(writeDelay0) {
+                stat.execute("SET WRITE_DELAY 0");
+            }
+            System.out.println(url +" started");
+        } catch(Exception e) {
+            System.out.println(url +": " + e.toString());
+            return;
+        }
+        try {
+            ResultSet rs = stat.executeQuery("SELECT MAX(ID) FROM TEST");
+            rs.next();
+            System.out.println(url+": MAX(ID)=" + rs.getInt(1));
+            stat.execute("DROP TABLE TEST");
+        } catch(SQLException e) {
+            // ignore
+        }
+        try {
+            stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))");
+            prep = conn.prepareStatement("INSERT INTO TEST VALUES(?, ?)");
+        } catch(SQLException e) {
+            System.out.println(url +": " + e.toString());
+        }
+    }
+
+    private void insert(int id) {
+        try {
+            if(prep != null) {
+                prep.setInt(1, id);
+                prep.setString(2, "World " + id);
+                prep.execute();
+            }
+        } catch(SQLException e) {
+            System.out.println(url +": " + e.toString());
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        new Test().test(args);
+    }
+
+    void test(String[] args) throws Exception {
+        int port = 9099;
+        String connect = "192.168.0.3";
+        boolean file = false;
+        for (int i = 0; i < args.length; i++) {
+            if (args[i].equals("-port")) {
+                port = Integer.parseInt(args[++i]);
+            } else if (args[i].equals("-connect")) {
+                connect = args[++i];
+            } else if (args[i].equals("-file")) {
+                file = true;
+            }
+        }
+        test(connect, port, file);
+    }
+
+    void test(String connect, int port, boolean file) throws Exception {
+        Socket socket = new Socket(connect, port);
+        DataOutputStream out = new DataOutputStream(socket.getOutputStream());
+        System.out.println("Connected to " + socket.toString());
+        if (file) {
+            testFile(out);
+        } else {
+            testDatabases(out);
+        }
+    }
+
+    void testFile(DataOutputStream out) throws Exception {
+        File file = new File("test.txt");
+        if (file.exists()) {
+            file.delete();
+        }
+        RandomAccessFile write = new RandomAccessFile(file, "rws");
+        // RandomAccessFile write = new RandomAccessFile(file, "rwd");
+        int fileSize = 10 * 1024 * 1024;
+        FileUtils.setLength(write, fileSize);
+        write.seek(0);
+        int i = 0;
+         FileDescriptor fd = write.getFD();
+        while (true) {
+            if (write.getFilePointer() >= fileSize) {
+                break;
+            }
+            write.writeBytes(i + "\r\n");
+            fd.sync();
+            out.writeInt(i);
+            out.flush();
+            i++;
+        }
+        write.close();
+    }
+
+    void testDatabases(DataOutputStream out) throws Exception {
+        Test[] dbs = new Test[] {
+            new Test("org.h2.Driver", "jdbc:h2:test1", "sa", "", true),
+            new Test("org.h2.Driver", "jdbc:h2:test2", "sa", "", false),
+            new Test("org.hsqldb.jdbcDriver", "jdbc:hsqldb:test4", "sa", "", false),
+//            new Test("com.mysql.jdbc.Driver", "jdbc:mysql://localhost/test", "sa", ""),
+            new Test("org.postgresql.Driver", "jdbc:postgresql:test", "sa", "sa", false),
+            new Test("org.apache.derby.jdbc.EmbeddedDriver", "jdbc:derby:test;create=true", "sa", "", false),
+            new Test("org.h2.Driver", "jdbc:h2:test5", "sa", "", true),
+            new Test("org.h2.Driver", "jdbc:h2:test6", "sa", "", false),
+        };
+        for(int i=0; ; i++) {
+            for(int j=0; j<dbs.length; j++) {
+                dbs[j].insert(i);
+            }
+            out.writeInt(i);
+            out.flush();
+        }
+    }
+
+}

h2/src/test/org/h2/test/server/TestNestedLoop.java

+/*
+ * Copyright 2004-2006 H2 Group. Licensed under the H2 License, Version 1.0 (http://h2database.com/html/license.html).
+ * Initial Developer: H2 Group
+ */
+package org.h2.test.server;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import org.h2.test.TestBase;
+
+public class TestNestedLoop extends TestBase {
+
+    public void test() throws Exception {
+        deleteDb("nestedLoop");
+        Connection conn = getConnection("nestedLoop");
+        Statement stat = conn.createStatement();
+        stat.execute("create table test(id int identity, name varchar)");
+        int len = getSize(1010, 10000);
+        for(int i=0; i<len; i++) {
+            stat.execute("insert into test(name) values('Hello World')");
+        }
+        ResultSet rs = stat.executeQuery("select id from test");
+        stat.executeQuery("select id from test");
+        try {
+            rs.next();
+            error("Result set should be closed");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+        }
+        rs = stat.executeQuery("select id from test");
+        stat.close();
+        try {
+            rs.next();
+            error("Result set should be closed");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+        }
+        stat = conn.createStatement();
+        rs = stat.executeQuery("select id from test");
+        Statement stat2 = conn.createStatement();
+        while(rs.next()) {
+            int id = rs.getInt(1);
+            ResultSet rs2 = stat2.executeQuery("select * from test where id=" + id);
+            while(rs2.next()) {
+                check(rs2.getInt(1), id);
+                check(rs2.getString(2), "Hello World");
+            }
+            rs2 = stat2.executeQuery("select * from test where id=" + id);
+            while(rs2.next()) {
+                check(rs2.getInt(1), id);
+                check(rs2.getString(2), "Hello World");
+            }
+        }
+        conn.close();
+        
+    }
+
+}