--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/TestMetaData.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.engine.Constants;
+import org.h2.test.TestBase;
+
+public class TestMetaData extends TestBase {
+
+    Connection conn;
+    DatabaseMetaData meta;
+    Statement stat;
+    String catalog = "METADATA";
+
+    public void test() throws Exception {
+        deleteDb("metaData");
+        conn = getConnection("metaData");
+
+        testCrossReferences();
+        testProcedureColumns();
+
+        stat = conn.createStatement();
+        meta = conn.getMetaData();
+        testStatic();
+        // TODO test remaining meta data
+
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))");
+        stat.execute("CREATE INDEX IDXNAME ON TEST(NAME)");
+
+        ResultSet rs;
+
+        rs=meta.getCatalogs();
+        rs.next();
+        check(rs.getString(1), catalog);
+        checkFalse(rs.next());
+
+        rs = meta.getSchemas();
+        rs.next();
+        check(rs.getString("TABLE_SCHEM"), "INFORMATION_SCHEMA");
+        rs.next();
+        check(rs.getString("TABLE_SCHEM"), "PUBLIC");
+        checkFalse(rs.next());
+
+        rs = meta.getTableTypes();
+        rs.next();
+        check(rs.getString("TABLE_TYPE"), "SYSTEM TABLE");
+        rs.next();
+        check(rs.getString("TABLE_TYPE"), "TABLE");
+        rs.next();
+        check(rs.getString("TABLE_TYPE"), "TABLE LINK");
+        rs.next();
+        check(rs.getString("TABLE_TYPE"), "VIEW");
+        checkFalse(rs.next());
+
+        rs = meta.getTables(null, Constants.SCHEMA_MAIN, null, new String[]{"TABLE"});
+        rs.next();
+        check(rs.getString("TABLE_NAME"), "TEST");
+        checkFalse(rs.next());
+
+        rs = meta.getTables(null, "INFORMATION_SCHEMA", null, new String[]{"TABLE", "SYSTEM TABLE"});
+        rs.next();
+        check("CATALOGS", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("COLLATIONS", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("COLUMNS", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("COLUMN_PRIVILEGES", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("CONSTANTS", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("CONSTRAINTS", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("CROSS_REFERENCES", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("DOMAINS", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("FUNCTION_ALIASES", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("FUNCTION_COLUMNS", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("HELP", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("INDEXES", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("IN_DOUBT", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("RIGHTS", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("ROLES", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("SCHEMATA", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("SEQUENCES", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("SETTINGS", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("TABLES", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("TABLE_PRIVILEGES", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("TABLE_TYPES", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("TRIGGERS", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("TYPE_INFO", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("USERS", rs.getString("TABLE_NAME"));
+        rs.next();
+        check("VIEWS", rs.getString("TABLE_NAME"));
+        checkFalse(rs.next());
+
+        rs = meta.getColumns(null, null, "TEST", null);
+        rs.next();
+        check(rs.getString("COLUMN_NAME"), "ID");
+        rs.next();
+        check(rs.getString("COLUMN_NAME"), "NAME");
+        checkFalse(rs.next());
+
+        rs = meta.getPrimaryKeys(null, null, "TEST");
+        rs.next();
+        check(rs.getString("COLUMN_NAME"), "ID");
+        checkFalse(rs.next());
+
+        rs = meta.getBestRowIdentifier(null, null, "TEST", DatabaseMetaData.bestRowSession, false);
+        rs.next();
+        check(rs.getString("COLUMN_NAME"), "ID");
+        checkFalse(rs.next());
+
+        rs = meta.getIndexInfo(null, null, "TEST", false, false);
+        rs.next();
+        String index = rs.getString("INDEX_NAME");
+        check(index.startsWith("PRIMARY_KEY"));
+        check(rs.getString("COLUMN_NAME"), "ID");
+        rs.next();
+        check(rs.getString("INDEX_NAME"), "IDXNAME");
+        check(rs.getString("COLUMN_NAME"), "NAME");
+        checkFalse(rs.next());
+
+        rs = meta.getIndexInfo(null, null, "TEST", true, false);
+        rs.next();
+        index = rs.getString("INDEX_NAME");
+        check(index.startsWith("PRIMARY_KEY"));
+        check(rs.getString("COLUMN_NAME"), "ID");
+        checkFalse(rs.next());
+
+        rs = meta.getVersionColumns(null, null, "TEST");
+        checkFalse(rs.next());
+
+        stat.execute("DROP TABLE TEST");
+
+        rs = stat.executeQuery("SELECT * FROM INFORMATION_SCHEMA.SETTINGS");
+        while(rs.next()) {
+            String name = rs.getString("NAME");
+            String value = rs.getString("VALUE");
+            trace(name+"="+value);
+        }
+
+        test(conn);
+
+//      meta.getTablePrivileges()
+
+        //      meta.getAttributes()
+//      meta.getColumnPrivileges()
+//      meta.getSuperTables()
+//      meta.getSuperTypes()
+//      meta.getTypeInfo()
+//      meta.getUDTs()
+
+        conn.close();
+        testTempTable();
+
+    }
+
+    private void testProcedureColumns() throws Exception {
+        DatabaseMetaData meta = conn.getMetaData();
+        ResultSet rs;
+        Statement stat = conn.createStatement();
+        stat.execute("CREATE ALIAS PROP FOR \"java.lang.System.getProperty(java.lang.String)\"");
+        stat.execute("CREATE ALIAS EXIT FOR \"java.lang.System.exit\"");
+        rs = meta.getProcedures(null, null, "EX%");
+        testResultSetMeta(rs, 8, new String[] { "PROCEDURE_CAT", "PROCEDURE_SCHEM",
+                "PROCEDURE_NAME", "NUM_INPUT_PARAMS", "NUM_OUTPUT_PARAMS", "NUM_RESULT_SETS",
+                "REMARKS", "PROCEDURE_TYPE"}, new int[] { Types.VARCHAR,
+                Types.VARCHAR, Types.VARCHAR, Types.INTEGER,
+                Types.INTEGER, Types.INTEGER, Types.VARCHAR,
+                Types.SMALLINT}, null, null);
+        testResultSetOrdered(rs, new String[][] {
+                { catalog, Constants.SCHEMA_MAIN, "EXIT", "0", "0", "0", "", ""+DatabaseMetaData.procedureNoResult },
+                });
+        rs = meta.getProcedureColumns(null, null, null, null);
+        testResultSetMeta(rs, 13, new String[] { "PROCEDURE_CAT", "PROCEDURE_SCHEM",
+                "PROCEDURE_NAME", "COLUMN_NAME", "COLUMN_TYPE", "DATA_TYPE", "TYPE_NAME",
+                "PRECISION", "LENGTH", "SCALE", "RADIX", "NULLABLE", "REMARKS"},
+                new int[] { Types.VARCHAR,
+                Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.SMALLINT, Types.INTEGER,
+                Types.VARCHAR, Types.INTEGER, Types.INTEGER, Types.SMALLINT,
+                Types.SMALLINT, Types.SMALLINT, Types.VARCHAR}, null, null);
+        testResultSetOrdered(rs, new String[][] {
+                { catalog, Constants.SCHEMA_MAIN, "EXIT", "P1", "" + DatabaseMetaData.procedureColumnIn,
+                    "" + Types.INTEGER, "INTEGER",
+                    "10", "10", "0", "10", ""+DatabaseMetaData.procedureNoNulls},
+                { catalog, Constants.SCHEMA_MAIN, "PROP", "P1", "" + DatabaseMetaData.procedureColumnIn,
+                    "" + Types.VARCHAR, "VARCHAR",
+                    "" + Integer.MAX_VALUE, "" + Integer.MAX_VALUE, "0", "10", ""+DatabaseMetaData.procedureNullable},
+                });
+        stat.execute("DROP ALIAS EXIT");
+        stat.execute("DROP ALIAS PROP");
+    }
+
+    private void testCrossReferences() throws Exception {
+        DatabaseMetaData meta = conn.getMetaData();
+        ResultSet rs;
+        Statement stat = conn.createStatement();
+        stat.execute("CREATE TABLE PARENT(A INT, B INT, PRIMARY KEY(A, B))");
+        stat.execute("CREATE TABLE CHILD(ID INT PRIMARY KEY, PA INT, PB INT, CONSTRAINT AB FOREIGN KEY(PA, PB) REFERENCES PARENT(A, B))");
+        rs = meta.getCrossReference(null, "PUBLIC", "PARENT", null, "PUBLIC", "CHILD");
+        checkCrossRef(rs);
+        rs = meta.getImportedKeys(null, "PUBLIC", "CHILD");
+        checkCrossRef(rs);
+        rs = meta.getExportedKeys(null, "PUBLIC", "PARENT");
+        checkCrossRef(rs);
+        stat.execute("DROP TABLE PARENT");
+        stat.execute("DROP TABLE CHILD");
+    }
+
+    private void checkCrossRef(ResultSet rs) throws Exception {
+        testResultSetMeta(rs, 14, new String[] {
+                "PKTABLE_CAT", "PKTABLE_SCHEM", "PKTABLE_NAME", "PKCOLUMN_NAME",
+                "FKTABLE_CAT", "FKTABLE_SCHEM", "FKTABLE_NAME", "FKCOLUMN_NAME",
+                "KEY_SEQ", "UPDATE_RULE", "DELETE_RULE",
+                "FK_NAME", "PK_NAME", "DEFERRABILITY"
+        }, new int[] {
+                Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,
+                Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,
+                Types.SMALLINT,Types.SMALLINT,Types.SMALLINT,
+                Types.VARCHAR,Types.VARCHAR,Types.SMALLINT
+        }, null, null);
+        testResultSetOrdered(rs, new String[][] { {
+                    catalog, Constants.SCHEMA_MAIN, "PARENT", "A",
+                    catalog, Constants.SCHEMA_MAIN, "CHILD", "PA",
+                    "1", ""+DatabaseMetaData.importedKeyRestrict, ""+DatabaseMetaData.importedKeyRestrict, "AB", null,
+                    ""+DatabaseMetaData.importedKeyNotDeferrable
+                },{
+                    catalog, Constants.SCHEMA_MAIN, "PARENT", "B",
+                    catalog, Constants.SCHEMA_MAIN, "CHILD", "PB",
+                    "2", ""+DatabaseMetaData.importedKeyRestrict, ""+DatabaseMetaData.importedKeyRestrict, "AB", null,
+                    ""+DatabaseMetaData.importedKeyNotDeferrable
+        } } );
+    }
+
+    void testTempTable() throws Exception {
+        Connection conn = getConnection("metaData");
+        Statement stat = conn.createStatement();
+        stat.execute("DROP TABLE IF EXISTS TEST_TEMP");
+        stat.execute("CREATE TEMP TABLE TEST_TEMP(ID INT PRIMARY KEY, NAME VARCHAR(255))");
+        stat.execute("CREATE INDEX IDX_NAME ON TEST_TEMP(NAME)");
+        stat.execute("ALTER TABLE TEST_TEMP ADD FOREIGN KEY(ID) REFERENCES(ID)");
+        conn.close();
+
+        conn = getConnection("metaData");
+        stat = conn.createStatement();
+        stat.execute("CREATE TEMP TABLE TEST_TEMP(ID INT PRIMARY KEY, NAME VARCHAR(255))");
+        ResultSet rs = stat.executeQuery("SELECT STORAGE_TYPE FROM "
+                + "INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME='TEST_TEMP'");
+        rs.next();
+        check(rs.getString("STORAGE_TYPE"), "GLOBAL TEMPORARY");
+        stat.execute("DROP TABLE IF EXISTS TEST_TEMP");
+        conn.close();
+    }
+
+    void testStatic() throws Exception {
+        Driver dr = (Driver) Class.forName("org.h2.Driver").newInstance();
+
+        check(dr.getMajorVersion(), meta.getDriverMajorVersion());
+        check(dr.getMinorVersion(), meta.getDriverMinorVersion());
+        check(dr.jdbcCompliant());
+
+        check(dr.getPropertyInfo(null, null).length, 0);
+        check(dr.connect("jdbc:test:false", null) == null);
+
+        check(meta.getNumericFunctions().length()>0);
+        check(meta.getStringFunctions().length()>0);
+        check(meta.getSystemFunctions().length()>0);
+        check(meta.getTimeDateFunctions().length()>0);
+
+        check(meta.allProceduresAreCallable());
+        check(meta.allTablesAreSelectable());
+        check(meta.dataDefinitionCausesTransactionCommit());
+        checkFalse(meta.dataDefinitionIgnoredInTransactions());
+        checkFalse(meta.deletesAreDetected(ResultSet.TYPE_FORWARD_ONLY));
+        checkFalse(meta.deletesAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        checkFalse(meta.deletesAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE));
+        checkFalse(meta.doesMaxRowSizeIncludeBlobs());
+        check(meta.getCatalogSeparator(), ".");
+        check(meta.getCatalogTerm(), "catalog");
+        check(meta.getConnection()==conn);
+        if(config.jdk14) {
+            String versionStart = meta.getDatabaseMajorVersion()+"."+meta.getDatabaseMinorVersion();
+            check(meta.getDatabaseProductVersion().startsWith(versionStart));
+            check(meta.getDriverMajorVersion(), meta.getDatabaseMajorVersion());
+            check(meta.getDriverMinorVersion(), meta.getDatabaseMinorVersion());
+            check(meta.getJDBCMajorVersion(), 3);
+            check(meta.getJDBCMinorVersion(), 0);
+        }
+        check(meta.getDatabaseProductName(), "H2");
+        check(meta.getDefaultTransactionIsolation(), Connection.TRANSACTION_READ_COMMITTED);
+        check(meta.getDriverName(), "H2 JDBC Driver");
+
+        String versionStart = meta.getDriverMajorVersion()+"."+meta.getDriverMinorVersion();
+        check(meta.getDriverVersion().startsWith(versionStart));
+        check(meta.getExtraNameCharacters(), "");
+        check(meta.getIdentifierQuoteString(), "\"");
+        check(meta.getMaxBinaryLiteralLength(), 0);
+        check(meta.getMaxCatalogNameLength(), 0);
+        check(meta.getMaxCharLiteralLength(), 0);
+        check(meta.getMaxColumnNameLength(), 0);
+        check(meta.getMaxColumnsInGroupBy(), 0);
+        check(meta.getMaxColumnsInIndex(), 0);
+        check(meta.getMaxColumnsInOrderBy(), 0);
+        check(meta.getMaxColumnsInSelect(), 0);
+        check(meta.getMaxColumnsInTable(), 0);
+        check(meta.getMaxConnections(), 0);
+        check(meta.getMaxCursorNameLength(), 0);
+        check(meta.getMaxIndexLength(), 0);
+        check(meta.getMaxProcedureNameLength(), 0);
+        check(meta.getMaxRowSize(), 0);
+        check(meta.getMaxSchemaNameLength(), 0);
+        check(meta.getMaxStatementLength(), 0);
+        check(meta.getMaxStatements(), 0);
+        check(meta.getMaxTableNameLength(), 0);
+        check(meta.getMaxTablesInSelect(), 0);
+        check(meta.getMaxUserNameLength(), 0);
+        check(meta.getProcedureTerm(), "procedure");
+        if(config.jdk14) {
+            check(meta.getResultSetHoldability(), ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            check(meta.getSQLStateType(), DatabaseMetaData.sqlStateSQL99);
+            checkFalse(meta.locatorsUpdateCopy());
+        }
+        check(meta.getSchemaTerm(), "schema");
+        check(meta.getSearchStringEscape(), "\\");
+        check(meta.getSQLKeywords(), "");
+
+        check(meta.getURL().startsWith("jdbc:h2:"));
+        check(meta.getUserName().length()>1);
+        checkFalse(meta.insertsAreDetected(ResultSet.TYPE_FORWARD_ONLY));
+        checkFalse(meta.insertsAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        checkFalse(meta.insertsAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE));
+        check(meta.isCatalogAtStart());
+        checkFalse(meta.isReadOnly());
+        check(meta.nullPlusNonNullIsNull());
+        checkFalse(meta.nullsAreSortedAtEnd());
+        checkFalse(meta.nullsAreSortedAtStart());
+        checkFalse(meta.nullsAreSortedHigh());
+        check(meta.nullsAreSortedLow());
+        checkFalse(meta.othersDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
+        checkFalse(meta.othersDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        checkFalse(meta.othersDeletesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
+        checkFalse(meta.othersInsertsAreVisible(ResultSet.TYPE_FORWARD_ONLY));
+        checkFalse(meta.othersInsertsAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        checkFalse(meta.othersInsertsAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
+        checkFalse(meta.othersUpdatesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
+        checkFalse(meta.othersUpdatesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        checkFalse(meta.othersUpdatesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
+        checkFalse(meta.ownDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
+        checkFalse(meta.ownDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        checkFalse(meta.ownDeletesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
+        checkFalse(meta.ownInsertsAreVisible(ResultSet.TYPE_FORWARD_ONLY));
+        checkFalse(meta.ownInsertsAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        checkFalse(meta.ownInsertsAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
+        checkFalse(meta.ownUpdatesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
+        checkFalse(meta.ownUpdatesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        checkFalse(meta.ownUpdatesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
+        checkFalse(meta.storesLowerCaseIdentifiers());
+        checkFalse(meta.storesLowerCaseQuotedIdentifiers());
+        checkFalse(meta.storesMixedCaseIdentifiers());
+        check(meta.storesMixedCaseQuotedIdentifiers());
+        check(meta.storesUpperCaseIdentifiers());
+        checkFalse(meta.storesUpperCaseQuotedIdentifiers());
+        check(meta.supportsAlterTableWithAddColumn());
+        check(meta.supportsAlterTableWithDropColumn());
+        check(meta.supportsANSI92EntryLevelSQL());
+        checkFalse(meta.supportsANSI92IntermediateSQL());
+        checkFalse(meta.supportsANSI92FullSQL());
+        check(meta.supportsBatchUpdates());
+        checkFalse(meta.supportsCatalogsInDataManipulation());
+        checkFalse(meta.supportsCatalogsInIndexDefinitions());
+        checkFalse(meta.supportsCatalogsInPrivilegeDefinitions());
+        checkFalse(meta.supportsCatalogsInProcedureCalls());
+        checkFalse(meta.supportsCatalogsInTableDefinitions());
+        check(meta.supportsColumnAliasing());
+        check(meta.supportsConvert());
+        check(meta.supportsConvert(Types.INTEGER, Types.VARCHAR));
+        check(meta.supportsCoreSQLGrammar());
+        check(meta.supportsCorrelatedSubqueries());
+        checkFalse(meta.supportsDataDefinitionAndDataManipulationTransactions());
+        check(meta.supportsDataManipulationTransactionsOnly());
+        checkFalse(meta.supportsDifferentTableCorrelationNames());
+        check(meta.supportsExpressionsInOrderBy());
+        checkFalse(meta.supportsExtendedSQLGrammar());
+        checkFalse(meta.supportsFullOuterJoins());
+        if(config.jdk14) {
+            check(meta.supportsGetGeneratedKeys());
+            check(meta.supportsMultipleOpenResults());
+            checkFalse(meta.supportsNamedParameters());
+        }
+        check(meta.supportsGroupBy());
+        check(meta.supportsGroupByBeyondSelect());
+        check(meta.supportsGroupByUnrelated());
+        check(meta.supportsIntegrityEnhancementFacility());
+        check(meta.supportsLikeEscapeClause());
+        check(meta.supportsLimitedOuterJoins());
+        check(meta.supportsMinimumSQLGrammar());
+        checkFalse(meta.supportsMixedCaseIdentifiers());
+        check(meta.supportsMixedCaseQuotedIdentifiers());
+        checkFalse(meta.supportsMultipleResultSets());
+        check(meta.supportsMultipleTransactions());
+        check(meta.supportsNonNullableColumns());
+        checkFalse(meta.supportsOpenCursorsAcrossCommit());
+        checkFalse(meta.supportsOpenCursorsAcrossRollback());
+        check(meta.supportsOpenStatementsAcrossCommit());
+        check(meta.supportsOpenStatementsAcrossRollback());
+        check(meta.supportsOrderByUnrelated());
+        check(meta.supportsOuterJoins());
+        check(meta.supportsPositionedDelete());
+        check(meta.supportsPositionedUpdate());
+        check(meta.supportsResultSetConcurrency(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY));
+        check(meta.supportsResultSetConcurrency(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE));
+        check(meta.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY));
+        check(meta.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE));
+        checkFalse(meta.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY));
+        checkFalse(meta.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE));
+        if(config.jdk14) {
+            checkFalse(meta.supportsResultSetHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT));
+            check(meta.supportsResultSetHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT));
+            check(meta.supportsSavepoints());
+            checkFalse(meta.supportsStatementPooling());
+        }
+        check(meta.supportsResultSetType(ResultSet.TYPE_FORWARD_ONLY));
+        check(meta.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        checkFalse(meta.supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE));
+        check(meta.supportsSchemasInDataManipulation());
+        check(meta.supportsSchemasInIndexDefinitions());
+        check(meta.supportsSchemasInPrivilegeDefinitions());
+        check(meta.supportsSchemasInProcedureCalls());
+        check(meta.supportsSchemasInTableDefinitions());
+        check(meta.supportsSelectForUpdate());
+        checkFalse(meta.supportsStoredProcedures());
+        check(meta.supportsSubqueriesInComparisons());
+        check(meta.supportsSubqueriesInExists());
+        check(meta.supportsSubqueriesInIns());
+        check(meta.supportsSubqueriesInQuantifieds());
+        check(meta.supportsTableCorrelationNames());
+        check(meta.supportsTransactions());
+        check(meta.supportsTransactionIsolationLevel(Connection.TRANSACTION_NONE));
+        check(meta.supportsTransactionIsolationLevel(Connection.TRANSACTION_READ_COMMITTED));
+        check(meta.supportsTransactionIsolationLevel(Connection.TRANSACTION_READ_UNCOMMITTED));
+        check(meta.supportsTransactionIsolationLevel(Connection.TRANSACTION_REPEATABLE_READ));
+        check(meta.supportsTransactionIsolationLevel(Connection.TRANSACTION_SERIALIZABLE));
+        check(meta.supportsUnion());
+        check(meta.supportsUnionAll());
+        checkFalse(meta.updatesAreDetected(ResultSet.TYPE_FORWARD_ONLY));
+        checkFalse(meta.updatesAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        checkFalse(meta.updatesAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE));
+        checkFalse(meta.usesLocalFilePerTable());
+        check(meta.usesLocalFiles());
+    }
+
+    void test(Connection conn) throws Exception {
+        DatabaseMetaData meta = conn.getMetaData();
+        Statement stat = conn.createStatement();
+        ResultSet rs;
+
+        conn.setReadOnly(true);
+        conn.setReadOnly(false);
+        checkFalse(conn.isReadOnly());
+        check(conn.isReadOnly() == meta.isReadOnly());
+
+        check(conn==meta.getConnection());
+
+        // currently, setCatalog is ignored
+        conn.setCatalog("XYZ");
+        trace(conn.getCatalog());
+
+        String product = meta.getDatabaseProductName();
+        trace("meta.getDatabaseProductName:" + product);
+
+        String version = meta.getDatabaseProductVersion();
+        trace("meta.getDatabaseProductVersion:" + version);
+
+        int major = meta.getDriverMajorVersion();
+        trace("meta.getDriverMajorVersion:" + major);
+
+        int minor = meta.getDriverMinorVersion();
+        trace("meta.getDriverMinorVersion:" + minor);
+
+        String drivername = meta.getDriverName();
+        trace("meta.getDriverName:" + drivername);
+
+        String driverversion = meta.getDriverVersion();
+        trace("meta.getDriverVersion:" + driverversion);
+
+        meta.getSearchStringEscape();
+
+        String url = meta.getURL();
+        trace("meta.getURL:" + url);
+
+        String user = meta.getUserName();
+        trace("meta.getUserName:" + user);
+
+        trace("meta.nullsAreSortedHigh:" + meta.nullsAreSortedHigh());
+        trace("meta.nullsAreSortedLow:" + meta.nullsAreSortedLow());
+        trace("meta.nullsAreSortedAtStart:" + meta.nullsAreSortedAtStart());
+        trace("meta.nullsAreSortedAtEnd:" + meta.nullsAreSortedAtEnd());
+        int count = (meta.nullsAreSortedHigh() ? 1 : 0)
+                + (meta.nullsAreSortedLow() ? 1 : 0)
+                + (meta.nullsAreSortedAtStart() ? 1 : 0)
+                + (meta.nullsAreSortedAtEnd() ? 1 : 0);
+        check(count == 1);
+
+        trace("meta.allProceduresAreCallable:" + meta.allProceduresAreCallable());
+        check(meta.allProceduresAreCallable());
+
+        trace("meta.allTablesAreSelectable:" + meta.allTablesAreSelectable());
+        check(meta.allTablesAreSelectable());
+
+        trace("getTables");
+        rs = meta.getTables(null, Constants.SCHEMA_MAIN, null, new String[] { "TABLE"});
+        testResultSetMeta(rs, 6, new String[] { "TABLE_CAT", "TABLE_SCHEM",
+                "TABLE_NAME", "TABLE_TYPE", "REMARKS", "SQL"}, new int[] {
+                Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
+                Types.VARCHAR, Types.VARCHAR}, null, null);
+        if (rs.next()) {
+            error("Database is not empty after dropping all tables");
+        }
+        stat.executeUpdate("CREATE TABLE TEST(" + "ID INT PRIMARY KEY,"
+                + "TEXT_V VARCHAR(120)," + "DEC_V DECIMAL(12,3),"
+                + "DATE_V DATETIME," + "BLOB_V BLOB," + "CLOB_V CLOB" + ")");
+        rs = meta.getTables(null, Constants.SCHEMA_MAIN, null, new String[]{"TABLE"});
+        testResultSetOrdered(rs, new String[][] { { catalog, Constants.SCHEMA_MAIN, "TEST",
+                "TABLE", ""}});
+        trace("getColumns");
+        rs = meta.getColumns(null, null, "TEST", null);
+        testResultSetMeta(rs, 18, new String[] { "TABLE_CAT", "TABLE_SCHEM",
+                "TABLE_NAME", "COLUMN_NAME", "DATA_TYPE", "TYPE_NAME",
+                "COLUMN_SIZE", "BUFFER_LENGTH", "DECIMAL_DIGITS",
+                "NUM_PREC_RADIX", "NULLABLE", "REMARKS", "COLUMN_DEF",
+                "SQL_DATA_TYPE", "SQL_DATETIME_SUB", "CHAR_OCTET_LENGTH",
+                "ORDINAL_POSITION", "IS_NULLABLE"}, new int[] { Types.VARCHAR,
+                Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.SMALLINT,
+                Types.VARCHAR, Types.INTEGER, Types.INTEGER, Types.INTEGER,
+                Types.INTEGER, Types.SMALLINT, Types.VARCHAR, Types.VARCHAR,
+                Types.SMALLINT, Types.INTEGER, Types.INTEGER, Types.INTEGER,
+                Types.VARCHAR}, null, null);
+        testResultSetOrdered(rs, new String[][] {
+                { catalog, Constants.SCHEMA_MAIN, "TEST", "ID", "" + Types.INTEGER, "INTEGER", "10",
+                        "10", "0", "10", "" + DatabaseMetaData.columnNoNulls,
+                        "", "", "" + Types.INTEGER, "0", "10", "1", "NO"},
+                { catalog, Constants.SCHEMA_MAIN, "TEST", "TEXT_V", "" + Types.VARCHAR, "VARCHAR",
+                        "120", "120", "0", "10", "" + DatabaseMetaData.columnNullable,
+                        "", "", "" + Types.VARCHAR, "0", "120", "2", "YES"},
+                { catalog, Constants.SCHEMA_MAIN, "TEST", "DEC_V", "" + Types.DECIMAL, "DECIMAL", "12",
+                            "12", "3", "10", "" + DatabaseMetaData.columnNullable, "", "", "" + Types.DECIMAL,
+                        "0", "12", "3", "YES"},
+                { catalog, Constants.SCHEMA_MAIN, "TEST", "DATE_V", "" + Types.TIMESTAMP,
+                        "TIMESTAMP", "23", "23", "10", "10",
+                        "" + DatabaseMetaData.columnNullable, "", "", "" + Types.TIMESTAMP,
+                        "0", "23", "4", "YES"},
+                { catalog, Constants.SCHEMA_MAIN, "TEST", "BLOB_V", "" + Types.BLOB, "BLOB",
+                        ""+Integer.MAX_VALUE, ""+Integer.MAX_VALUE, "0", "10",
+                        "" + DatabaseMetaData.columnNullable, "", "", "" + Types.BLOB,
+                        "0", ""+Integer.MAX_VALUE, "5", "YES"},
+                { catalog, Constants.SCHEMA_MAIN, "TEST", "CLOB_V", "" + Types.CLOB, "CLOB",
+                            ""+Integer.MAX_VALUE, ""+Integer.MAX_VALUE, "0", "10",
+                        "" + DatabaseMetaData.columnNullable, "", "","" + Types.CLOB,
+                        "0", ""+Integer.MAX_VALUE, "6", "YES"}});
+        /*
+         * rs=meta.getColumns(null,null,"TEST",null); while(rs.next()) { int
+         * datatype=rs.getInt(5); }
+         */
+        trace("getIndexInfo");
+        stat.executeUpdate("CREATE INDEX IDX_TEXT_DEC ON TEST(TEXT_V,DEC_V)");
+        stat.executeUpdate("CREATE UNIQUE INDEX IDX_DATE ON TEST(DATE_V)");
+        rs = meta.getIndexInfo(null, null, "TEST", false, false);
+        testResultSetMeta(rs, 13, new String[] { "TABLE_CAT", "TABLE_SCHEM",
+                "TABLE_NAME", "NON_UNIQUE", "INDEX_QUALIFIER", "INDEX_NAME",
+                "TYPE", "ORDINAL_POSITION", "COLUMN_NAME", "ASC_OR_DESC",
+                "CARDINALITY", "PAGES", "FILTER_CONDITION"}, new int[] {
+                Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.BOOLEAN,
+                Types.VARCHAR, Types.VARCHAR, Types.SMALLINT, Types.SMALLINT,
+                Types.VARCHAR, Types.VARCHAR, Types.INTEGER, Types.INTEGER,
+                Types.VARCHAR}, null, null);
+        testResultSetOrdered(rs, new String[][] {
+                { catalog, Constants.SCHEMA_MAIN, "TEST", "FALSE", catalog, "IDX_DATE",
+                        "" + DatabaseMetaData.tableIndexOther, "1", "DATE_V",
+                        "A", "0", "0", ""},
+                { catalog, Constants.SCHEMA_MAIN, "TEST", "FALSE", catalog, "PRIMARY_KEY_1",
+                        "" + DatabaseMetaData.tableIndexOther, "1", "ID", "A",
+                        "0", "0", ""},
+                { catalog, Constants.SCHEMA_MAIN, "TEST", "TRUE", catalog, "IDX_TEXT_DEC",
+                        "" + DatabaseMetaData.tableIndexOther, "1", "TEXT_V",
+                        "A", "0", "0", ""},
+                { catalog, Constants.SCHEMA_MAIN, "TEST", "TRUE", catalog, "IDX_TEXT_DEC",
+                        "" + DatabaseMetaData.tableIndexOther, "2", "DEC_V",
+                        "A", "0", "0", ""},});
+        stat.executeUpdate("DROP INDEX IDX_TEXT_DEC");
+        stat.executeUpdate("DROP INDEX IDX_DATE");
+        rs = meta.getIndexInfo(null, null, "TEST", false, false);
+        testResultSetMeta(rs, 13, new String[] { "TABLE_CAT", "TABLE_SCHEM",
+                "TABLE_NAME", "NON_UNIQUE", "INDEX_QUALIFIER", "INDEX_NAME",
+                "TYPE", "ORDINAL_POSITION", "COLUMN_NAME", "ASC_OR_DESC",
+                "CARDINALITY", "PAGES", "FILTER_CONDITION"}, new int[] {
+                Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.BOOLEAN,
+                Types.VARCHAR, Types.VARCHAR, Types.SMALLINT, Types.SMALLINT,
+                Types.VARCHAR, Types.VARCHAR, Types.INTEGER, Types.INTEGER,
+                Types.VARCHAR}, null, null);
+        testResultSetOrdered(rs, new String[][] { { catalog, Constants.SCHEMA_MAIN, "TEST",
+                "FALSE", catalog, "PRIMARY_KEY_1",
+                "" + DatabaseMetaData.tableIndexOther, "1", "ID", "A", "0",
+                "0", ""}});
+        trace("getPrimaryKeys");
+        rs = meta.getPrimaryKeys(null, null, "TEST");
+        testResultSetMeta(rs, 6, new String[] { "TABLE_CAT", "TABLE_SCHEM",
+                "TABLE_NAME", "COLUMN_NAME", "KEY_SEQ", "PK_NAME"}, new int[] {
+                Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
+                Types.SMALLINT, Types.VARCHAR}, null, null);
+        testResultSetOrdered(rs, new String[][] { { catalog, Constants.SCHEMA_MAIN, "TEST", "ID",
+                "1", "PRIMARY_KEY_1"},});
+        trace("getTables - using a wildcard");
+        stat.executeUpdate("CREATE TABLE T_2(B INT,A VARCHAR(6),C INT,PRIMARY KEY(C,A,B))");
+        stat.executeUpdate("CREATE TABLE TX2(B INT,A VARCHAR(6),C INT,PRIMARY KEY(C,A,B))");
+        rs = meta.getTables(null, null, "T_2", null);
+        testResultSetOrdered(rs, new String[][] {
+                { catalog, Constants.SCHEMA_MAIN, "TX2", "TABLE", ""},
+                { catalog, Constants.SCHEMA_MAIN, "T_2", "TABLE", ""}});
+        trace("getTables - using a quoted _ character");
+        rs = meta.getTables(null, null, "T\\_2", null);
+        testResultSetOrdered(rs, new String[][] { { catalog, Constants.SCHEMA_MAIN, "T_2", "TABLE",
+                ""}});
+        trace("getTables - using the % wildcard");
+        rs = meta.getTables(null, Constants.SCHEMA_MAIN, "%", new String[]{"TABLE"});
+        testResultSetOrdered(rs, new String[][] {
+                { catalog, Constants.SCHEMA_MAIN, "TEST", "TABLE", ""},
+                { catalog, Constants.SCHEMA_MAIN, "TX2", "TABLE", ""},
+                { catalog, Constants.SCHEMA_MAIN, "T_2", "TABLE", ""}});
+        stat.execute("DROP TABLE TEST");
+
+        trace("getColumns - using wildcards");
+        rs = meta.getColumns(null, null, "___", "B%");
+        testResultSetOrdered(rs, new String[][] {
+                { catalog, Constants.SCHEMA_MAIN, "TX2", "B", "" + Types.INTEGER, "INTEGER", "10" /*,
+                        null, "0", "10", "" + DatabaseMetaData.columnNoNulls,
+                        null, null, null, null, null, "1", "NO" */},
+                { catalog, Constants.SCHEMA_MAIN, "T_2", "B", "" + Types.INTEGER, "INTEGER", "10" /*,
+                        null, "0", "10", "" + DatabaseMetaData.columnNoNulls,
+                        null, null, null, null, null, "1", "NO" */},});
+        trace("getColumns - using wildcards");
+        rs = meta.getColumns(null, null, "_\\__", "%");
+        testResultSetOrdered(rs, new String[][] {
+                { catalog, Constants.SCHEMA_MAIN, "T_2", "B", "" + Types.INTEGER, "INTEGER", "10" /*,
+                        null, "0", "10", "" + DatabaseMetaData.columnNoNulls,
+                        null, null, null, null, null, "1", "NO"*/},
+                { catalog, Constants.SCHEMA_MAIN, "T_2", "A", "" + Types.VARCHAR, "VARCHAR", "6" /*,
+                        null, "0", "10", "" + DatabaseMetaData.columnNoNulls,
+                        null, null, null, null, null, "2", "NO"*/},
+                { catalog, Constants.SCHEMA_MAIN, "T_2", "C", "" + Types.INTEGER, "INTEGER", "10" /*,
+                        null, "0", "10", "" + DatabaseMetaData.columnNoNulls,
+                        null, null, null, null, null, "3", "NO"*/},});
+        trace("getIndexInfo");
+        stat.executeUpdate("CREATE UNIQUE INDEX A_INDEX ON TX2(B,C,A)");
+        stat.executeUpdate("CREATE INDEX B_INDEX ON TX2(A,B,C)");
+        rs = meta.getIndexInfo(null, null, "TX2", false, false);
+        testResultSetOrdered(rs, new String[][] {
+                { catalog, Constants.SCHEMA_MAIN, "TX2", "FALSE", catalog, "A_INDEX",
+                        "" + DatabaseMetaData.tableIndexOther, "1", "B", "A" /*,
+                        null, null, null */},
+                { catalog, Constants.SCHEMA_MAIN, "TX2", "FALSE", catalog, "A_INDEX",
+                        "" + DatabaseMetaData.tableIndexOther, "2", "C", "A" /*,
+                        null, null, null*/},
+                { catalog, Constants.SCHEMA_MAIN, "TX2", "FALSE", catalog, "A_INDEX",
+                        "" + DatabaseMetaData.tableIndexOther, "3", "A", "A" /*,
+                        null, null, null*/},
+                { catalog, Constants.SCHEMA_MAIN, "TX2", "FALSE", catalog, "PRIMARY_KEY_3",
+                        "" + DatabaseMetaData.tableIndexOther, "1", "C", "A" /*,
+                        null, null, null*/},
+                { catalog, Constants.SCHEMA_MAIN, "TX2", "FALSE", catalog, "PRIMARY_KEY_3",
+                        "" + DatabaseMetaData.tableIndexOther, "2", "A", "A" /*,
+                        null, null, null*/},
+                { catalog, Constants.SCHEMA_MAIN, "TX2", "FALSE", catalog, "PRIMARY_KEY_3",
+                        "" + DatabaseMetaData.tableIndexOther, "3", "B", "A"/*,
+                        null, null, null*/},
+                { catalog, Constants.SCHEMA_MAIN, "TX2", "TRUE", catalog, "B_INDEX",
+                        "" + DatabaseMetaData.tableIndexOther, "1", "A", "A" /*,
+                        null, null, null*/},
+                { catalog, Constants.SCHEMA_MAIN, "TX2", "TRUE", catalog, "B_INDEX",
+                        "" + DatabaseMetaData.tableIndexOther, "2", "B", "A" /*,
+                        null, null, null*/},
+                { catalog, Constants.SCHEMA_MAIN, "TX2", "TRUE", catalog, "B_INDEX",
+                        "" + DatabaseMetaData.tableIndexOther, "3", "C", "A" /*,
+                        null, null, null*/},});
+        trace("getPrimaryKeys");
+        rs = meta.getPrimaryKeys(null, null, "T_2");
+        testResultSetOrdered(rs, new String[][] {
+                { catalog, Constants.SCHEMA_MAIN, "T_2", "A", "2", "PRIMARY_KEY_2"},
+                { catalog, Constants.SCHEMA_MAIN, "T_2", "B", "3", "PRIMARY_KEY_2"},
+                { catalog, Constants.SCHEMA_MAIN, "T_2", "C", "1", "PRIMARY_KEY_2"},});
+        stat.executeUpdate("DROP TABLE TX2");
+        stat.executeUpdate("DROP TABLE T_2");
+        stat.executeUpdate("CREATE TABLE PARENT(ID INT PRIMARY KEY)");
+        stat
+                .executeUpdate("CREATE TABLE CHILD(P_ID INT,ID INT,PRIMARY KEY(P_ID,ID),FOREIGN KEY(P_ID) REFERENCES PARENT(ID))");
+
+        trace("getImportedKeys");
+        rs = meta.getImportedKeys(null, null, "CHILD");
+        testResultSetMeta(rs, 14, new String[] { "PKTABLE_CAT",
+                "PKTABLE_SCHEM", "PKTABLE_NAME", "PKCOLUMN_NAME",
+                "FKTABLE_CAT", "FKTABLE_SCHEM", "FKTABLE_NAME",
+                "FKCOLUMN_NAME", "KEY_SEQ", "UPDATE_RULE", "DELETE_RULE",
+                "FK_NAME", "PK_NAME", "DEFERRABILITY"}, new int[] {
+                Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
+                Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
+                Types.SMALLINT, Types.SMALLINT, Types.SMALLINT, Types.VARCHAR,
+                Types.VARCHAR, Types.SMALLINT}, null, null);
+        // TODO test
+        // testResultSetOrdered(rs, new String[][] { { null, null, "PARENT", "ID",
+        //        null, null, "CHILD", "P_ID", "1",
+        //        "" + DatabaseMetaData.importedKeyNoAction,
+        //        "" + DatabaseMetaData.importedKeyNoAction, "FK_1", null,
+        //        "" + DatabaseMetaData.importedKeyNotDeferrable}});
+
+        trace("getExportedKeys");
+        rs = meta.getExportedKeys(null, null, "PARENT");
+        testResultSetMeta(rs, 14, new String[] { "PKTABLE_CAT",
+                "PKTABLE_SCHEM", "PKTABLE_NAME", "PKCOLUMN_NAME",
+                "FKTABLE_CAT", "FKTABLE_SCHEM", "FKTABLE_NAME",
+                "FKCOLUMN_NAME", "KEY_SEQ", "UPDATE_RULE", "DELETE_RULE",
+                "FK_NAME", "PK_NAME", "DEFERRABILITY"}, new int[] {
+                Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
+                Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
+                Types.SMALLINT, Types.SMALLINT, Types.SMALLINT, Types.VARCHAR,
+                Types.VARCHAR, Types.SMALLINT}, null, null);
+        // TODO test
+        /*
+         * testResultSetOrdered(rs, new String[][]{ { null,null,"PARENT","ID",
+         * null,null,"CHILD","P_ID",
+         * "1",""+DatabaseMetaData.importedKeyNoAction,""+DatabaseMetaData.importedKeyNoAction,
+         * null,null,""+DatabaseMetaData.importedKeyNotDeferrable } } );
+         */
+        trace("getCrossReference");
+        rs = meta.getCrossReference(null, null, "PARENT", null, null, "CHILD");
+        testResultSetMeta(rs, 14, new String[] { "PKTABLE_CAT",
+                "PKTABLE_SCHEM", "PKTABLE_NAME", "PKCOLUMN_NAME",
+                "FKTABLE_CAT", "FKTABLE_SCHEM", "FKTABLE_NAME",
+                "FKCOLUMN_NAME", "KEY_SEQ", "UPDATE_RULE", "DELETE_RULE",
+                "FK_NAME", "PK_NAME", "DEFERRABILITY"}, new int[] {
+                Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
+                Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
+                Types.SMALLINT, Types.SMALLINT, Types.SMALLINT, Types.VARCHAR,
+                Types.VARCHAR, Types.SMALLINT}, null, null);
+        // TODO test
+        /*
+         * testResultSetOrdered(rs, new String[][]{ { null,null,"PARENT","ID",
+         * null,null,"CHILD","P_ID",
+         * "1",""+DatabaseMetaData.importedKeyNoAction,""+DatabaseMetaData.importedKeyNoAction,
+         * null,null,""+DatabaseMetaData.importedKeyNotDeferrable } } );
+         */
+
+
+
+        rs = meta.getSchemas();
+        testResultSetMeta(rs, 3, new String[] { "TABLE_SCHEM", "TABLE_CATALOG", "IS_DEFAULT"}, new int[] { Types.VARCHAR, Types.VARCHAR, Types.BOOLEAN}, null, null);
+        check(rs.next());
+        check(rs.getString(1), "INFORMATION_SCHEMA");
+        check(rs.next());
+        check(rs.getString(1), "PUBLIC");
+        checkFalse(rs.next());
+
+        rs = meta.getCatalogs();
+        testResultSetMeta(rs, 1, new String[] { "TABLE_CAT"}, new int[] { Types.VARCHAR}, null, null);
+        testResultSetOrdered(rs, new String[][] { { catalog } });
+
+        rs = meta.getTableTypes();
+        testResultSetMeta(rs, 1, new String[] { "TABLE_TYPE"}, new int[] { Types.VARCHAR}, null, null);
+        testResultSetOrdered(rs, new String[][] { { "SYSTEM TABLE" }, { "TABLE" }, { "TABLE LINK" }, {"VIEW" } });
+
+        rs = meta.getTypeInfo();
+        testResultSetMeta(rs, 18,  new String[]{
+                    "TYPE_NAME","DATA_TYPE","PRECISION","LITERAL_PREFIX",
+                    "LITERAL_SUFFIX","CREATE_PARAMS","NULLABLE","CASE_SENSITIVE",
+                    "SEARCHABLE","UNSIGNED_ATTRIBUTE","FIXED_PREC_SCALE",
+                    "AUTO_INCREMENT","LOCAL_TYPE_NAME","MINIMUM_SCALE",
+                    "MAXIMUM_SCALE","SQL_DATA_TYPE","SQL_DATETIME_SUB",
+                    "NUM_PREC_RADIX"
+                },
+                new int[]{
+                    Types.VARCHAR,Types.SMALLINT,Types.INTEGER,Types.VARCHAR,
+                    Types.VARCHAR,Types.VARCHAR,Types.SMALLINT,Types.BOOLEAN,
+                    Types.SMALLINT,Types.BOOLEAN,Types.BOOLEAN,Types.BOOLEAN,
+                    Types.VARCHAR,Types.SMALLINT,Types.SMALLINT,Types.SMALLINT,
+                    Types.INTEGER,Types.INTEGER
+                }   ,null, null
+        );
+
+        rs = meta.getTablePrivileges(null, null, null);
+        testResultSetMeta(rs, 7,  new String[]{
+                    "TABLE_CAT","TABLE_SCHEM","TABLE_NAME","GRANTOR",
+                    "GRANTEE","PRIVILEGE","IS_GRANTABLE"
+                },
+                new int[]{
+                    Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,
+                    Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR
+                }   ,null, null
+        );
+
+        rs = meta.getColumnPrivileges(null, null, "TEST", null);
+        testResultSetMeta(rs, 8,  new String[]{
+                    "TABLE_CAT","TABLE_SCHEM","TABLE_NAME","COLUMN_NAME","GRANTOR",
+                    "GRANTEE","PRIVILEGE","IS_GRANTABLE"
+                },
+                new int[]{
+                    Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,
+                    Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR
+                }   ,null, null
+        );
+
+        check(conn.getWarnings()==null);
+        conn.clearWarnings();
+        check(conn.getWarnings()==null);
+
+    }
+
+}

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/TestPreparedStatement.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.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.StringReader;
+import java.math.BigDecimal;
+import java.sql.Connection;
+import java.sql.ParameterMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Types;
+
+import org.h2.test.TestBase;
+
+public class TestPreparedStatement extends TestBase {
+    
+    static final int LOB_SIZE=4000, LOB_SIZE_BIG=512 * 1024;
+    
+    public void test() throws Exception {
+        
+        deleteDb("preparedStatement");
+        Connection conn = getConnection("preparedStatement");
+        testSetObject(conn);
+        testPreparedSubquery(conn);
+        testLikeIndex(conn);
+        testCasewhen(conn);
+        testSubquery(conn);
+        testObject(conn);
+        if(config.jdk14) {
+            testIdentity(conn);
+        }
+        testDataTypes(conn);        
+        testBlob(conn);
+        testClob(conn);
+        testParameterMetaData(conn);
+        conn.close();
+    }
+    
+    private void testSetObject(Connection conn) throws Exception {
+        Statement stat = conn.createStatement();
+        stat.execute("CREATE TABLE TEST(ID INT, DATA BINARY, JAVA OTHER)");
+        PreparedStatement prep = conn.prepareStatement("INSERT INTO TEST VALUES(?, ?, ?)");
+        prep.setInt(1, 1);
+        prep.setObject(2, new Integer(11));
+        prep.setObject(3, null);
+        prep.execute();
+        prep.setInt(1, 2);
+        prep.setObject(2, new Integer(101), Types.OTHER);
+        prep.setObject(3, new Integer(103), Types.OTHER);
+        prep.execute();
+        PreparedStatement p2 = conn.prepareStatement("SELECT * FROM TEST ORDER BY ID");
+        ResultSet rs = p2.executeQuery();
+        rs.next();
+        Object o = rs.getObject(2);
+        check(o instanceof byte[]);
+        check(rs.getObject(3) == null);
+        rs.next();
+        o = rs.getObject(2);
+        check(o instanceof byte[]);
+        o = rs.getObject(3);
+        check(o instanceof Integer);
+        check(((Integer)o).intValue(), 103);
+        checkFalse(rs.next());
+        stat.execute("DROP TABLE TEST");
+    }
+
+    private void testPreparedSubquery(Connection conn) throws Exception {
+        Statement s = conn.createStatement();
+        s.executeUpdate("CREATE TABLE TEST(ID IDENTITY, FLAG BIT)");
+        s.executeUpdate("INSERT INTO TEST(ID, FLAG) VALUES(0, FALSE)");
+        s.executeUpdate("INSERT INTO TEST(ID, FLAG) VALUES(1, FALSE)");
+        PreparedStatement u = conn.prepareStatement("SELECT ID, FLAG FROM TEST ORDER BY ID");
+        PreparedStatement p = conn.prepareStatement("UPDATE TEST SET FLAG=true WHERE ID=(SELECT ?)");
+        p.clearParameters();
+        p.setLong(1, 0);
+        check(p.executeUpdate(), 1);
+        p.clearParameters();
+        p.setLong(1, 1);
+        check(p.executeUpdate(), 1);
+        ResultSet rs = u.executeQuery();
+        check(rs.next());
+        check(rs.getInt(1), 0);
+        check(rs.getBoolean(2));
+        check(rs.next());
+        check(rs.getInt(1), 1);
+        check(rs.getBoolean(2));
+        
+        p = conn.prepareStatement("SELECT * FROM TEST WHERE EXISTS(SELECT * FROM TEST WHERE ID=?)");
+        p.setInt(1, -1);
+        rs = p.executeQuery();
+        checkFalse(rs.next());
+        p.setInt(1, 1);
+        rs = p.executeQuery();
+        check(rs.next());
+        
+        s.executeUpdate("DROP TABLE IF EXISTS TEST");
+    }
+
+    private void testParameterMetaData(Connection conn) throws Exception {
+        PreparedStatement prep = conn.prepareStatement("SELECT ?, ?, ? FROM DUAL");
+        ParameterMetaData pm = prep.getParameterMetaData();
+        check(pm.getParameterClassName(1), "java.lang.String");
+        check(pm.getParameterTypeName(1), "VARCHAR");
+        check(pm.getParameterCount(), 3);
+        check(pm.getParameterMode(1), ParameterMetaData.parameterModeIn);
+        check(pm.getParameterType(1), Types.VARCHAR);
+        check(pm.getPrecision(1) , 0);
+        check(pm.getScale(1) , 0);
+        check(pm.isNullable(1), ResultSetMetaData.columnNullableUnknown);
+        check(pm.isSigned(1), true);
+        try {
+            pm.getPrecision(0);
+            error("should fail");
+        } catch(SQLException e) {
+            // ok
+        }
+        try {
+            pm.getPrecision(4);
+            error("should fail");
+        } catch(SQLException e) {
+            // ok
+        }
+        prep.close();
+        try {
+            pm.getPrecision(1);
+            error("should fail");
+        } catch(SQLException e) {
+            // ok
+        }
+    }
+    
+    private void testLikeIndex(Connection conn) throws Exception {
+        Statement stat = conn.createStatement();
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))");
+        stat.execute("INSERT INTO TEST VALUES(1, 'Hello')");
+        stat.execute("INSERT INTO TEST VALUES(2, 'World')");
+        stat.execute("create index idxname on test(name);");
+        PreparedStatement prep, prepExe;
+        
+        prep = conn.prepareStatement("EXPLAIN SELECT * FROM TEST WHERE NAME LIKE ?");
+        check(prep.getParameterMetaData().getParameterCount(), 1);
+        prepExe = conn.prepareStatement("SELECT * FROM TEST WHERE NAME LIKE ?");
+        prep.setString(1, "%orld");
+        prepExe.setString(1, "%orld");
+        ResultSet rs = prep.executeQuery();
+        rs.next();
+        String plan = rs.getString(1);
+        check(plan.indexOf("TABLE_SCAN") >= 0);
+        rs = prepExe.executeQuery();
+        rs.next();
+        check(rs.getString(2), "World");
+        checkFalse(rs.next());
+
+        prep.setString(1, "H%");
+        prepExe.setString(1, "H%");
+        rs = prep.executeQuery();
+        rs.next();
+        String plan1 = rs.getString(1);
+        check(plan1.indexOf("IDXNAME") >= 0);
+        rs = prepExe.executeQuery();
+        rs.next();
+        check(rs.getString(2), "Hello");
+        checkFalse(rs.next());
+        
+        stat.execute("DROP TABLE IF EXISTS TEST");
+    }
+    
+    private void testCasewhen(Connection conn) throws Exception {
+        Statement stat = conn.createStatement();
+        stat.execute("CREATE TABLE TEST(ID INT)");
+        stat.execute("INSERT INTO TEST VALUES(1),(2),(3)");
+        PreparedStatement prep;
+        ResultSet rs;
+        prep = conn.prepareStatement(
+                "EXPLAIN SELECT COUNT(*) FROM TEST WHERE CASEWHEN(ID=1, ID, ID)=? GROUP BY ID"
+        );
+        prep.setInt(1, 1);
+        rs = prep.executeQuery();
+        rs.next();
+        String plan = rs.getString(1);
+        trace(plan);
+        rs.close();
+        prep = conn.prepareStatement(
+                "EXPLAIN SELECT COUNT(*) FROM TEST WHERE CASE ID WHEN 1 THEN ID WHEN 2 THEN ID ELSE ID END=? GROUP BY ID"
+        );
+        prep.setInt(1, 1);
+        rs = prep.executeQuery();
+        rs.next();
+        plan = rs.getString(1);
+        trace(plan);
+        
+        
+        prep = conn.prepareStatement(
+                "SELECT COUNT(*) FROM TEST WHERE CASEWHEN(ID=1, ID, ID)=? GROUP BY ID"
+        );
+        prep.setInt(1, 1);
+        rs = prep.executeQuery();
+        check(rs.next());
+        check(rs.getInt(1), 1);
+        checkFalse(rs.next());
+        
+        prep = conn.prepareStatement(
+                "SELECT COUNT(*) FROM TEST WHERE CASE ID WHEN 1 THEN ID WHEN 2 THEN ID ELSE ID END=? GROUP BY ID"
+        );
+        prep.setInt(1, 1);
+        rs = prep.executeQuery();
+        check(rs.next());
+        check(rs.getInt(1), 1);
+        checkFalse(rs.next());
+        
+        prep = conn.prepareStatement("SELECT * FROM TEST WHERE ? IS NULL");
+        prep.setString(1, "Hello");
+        rs = prep.executeQuery();
+        checkFalse(rs.next());
+        try {
+            prep = conn.prepareStatement("select ? from dual union select ? from dual");
+            error("expected error");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+            // ok
+        }
+        prep = conn.prepareStatement("select cast(? as varchar) from dual union select ? from dual");
+        check(prep.getParameterMetaData().getParameterCount(), 2);
+        prep.setString(1, "a");
+        prep.setString(2, "a");
+        rs = prep.executeQuery();
+        rs.next();
+        check(rs.getString(1), "a");
+        check(rs.getString(1), "a");
+        checkFalse(rs.next());
+        
+        stat.execute("DROP TABLE TEST");
+    }
+
+    private void testSubquery(Connection conn) throws Exception {
+        Statement stat = conn.createStatement();
+        stat.execute("CREATE TABLE TEST(ID INT)");
+        stat.execute("INSERT INTO TEST VALUES(1),(2),(3)");
+        PreparedStatement prep = conn.prepareStatement(
+                "select x.id, ? from "
+              + "(select * from test where id in(?, ?)) x "
+              + "where x.id*2 <>  ?");
+        check(prep.getParameterMetaData().getParameterCount(), 4);
+        prep.setInt(1, 0);
+        prep.setInt(2, 1);
+        prep.setInt(3, 2);
+        prep.setInt(4, 4);
+        ResultSet rs = prep.executeQuery();
+        rs.next();
+        check(rs.getInt(1), 1);
+        check(rs.getInt(2), 0);
+        checkFalse(rs.next());
+        stat.execute("DROP TABLE TEST");
+    }
+    
+    private void testDataTypes(Connection conn) throws Exception {
+        conn.createStatement(ResultSet.TYPE_FORWARD_ONLY,ResultSet.CONCUR_READ_ONLY);
+        conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
+        Statement stat=conn.createStatement();
+        PreparedStatement prep;
+        ResultSet rs;
+        trace("Create tables");
+        stat.execute("CREATE TABLE T_INT(ID INT PRIMARY KEY,VALUE INT)");
+        stat.execute("CREATE TABLE T_VARCHAR(ID INT PRIMARY KEY,VALUE VARCHAR(255))");
+        stat.execute("CREATE TABLE T_DECIMAL_0(ID INT PRIMARY KEY,VALUE DECIMAL(30,0))");
+        stat.execute("CREATE TABLE T_DECIMAL_10(ID INT PRIMARY KEY,VALUE DECIMAL(20,10))");
+        stat.execute("CREATE TABLE T_DATETIME(ID INT PRIMARY KEY,VALUE DATETIME)");
+        prep=conn.prepareStatement("INSERT INTO T_INT VALUES(?,?)", ResultSet.TYPE_FORWARD_ONLY,ResultSet.CONCUR_READ_ONLY);
+        prep.setInt(1,1);
+        prep.setInt(2,0);
+        prep.executeUpdate();
+        prep.setInt(1,2);
+        prep.setInt(2,-1);
+        prep.executeUpdate();
+        prep.setInt(1,3);
+        prep.setInt(2,3);
+        prep.executeUpdate();
+        prep.setInt(1,4);
+        prep.setNull(2,Types.INTEGER);
+        prep.executeUpdate();
+        prep.setInt(1,5);
+        prep.setBigDecimal(2,new java.math.BigDecimal("0"));
+        prep.executeUpdate();
+        prep.setInt(1,6);
+        prep.setString(2,"-1");
+        prep.executeUpdate();
+        prep.setInt(1,7);
+        prep.setObject(2,new Integer(3));
+        prep.executeUpdate();
+        prep.setObject(1,"8");
+        // should throw an exception
+        prep.setObject(2,null);
+        // some databases don't allow calling setObject with null (no data type)
+        prep.executeUpdate();
+        prep.setInt(1,9);
+        prep.setObject(2,new Integer(-4),Types.VARCHAR);
+        prep.executeUpdate();
+        prep.setInt(1,10);
+        prep.setObject(2,"5",Types.INTEGER);
+        prep.executeUpdate();
+        prep.setInt(1,11);
+        prep.setObject(2,null,Types.INTEGER);
+        prep.executeUpdate();
+        prep.setInt(1,12);
+        prep.setBoolean(2,true);
+        prep.executeUpdate();
+        prep.setInt(1,13);
+        prep.setBoolean(2,false);
+        prep.executeUpdate();
+        prep.setInt(1,14);
+        prep.setByte(2,(byte)-20);
+        prep.executeUpdate();
+        prep.setInt(1,15);
+        prep.setByte(2,(byte)100);
+        prep.executeUpdate();
+        prep.setInt(1,16);
+        prep.setShort(2,(short)30000);
+        prep.executeUpdate();
+        prep.setInt(1,17);
+        prep.setShort(2,(short)(-30000));
+        prep.executeUpdate();
+        prep.setInt(1,18);
+        prep.setLong(2,Integer.MAX_VALUE);
+        prep.executeUpdate();
+        prep.setInt(1,19);
+        prep.setLong(2,Integer.MIN_VALUE);
+        prep.executeUpdate();
+
+        check(stat.execute("SELECT * FROM T_INT ORDER BY ID"));
+        rs=stat.getResultSet();
+        testResultSetOrdered(rs,new String[][]{
+        {"1","0"},{"2","-1"},{"3","3"},{"4",null},{"5","0"},{"6","-1"},
+        {"7","3"},{"8",null},{"9","-4"},{"10","5"},{"11",null},{"12","1"},{"13","0"},
+        {"14","-20"},{"15","100"},{"16","30000"},{"17","-30000"},
+        {"18",""+Integer.MAX_VALUE},{"19",""+Integer.MIN_VALUE},
+        });
+
+        prep=conn.prepareStatement("INSERT INTO T_DECIMAL_0 VALUES(?,?)");
+        prep.setInt(1,1);
+        prep.setLong(2,Long.MAX_VALUE);
+        prep.executeUpdate();
+        prep.setInt(1,2);
+        prep.setLong(2,Long.MIN_VALUE);
+        prep.executeUpdate();
+        prep.setInt(1,3);
+        prep.setFloat(2,10);
+        prep.executeUpdate();
+        prep.setInt(1,4);
+        prep.setFloat(2,-20);
+        prep.executeUpdate();
+        prep.setInt(1,5);
+        prep.setFloat(2,30);
+        prep.executeUpdate();
+        prep.setInt(1,6);
+        prep.setFloat(2,-40);
+        prep.executeUpdate();
+        
+        rs=stat.executeQuery("SELECT VALUE FROM T_DECIMAL_0 ORDER BY ID");        
+        checkBigDecimal(rs,new String[]{
+        ""+Long.MAX_VALUE,""+Long.MIN_VALUE,
+        "10","-20","30","-40"
+        });
+
+        // getMoreResults
+        stat.execute("CREATE TABLE TEST(ID INT)");
+        stat.execute("INSERT INTO TEST VALUES(1)");
+        prep=conn.prepareStatement("SELECT * FROM TEST");
+        // just to check if it doesn't throw an exception - it may be null
+        prep.getMetaData();
+        check(prep.execute());
+        rs=prep.getResultSet();
+        checkFalse(prep.getMoreResults());
+        try {
+            // supposed to be closed now
+            rs.next();
+            error("getMoreResults didn't close this result set");
+        } catch(SQLException e) {
+            trace("no error - getMoreResults is supposed to close the result set");
+        }
+        check(prep.getUpdateCount()==-1);
+        prep=conn.prepareStatement("DELETE FROM TEST");
+        prep.executeUpdate();
+        checkFalse(prep.getMoreResults());
+        check(prep.getUpdateCount()==-1);
+    }
+    
+    private void testObject(Connection conn) throws Exception {
+        Statement stat = conn.createStatement();
+        ResultSet rs;
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))");
+        stat.execute("INSERT INTO TEST VALUES(1, 'Hello')");
+        PreparedStatement prep = conn.prepareStatement("SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? FROM TEST");
+        prep.setObject(1, new Boolean(true));
+        prep.setObject(2, "Abc");
+        prep.setObject(3, new BigDecimal("10.2"));
+        prep.setObject(4, new Byte((byte)0xff));
+        prep.setObject(5, new Short(Short.MAX_VALUE));
+        prep.setObject(6, new Integer(Integer.MIN_VALUE));
+        prep.setObject(7, new Long(Long.MAX_VALUE));
+        prep.setObject(8, new Float(Float.MAX_VALUE));
+        prep.setObject(9, new Double(Double.MAX_VALUE));
+        prep.setObject(10, java.sql.Date.valueOf("2001-02-03"));
+        prep.setObject(11, java.sql.Time.valueOf("04:05:06"));
+        prep.setObject(12, java.sql.Timestamp.valueOf("2001-02-03 04:05:06.123456789"));
+        prep.setObject(13, new java.util.Date(java.sql.Date.valueOf("2001-02-03").getTime()));
+        prep.setObject(14, new byte[]{10, 20, 30});
+        prep.setObject(15, new Character('a'));
+        prep.setObject(16, "2001-01-02", Types.DATE);
+        // converting to null seems strange...
+        prep.setObject(17, "2001-01-02", Types.NULL);
+        prep.setObject(18, "3.725", Types.DOUBLE);
+        prep.setObject(19, "23:22:21", Types.TIME);
+        prep.setObject(20, new java.math.BigInteger("12345"), Types.OTHER);
+        rs = prep.executeQuery();
+        rs.next();
+        check(rs.getObject(1).equals(new Boolean(true)));
+        check(rs.getObject(2).equals("Abc"));
+        check(rs.getObject(3).equals(new BigDecimal("10.2")));
+        check(rs.getObject(4).equals(new Byte((byte)0xff)));
+        check(rs.getObject(5).equals(new Short(Short.MAX_VALUE)));
+        check(rs.getObject(6).equals(new Integer(Integer.MIN_VALUE)));
+        check(rs.getObject(7).equals(new Long(Long.MAX_VALUE)));
+        check(rs.getObject(8).equals(new Float(Float.MAX_VALUE)));
+        check(rs.getObject(9).equals(new Double(Double.MAX_VALUE)));
+        check(rs.getObject(10).equals(java.sql.Date.valueOf("2001-02-03")));
+        check(rs.getObject(11).toString(), "04:05:06");
+        check(rs.getObject(11).equals(java.sql.Time.valueOf("04:05:06")));
+        check(rs.getObject(12).equals(java.sql.Timestamp.valueOf("2001-02-03 04:05:06.123456789")));
+        check(rs.getObject(13).equals(java.sql.Date.valueOf("2001-02-03")));
+        check((byte[])rs.getObject(14), new byte[]{10, 20, 30});
+        check(rs.getObject(15).equals(new Character('a')));
+        check(rs.getObject(16).equals(java.sql.Date.valueOf("2001-01-02")));
+        check(rs.getObject(17) == null && rs.wasNull());
+        check(rs.getObject(18).equals(new Double(3.725)));
+        check(rs.getObject(19).equals(java.sql.Time.valueOf("23:22:21")));
+        check(rs.getObject(20).equals(new java.math.BigInteger("12345")));
+        
+        
+//        } else if(x instanceof java.io.Reader) {
+//            return session.createLob(Value.CLOB, TypeConverter.getInputStream((java.io.Reader)x), 0);
+//        } else if(x instanceof java.io.InputStream) {
+//            return session.createLob(Value.BLOB, (java.io.InputStream)x, 0);
+//        } else {
+//            return ValueBytes.get(TypeConverter.serialize(x));
+        
+        
+        stat.execute("DROP TABLE TEST");
+        
+    }
+    
+    private void testIdentity(Connection conn) throws Exception {
+        Statement stat = conn.createStatement();
+        stat.execute("CREATE SEQUENCE SEQ");
+        stat.execute("CREATE TABLE TEST(ID INT)");
+        PreparedStatement prep;
+        prep = conn.prepareStatement("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)");
+        prep.execute();
+        ResultSet rs = prep.getGeneratedKeys();
+        rs.next();
+        check(rs.getInt(1), 1);
+        checkFalse(rs.next());
+        prep = conn.prepareStatement("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", Statement.RETURN_GENERATED_KEYS);
+        prep.execute();
+        rs = prep.getGeneratedKeys();
+        rs.next();
+        check(rs.getInt(1), 2);        
+        checkFalse(rs.next());
+        prep = conn.prepareStatement("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", new int[]{1});
+        prep.execute();
+        rs = prep.getGeneratedKeys();
+        rs.next();
+        check(rs.getInt(1), 3);        
+        checkFalse(rs.next());
+        prep = conn.prepareStatement("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", new String[]{"ID"});
+        prep.execute();
+        rs = prep.getGeneratedKeys();
+        rs.next();
+        check(rs.getInt(1), 4);        
+        checkFalse(rs.next());
+        stat.execute("DROP TABLE TEST");
+    }
+    
+    int getLength() throws Exception {
+        return getSize(LOB_SIZE, LOB_SIZE_BIG);
+    }
+
+    void testBlob(Connection conn) throws Exception {
+        trace("testBlob");
+        Statement stat=conn.createStatement();
+        PreparedStatement prep;
+        ResultSet rs;
+        stat.execute("CREATE TABLE T_BLOB(ID INT PRIMARY KEY,V1 BLOB,V2 BLOB)");
+        trace("table created");
+        prep=conn.prepareStatement("INSERT INTO T_BLOB VALUES(?,?,?)");
+        
+        prep.setInt(1,1);
+        prep.setBytes(2,null);
+        prep.setNull(3,Types.BINARY);
+        prep.executeUpdate();
+        
+        prep.setInt(1,2);
+        prep.setBinaryStream(2,null,0);
+        prep.setNull(3,Types.BLOB);
+        prep.executeUpdate();
+        
+        int length = getLength();
+        byte[] big1=new byte[length];
+        byte[] big2=new byte[length];
+        for(int i=0;i<big1.length;i++) {
+            big1[i]=(byte)((i*11)%254);
+            big2[i]=(byte)((i*17)%251);
+        }
+        
+        prep.setInt(1,3);
+        prep.setBytes(2,big1);
+        prep.setBytes(3,big2);
+        prep.executeUpdate();
+        
+        prep.setInt(1,4);
+        ByteArrayInputStream buffer;
+        buffer=new ByteArrayInputStream(big2);
+        prep.setBinaryStream(2,buffer,big2.length);
+        buffer=new ByteArrayInputStream(big1);
+        prep.setBinaryStream(3,buffer,big1.length);
+        prep.executeUpdate();
+        try {
+            buffer.close();
+            trace("buffer not closed");
+        } catch(IOException e) {
+            trace("buffer closed");
+        }
+
+        prep.setInt(1,5);
+        buffer=new ByteArrayInputStream(big2);
+        prep.setObject(2,buffer, Types.BLOB, 0);
+        buffer=new ByteArrayInputStream(big1);
+        prep.setObject(3,buffer);
+        prep.executeUpdate();
+
+        rs=stat.executeQuery("SELECT ID, V1, V2 FROM T_BLOB ORDER BY ID");
+
+        rs.next();
+        check(rs.getInt(1), 1);
+        check(rs.getBytes(2)==null && rs.wasNull());
+        check(rs.getBytes(3)==null && rs.wasNull());
+        
+        rs.next();
+        check(rs.getInt(1), 2);
+        check(rs.getBytes(2)==null && rs.wasNull());
+        check(rs.getBytes(3)==null && rs.wasNull());
+
+        rs.next();
+        check(rs.getInt(1), 3);
+        check(rs.getBytes(2),big1);
+        check(rs.getBytes(3),big2);
+        
+        rs.next();
+        check(rs.getInt(1), 4);
+        check(rs.getBytes(2),big2);
+        check(rs.getBytes(3),big1);
+        
+        rs.next();
+        check(rs.getInt(1), 5);
+        check(rs.getBytes(2),big2);
+        check(rs.getBytes(3),big1);
+
+        checkFalse(rs.next());        
+    }
+    
+    void testClob(Connection conn) throws Exception {
+        trace("testClob");
+        Statement stat=conn.createStatement();
+        PreparedStatement prep;
+        ResultSet rs;
+        stat.execute("CREATE TABLE T_CLOB(ID INT PRIMARY KEY,V1 CLOB,V2 CLOB)");
+        StringBuffer asciibuffer=new StringBuffer();
+        int len = getLength();
+        for(int i=0;i<len;i++) {
+            asciibuffer.append((char)('a'+(i%20)));
+        }
+        String ascii1=asciibuffer.toString();
+        String ascii2="Number2 "+ascii1;
+        prep=conn.prepareStatement("INSERT INTO T_CLOB VALUES(?,?,?)");
+        
+        prep.setInt(1,1);
+        prep.setString(2,null);
+        prep.setNull(3,Types.CLOB);
+        prep.executeUpdate();
+        
+        prep.clearParameters();
+        prep.setInt(1,2);
+        prep.setAsciiStream(2,null,0);
+        prep.setCharacterStream(3,null,0);
+        prep.executeUpdate();
+        
+        prep.clearParameters();
+        prep.setInt(1,3);
+        prep.setCharacterStream(2, new StringReader(ascii1), ascii1.length());
+        prep.setCharacterStream(3, null, 0);
+        prep.setAsciiStream(3, new ByteArrayInputStream(ascii2.getBytes()), ascii2.length());
+        prep.executeUpdate();
+        
+        prep.clearParameters();
+        prep.setInt(1,4);
+        prep.setNull(2, Types.CLOB);
+        prep.setString(2,ascii2);
+        prep.setCharacterStream(3,null,0);
+        prep.setNull(3,Types.CLOB);
+        prep.setString(3,ascii1);
+        prep.executeUpdate();
+
+        prep.clearParameters();
+        prep.setInt(1,5);
+        prep.setObject(2, new StringReader(ascii1));
+        prep.setObject(3, new StringReader(ascii2), Types.CLOB, 0);
+        prep.executeUpdate();
+
+        rs=stat.executeQuery("SELECT ID, V1, V2 FROM T_CLOB ORDER BY ID");
+
+        rs.next();
+        check(rs.getInt(1), 1);
+        check(rs.getCharacterStream(2)==null && rs.wasNull());
+        check(rs.getAsciiStream(3)==null && rs.wasNull());
+        
+        rs.next();
+        check(rs.getInt(1), 2);
+        check(rs.getString(2)==null && rs.wasNull());
+        check(rs.getString(3)==null && rs.wasNull());
+        
+        rs.next();
+        check(rs.getInt(1), 3);
+        check(rs.getString(2), ascii1);
+        check(rs.getString(3), ascii2);
+
+        rs.next();
+        check(rs.getInt(1), 4);
+        check(rs.getString(2), ascii2);
+        check(rs.getString(3), ascii1);
+
+        rs.next();
+        check(rs.getInt(1), 5);
+        check(rs.getString(2), ascii1);
+        check(rs.getString(3), ascii2);
+
+        checkFalse(rs.next());      
+        check(prep.getWarnings()==null);
+        prep.clearWarnings();
+        check(prep.getWarnings()==null);
+        check(conn==prep.getConnection());
+    }
+    
+    void checkBigDecimal(ResultSet rs,String[] value) throws Exception {
+        for(int i=0;i<value.length;i++) {
+            String v=value[i];
+            check(rs.next());
+            java.math.BigDecimal x=rs.getBigDecimal(1);
+            trace("v="+v+" x="+x);
+            if(v==null) {
+                check(x==null);
+            } else {
+                check(x.compareTo(new java.math.BigDecimal(v))==0);
+            }
+        }
+        check(!rs.next());
+    }
+
+}

h2/src/test/org/h2/test/jdbc/TestResultSet.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.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.math.BigDecimal;
+import java.sql.Connection;
+import java.sql.Date;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.sql.Types;
+import java.util.Calendar;
+import java.util.TimeZone;
+
+import org.h2.test.TestBase;
+
+public class TestResultSet extends TestBase {
+    Connection conn;
+    Statement stat;
+
+    public void test() throws Exception {
+        deleteDb("resultset");
+        conn = getConnection("resultset");
+
+        stat=conn.createStatement();
+
+        testLimitMaxRows();
+
+        trace("max rows="+stat.getMaxRows());
+        stat.setMaxRows(6);
+        trace("max rows after set to 6="+stat.getMaxRows());
+        check(stat.getMaxRows()==6);
+
+        testInt();
+        testVarchar();
+        testDecimal();
+        testDoubleFloat();
+        testDatetime();
+        testDatetimeWithCalendar();
+        testBlob();
+        testClob();
+
+        testAutoIncrement();
+
+        conn.close();
+
+    }
+
+    private void testLimitMaxRows() throws Exception {
+        trace("Test LimitMaxRows");
+        ResultSet rs;
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY)");
+        stat.execute("INSERT INTO TEST VALUES(1), (2), (3), (4)");
+        rs = stat.executeQuery("SELECT * FROM TEST");
+        checkResultRowCount(rs, 4);
+        rs = stat.executeQuery("SELECT * FROM TEST LIMIT 2");
+        checkResultRowCount(rs, 2);
+        stat.setMaxRows(2);
+        rs = stat.executeQuery("SELECT * FROM TEST");
+        checkResultRowCount(rs, 2);
+        rs = stat.executeQuery("SELECT * FROM TEST LIMIT 1");
+        checkResultRowCount(rs, 1);
+        rs = stat.executeQuery("SELECT * FROM TEST LIMIT 3");
+        checkResultRowCount(rs, 2);
+        stat.setMaxRows(0);
+        stat.execute("DROP TABLE TEST");
+    }
+
+    void testAutoIncrement() throws Exception {
+        trace("Test AutoIncrement");
+        stat.execute("DROP TABLE IF EXISTS TEST");
+        ResultSet rs;
+        stat.execute("CREATE TABLE TEST(ID IDENTITY NOT NULL, NAME VARCHAR NULL)");
+
+        stat.execute("INSERT INTO TEST(NAME) VALUES('Hello')");
+        rs = stat.getGeneratedKeys();
+        check(rs.next());
+        check(rs.getInt(1), 1);
+
+        stat.execute("INSERT INTO TEST(NAME) VALUES('World')");
+        rs = stat.getGeneratedKeys();
+        check(rs.next());
+        check(rs.getInt(1), 2);
+
+        rs = stat.executeQuery("SELECT ID AS I, NAME AS N, ID+1 AS IP1 FROM TEST");
+        ResultSetMetaData meta = rs.getMetaData();
+        check(meta.isAutoIncrement(1));
+        checkFalse(meta.isAutoIncrement(2));
+        checkFalse(meta.isAutoIncrement(3));
+        check(meta.isNullable(1), ResultSetMetaData.columnNoNulls);
+        check(meta.isNullable(2), ResultSetMetaData.columnNullable);
+        check(meta.isNullable(3), ResultSetMetaData.columnNullableUnknown);
+        check(rs.next());
+        check(rs.next());
+        checkFalse(rs.next());
+
+    }
+
+    void testInt() throws Exception {
+        trace("Test INT");
+        ResultSet rs;
+        Object o;
+
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY,VALUE INT)");
+        stat.execute("INSERT INTO TEST VALUES(1,-1)");
+        stat.execute("INSERT INTO TEST VALUES(2,0)");
+        stat.execute("INSERT INTO TEST VALUES(3,1)");
+        stat.execute("INSERT INTO TEST VALUES(4,"+Integer.MAX_VALUE+")");
+        stat.execute("INSERT INTO TEST VALUES(5,"+Integer.MIN_VALUE+")");
+        stat.execute("INSERT INTO TEST VALUES(6,NULL)");
+        // this should not be read - maxrows=6
+        stat.execute("INSERT INTO TEST VALUES(7,NULL)");
+
+        // MySQL compatibility (is this required?)
+//        rs=stat.executeQuery("SELECT * FROM TEST T ORDER BY ID");
+//        check(rs.findColumn("T.ID"), 1);
+//        check(rs.findColumn("T.NAME"), 2);
+
+        rs=stat.executeQuery("SELECT *, NULL AS N FROM TEST ORDER BY ID");
+
+        // MySQL compatibility
+        check(rs.findColumn("TEST.ID"), 1);
+        check(rs.findColumn("TEST.VALUE"), 2);
+
+        ResultSetMetaData meta = rs.getMetaData();
+        check(meta.getColumnCount(), 3);
+        check(meta.getCatalogName(1), "RESULTSET");
+        check("PUBLIC".equals(meta.getSchemaName(2)));
+        check("TEST".equals(meta.getTableName(1)));
+        check("ID".equals(meta.getColumnName(1)));
+        check("VALUE".equals(meta.getColumnName(2)));
+        check(meta.isAutoIncrement(1)==false);
+        check(meta.isCaseSensitive(1));
+        check(meta.isSearchable(1));
+        checkFalse(meta.isCurrency(1));
+        check(meta.getColumnDisplaySize(1)>0);
+        check(meta.isSigned(1));
+        check(meta.isSearchable(2));
+        check(meta.isNullable(1), ResultSetMetaData.columnNoNulls);
+        checkFalse(meta.isReadOnly(1));
+        check(meta.isWritable(1));
+        checkFalse(meta.isDefinitelyWritable(1));
+        check(meta.getColumnDisplaySize(1)>0);
+        check(meta.getColumnDisplaySize(2)>0);
+        check(meta.getColumnClassName(3), null);
+
+        check(rs.getRow()==0);
+        testResultSetMeta(rs,3,
+            new String[]{"ID", "VALUE", "N"},
+            new int[]{Types.INTEGER,Types.INTEGER, Types.NULL},
+            new int[]{10,10,1},
+            new int[]{0,0,0}
+            );
+        rs.next();
+        check(rs.getConcurrency(), ResultSet.CONCUR_READ_ONLY);
+        check(rs.getFetchDirection(), ResultSet.FETCH_FORWARD);
+        trace("default fetch size="+rs.getFetchSize());
+        // 0 should be an allowed value (but it's not defined what is actually means)
+        rs.setFetchSize(0);
+        trace("after set to 0, fetch size="+rs.getFetchSize());
+        // this should break
+        try {
+            rs.setFetchSize(-1);
+            error("fetch size -1 is not allowed");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+            trace(e.toString());
+        }
+        trace("after try to set to -1, fetch size="+rs.getFetchSize());
+        try {
+            rs.setFetchSize(100);
+            error("fetch size 100 is bigger than maxrows - not allowed");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+            trace(e.toString());
+        }
+        trace("after try set to 100, fetch size="+rs.getFetchSize());
+        rs.setFetchSize(6);
+
+        check(rs.getRow()==1);
+        check(rs.findColumn("VALUE"), 2);
+        check(rs.findColumn("value"), 2);
+        check(rs.findColumn("Value"), 2);
+        check(rs.findColumn("Value"), 2);
+        check(rs.findColumn("ID"), 1);
+        check(rs.findColumn("id"), 1);
+        check(rs.findColumn("Id"), 1);
+        check(rs.findColumn("iD"), 1);
+        check(rs.getInt(2)==-1 && rs.wasNull()==false);
+        check(rs.getInt("VALUE")==-1 && rs.wasNull()==false);
+        check(rs.getInt("value")==-1 && rs.wasNull()==false);
+        check(rs.getInt("Value")==-1 && rs.wasNull()==false);
+        check(rs.getString("Value").equals("-1") && rs.wasNull()==false);
+
+        o=rs.getObject("value");
+        trace(o.getClass().getName());
+        check(o instanceof Integer);
+        check(((Integer)o).intValue()==-1);
+        o=rs.getObject(2);
+        trace(o.getClass().getName());
+        check(o instanceof Integer);
+        check(((Integer)o).intValue()==-1);
+        check(rs.getBoolean("Value")==true);
+        check(rs.getByte("Value")==(byte)-1);
+        check(rs.getShort("Value")==(short)-1);
+        check(rs.getLong("Value")==-1);
+        check(rs.getFloat("Value")==-1.0);
+        check(rs.getDouble("Value")==-1.0);
+
+        check(rs.getString("Value").equals("-1") && rs.wasNull()==false);
+        check(rs.getInt("ID")==1 && rs.wasNull()==false);
+        check(rs.getInt("id")==1 && rs.wasNull()==false);
+        check(rs.getInt("Id")==1 && rs.wasNull()==false);
+        check(rs.getInt(1)==1 && rs.wasNull()==false);
+        rs.next();
+        check(rs.getRow()==2);
+        check(rs.getInt(2)==0 && rs.wasNull()==false);
+        check(rs.getBoolean(2)==false);
+        check(rs.getByte(2)==0);
+        check(rs.getShort(2)==0);
+        check(rs.getLong(2)==0);
+        check(rs.getFloat(2)==0.0);
+        check(rs.getDouble(2)==0.0);
+        check(rs.getString(2).equals("0") && rs.wasNull()==false);
+        check(rs.getInt(1)==2 && rs.wasNull()==false);
+        rs.next();
+        check(rs.getRow()==3);
+        check(rs.getInt("ID")==3 && rs.wasNull()==false);
+        check(rs.getInt("VALUE")==1 && rs.wasNull()==false);
+        rs.next();
+        check(rs.getRow()==4);
+        check(rs.getInt("ID")==4 && rs.wasNull()==false);
+        check(rs.getInt("VALUE")==Integer.MAX_VALUE && rs.wasNull()==false);
+        rs.next();
+        check(rs.getRow()==5);
+        check(rs.getInt("id")==5 && rs.wasNull()==false);
+        check(rs.getInt("value")==Integer.MIN_VALUE && rs.wasNull()==false);
+        check(rs.getString(1).equals("5") && rs.wasNull()==false);
+        rs.next();
+        check(rs.getRow()==6);
+        check(rs.getInt("id")==6 && rs.wasNull()==false);
+        check(rs.getInt("value")==0 && rs.wasNull()==true);
+        check(rs.getInt(2)==0 && rs.wasNull()==true);
+        check(rs.getInt(1)==6 && rs.wasNull()==false);
+        check(rs.getString(1).equals("6") && rs.wasNull()==false);
+        check(rs.getString(2)==null && rs.wasNull()==true);
+        o=rs.getObject(2);
+        check(o==null);
+        check(rs.wasNull());
+        checkFalse(rs.next());
+        check(rs.getRow(), 0);
+        // there is one more row, but because of setMaxRows we don't get it
+
+        stat.execute("DROP TABLE TEST");
+        stat.setMaxRows(0);
+    }
+
+    void testVarchar() throws Exception {
+        trace("Test VARCHAR");
+        ResultSet rs;
+        Object o;
+
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY,VALUE VARCHAR(255))");
+        stat.execute("INSERT INTO TEST VALUES(1,'')");
+        stat.execute("INSERT INTO TEST VALUES(2,' ')");
+        stat.execute("INSERT INTO TEST VALUES(3,'  ')");
+        stat.execute("INSERT INTO TEST VALUES(4,NULL)");
+        stat.execute("INSERT INTO TEST VALUES(5,'Hi')");
+        stat.execute("INSERT INTO TEST VALUES(6,' Hi ')");
+        stat.execute("INSERT INTO TEST VALUES(7,'Joe''s')");
+        stat.execute("INSERT INTO TEST VALUES(8,'{escape}')");
+        stat.execute("INSERT INTO TEST VALUES(9,'\\n')");
+        stat.execute("INSERT INTO TEST VALUES(10,'\\''')");
+        stat.execute("INSERT INTO TEST VALUES(11,'\\%')");
+        rs=stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
+        testResultSetMeta(rs,2,
+            new String[]{"ID","VALUE"},
+            new int[]{Types.INTEGER,Types.VARCHAR},
+            new int[]{10,255},
+            new int[]{0,0}
+            );
+        String value;
+        rs.next();
+        value=rs.getString(2);
+        trace("Value: <"+value+"> (should be: <>)");
+        check(value!=null && value.equals("") && rs.wasNull()==false);
+        check(rs.getInt(1)==1 && rs.wasNull()==false);
+        rs.next();
+        value=rs.getString(2);
+        trace("Value: <"+value+"> (should be: < >)");
+        check(rs.getString(2).equals(" ") && rs.wasNull()==false);
+        check(rs.getInt(1)==2 && rs.wasNull()==false);
+        rs.next();
+        value=rs.getString(2);
+        trace("Value: <"+value+"> (should be: <  >)");
+        check(rs.getString(2).equals("  ") && rs.wasNull()==false);
+        check(rs.getInt(1)==3 && rs.wasNull()==false);
+        rs.next();
+        value=rs.getString(2);
+        trace("Value: <"+value+"> (should be: <null>)");
+        check(rs.getString(2)==null && rs.wasNull()==true);
+        check(rs.getInt(1)==4 && rs.wasNull()==false);
+        rs.next();
+        value=rs.getString(2);
+        trace("Value: <"+value+"> (should be: <Hi>)");
+        check(rs.getInt(1)==5 && rs.wasNull()==false);
+        check(rs.getString(2).equals("Hi") && rs.wasNull()==false);
+        o=rs.getObject("value");
+        trace(o.getClass().getName());
+        check(o instanceof String);
+        check(o.toString().equals("Hi"));
+        rs.next();
+        value=rs.getString(2);
+        trace("Value: <"+value+"> (should be: < Hi >)");
+        check(rs.getInt(1)==6 && rs.wasNull()==false);
+        check(rs.getString(2).equals(" Hi ") && rs.wasNull()==false);
+        rs.next();
+        value=rs.getString(2);
+        trace("Value: <"+value+"> (should be: <Joe's>)");
+        check(rs.getInt(1)==7 && rs.wasNull()==false);
+        check(rs.getString(2).equals("Joe's") && rs.wasNull()==false);
+        rs.next();
+        value=rs.getString(2);
+        trace("Value: <"+value+"> (should be: <{escape}>)");
+        check(rs.getInt(1)==8 && rs.wasNull()==false);
+        check(rs.getString(2).equals("{escape}")&& rs.wasNull()==false);
+        rs.next();
+        value=rs.getString(2);
+        trace("Value: <"+value+"> (should be: <\\n>)");
+        check(rs.getInt(1)==9 && rs.wasNull()==false);
+        check(rs.getString(2).equals("\\n") && rs.wasNull()==false);
+        rs.next();
+        value=rs.getString(2);
+        trace("Value: <"+value+"> (should be: <\\'>)");
+        check(rs.getInt(1)==10 && rs.wasNull()==false);
+        check(rs.getString(2).equals("\\'") && rs.wasNull()==false);
+        rs.next();
+        value=rs.getString(2);
+        trace("Value: <"+value+"> (should be: <\\%>)");
+        check(rs.getInt(1)==11 && rs.wasNull()==false);
+        check(rs.getString(2).equals("\\%") && rs.wasNull()==false);
+        check(rs.next()==false);
+        stat.execute("DROP TABLE TEST");
+    }
+
+    void testDecimal() throws Exception {
+        trace("Test DECIMAL");
+        ResultSet rs;
+        Object o;
+
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY,VALUE DECIMAL(10,2))");
+        stat.execute("INSERT INTO TEST VALUES(1,-1)");
+        stat.execute("INSERT INTO TEST VALUES(2,.0)");
+        stat.execute("INSERT INTO TEST VALUES(3,1.)");
+        stat.execute("INSERT INTO TEST VALUES(4,12345678.89)");
+        stat.execute("INSERT INTO TEST VALUES(6,99999999.99)");
+        stat.execute("INSERT INTO TEST VALUES(7,-99999999.99)");
+        stat.execute("INSERT INTO TEST VALUES(8,NULL)");
+        rs=stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
+        testResultSetMeta(rs,2,
+            new String[]{"ID","VALUE"},
+            new int[]{Types.INTEGER,Types.DECIMAL},
+            new int[]{10,10},
+            new int[]{0,2}
+            );
+        BigDecimal bd;
+        rs.next();
+        check(rs.getInt(1)==1);
+        check(rs.wasNull()==false);
+        check(rs.getInt(2)==-1);
+        check(rs.wasNull()==false);
+        bd=rs.getBigDecimal(2);
+        check(bd.compareTo(new BigDecimal("-1.00"))==0);
+        check(rs.wasNull()==false);
+        o=rs.getObject(2);
+        trace(o.getClass().getName());
+        check(o instanceof BigDecimal);
+        check(((BigDecimal)o).compareTo(new BigDecimal("-1.00"))==0);
+        rs.next();
+        check(rs.getInt(1)==2);
+        check(rs.wasNull()==false);
+        check(rs.getInt(2)==0);
+        check(rs.wasNull()==false);
+        bd=rs.getBigDecimal(2);
+        check(bd.compareTo(new BigDecimal("0.00"))==0);
+        check(rs.wasNull()==false);
+        rs.next();
+        checkColumnBigDecimal(rs,2,1,"1.00");
+        rs.next();
+        checkColumnBigDecimal(rs,2,12345678,"12345678.89");
+        rs.next();
+        checkColumnBigDecimal(rs,2,99999999,"99999999.99");
+        rs.next();
+        checkColumnBigDecimal(rs,2,-99999999,"-99999999.99");
+        rs.next();
+        checkColumnBigDecimal(rs,2,0,null);
+        check(rs.next()==false);
+        stat.execute("DROP TABLE TEST");
+    }
+
+    void testDoubleFloat() throws Exception {
+        trace("Test DOUBLE - FLOAT");
+        ResultSet rs;
+        Object o;
+
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, D DOUBLE, R REAL)");
+        stat.execute("INSERT INTO TEST VALUES(1, -1, -1)");
+        stat.execute("INSERT INTO TEST VALUES(2,.0, .0)");
+        stat.execute("INSERT INTO TEST VALUES(3, 1., 1.)");
+        stat.execute("INSERT INTO TEST VALUES(4, 12345678.89, 12345678.89)");
+        stat.execute("INSERT INTO TEST VALUES(6, 99999999.99, 99999999.99)");
+        stat.execute("INSERT INTO TEST VALUES(7, -99999999.99, -99999999.99)");
+        stat.execute("INSERT INTO TEST VALUES(8, NULL, NULL)");
+        rs=stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
+        testResultSetMeta(rs,3,
+            new String[]{"ID", "D", "R"},
+            new int[]{Types.INTEGER, Types.DOUBLE, Types.REAL},
+            new int[]{10, 17, 7},
+            new int[]{0, 0, 0}
+            );
+        BigDecimal bd;
+        rs.next();
+        check(rs.getInt(1)==1);
+        check(rs.wasNull()==false);
+        check(rs.getInt(2)==-1);
+        check(rs.getInt(3)==-1);
+        check(rs.wasNull()==false);
+        bd=rs.getBigDecimal(2);
+        check(bd.compareTo(new BigDecimal("-1.00"))==0);
+        check(rs.wasNull()==false);
+        o=rs.getObject(2);
+        trace(o.getClass().getName());
+        check(o instanceof Double);
+        check(((Double)o).compareTo(new Double("-1.00"))==0);
+        o=rs.getObject(3);
+        trace(o.getClass().getName());
+        check(o instanceof Float);
+        check(((Float)o).compareTo(new Float("-1.00"))==0);
+        rs.next();
+        check(rs.getInt(1)==2);
+        check(rs.wasNull()==false);
+        check(rs.getInt(2)==0);
+        check(rs.wasNull()==false);
+        check(rs.getInt(3)==0);
+        check(rs.wasNull()==false);
+        bd=rs.getBigDecimal(2);
+        check(bd.compareTo(new BigDecimal("0.00"))==0);
+        check(rs.wasNull()==false);
+        bd=rs.getBigDecimal(3);
+        check(bd.compareTo(new BigDecimal("0.00"))==0);
+        check(rs.wasNull()==false);
+        rs.next();
+        check(rs.getDouble(2), 1.0);
+        check(rs.getFloat(3), 1.0f);
+        rs.next();
+        check(rs.getDouble(2), 12345678.89);
+        check(rs.getFloat(3), 12345678.89f);
+        rs.next();
+        check(rs.getDouble(2), 99999999.99);
+        check(rs.getFloat(3), 99999999.99f);
+        rs.next();
+        check(rs.getDouble(2), -99999999.99);
+        check(rs.getFloat(3), -99999999.99f);
+        rs.next();
+        checkColumnBigDecimal(rs,2,0,null);
+        checkColumnBigDecimal(rs,3,0,null);
+        check(rs.next()==false);
+        stat.execute("DROP TABLE TEST");
+    }
+
+    void testDatetime() throws Exception {
+        trace("Test DATETIME");
+        ResultSet rs;
+        Object o;
+
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY,VALUE DATETIME)");
+        stat.execute("INSERT INTO TEST VALUES(1,DATE '2011-11-11')");
+        stat.execute("INSERT INTO TEST VALUES(2,TIMESTAMP '2002-02-02 02:02:02')");
+        stat.execute("INSERT INTO TEST VALUES(3,TIMESTAMP '1800-1-1 0:0:0')");
+        stat.execute("INSERT INTO TEST VALUES(4,TIMESTAMP '9999-12-31 23:59:59')");
+        stat.execute("INSERT INTO TEST VALUES(5,NULL)");
+        rs=stat.executeQuery("SELECT 0 ID, TIMESTAMP '9999-12-31 23:59:59' VALUE FROM TEST ORDER BY ID");
+        testResultSetMeta(rs,2,
+            new String[]{"ID","VALUE"},
+            new int[]{Types.INTEGER,Types.TIMESTAMP},
+            new int[]{10,23},
+            new int[]{0,10}
+        );
+        rs=stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
+        testResultSetMeta(rs,2,
+            new String[]{"ID","VALUE"},
+            new int[]{Types.INTEGER,Types.TIMESTAMP},
+            new int[]{10,23},
+            new int[]{0,10}
+        );
+        rs.next();
+        java.sql.Date date;
+        java.sql.Time time;
+        java.sql.Timestamp ts;
+        date=rs.getDate(2);
+        check(!rs.wasNull());
+        time=rs.getTime(2);
+        check(!rs.wasNull());
+        ts=rs.getTimestamp(2);
+        check(!rs.wasNull());
+        trace("Date: "+date.toString()+" Time:"+time.toString()+" Timestamp:"+ts.toString());
+        trace("Date ms: "+date.getTime()+" Time ms:"+time.getTime()+" Timestamp ms:"+ts.getTime());
+        trace("1970 ms: "+java.sql.Timestamp.valueOf("1970-01-01 00:00:00.0").getTime());
+        check(date.getTime(), java.sql.Timestamp.valueOf("2011-11-11 00:00:00.0").getTime());
+        check(time.getTime(), java.sql.Timestamp.valueOf("1970-01-01 00:00:00.0").getTime());
+        check(ts.getTime(), java.sql.Timestamp.valueOf("2011-11-11 00:00:00.0").getTime());
+        check(date.equals(java.sql.Timestamp.valueOf("2011-11-11 00:00:00.0")));
+        check(time.equals(java.sql.Timestamp.valueOf("1970-01-01 00:00:00.0")));
+        check(ts.equals(java.sql.Timestamp.valueOf("2011-11-11 00:00:00.0")));
+        checkFalse(rs.wasNull());
+        o=rs.getObject(2);
+        trace(o.getClass().getName());
+        check(o instanceof java.sql.Timestamp);
+        check(((java.sql.Timestamp)o).equals(java.sql.Timestamp.valueOf("2011-11-11 00:00:00.0")));
+        checkFalse(rs.wasNull());
+        rs.next();
+
+        date=rs.getDate("VALUE");
+        check(!rs.wasNull());
+        time=rs.getTime("VALUE");
+        check(!rs.wasNull());
+        ts=rs.getTimestamp("VALUE");
+        check(!rs.wasNull());
+        trace("Date: "+date.toString()+" Time:"+time.toString()+" Timestamp:"+ts.toString());
+        check(date.toString(), "2002-02-02");
+        check(time.toString(), "02:02:02");
+        check(ts.toString(), "2002-02-02 02:02:02.0");
+        rs.next();
+        check(rs.getDate("value").toString(), "1800-01-01");
+        check(rs.getTime("value").toString(), "00:00:00");
+        check(rs.getTimestamp("value").toString(), "1800-01-01 00:00:00.0");
+        rs.next();
+        check(rs.getDate("Value").toString(), "9999-12-31");
+        check(rs.getTime("Value").toString(), "23:59:59");
+        check(rs.getTimestamp("Value").toString(), "9999-12-31 23:59:59.0");
+        rs.next();
+        check(rs.getDate("Value")==null && rs.wasNull());
+        check(rs.getTime("vALUe")==null && rs.wasNull());
+        check(rs.getTimestamp(2)==null && rs.wasNull());
+        check(rs.next()==false);
+
+        rs = stat.executeQuery("SELECT DATE '2001-02-03' D, TIME '14:15:16', TIMESTAMP '2007-08-09 10:11:12.141516171' TS FROM TEST");
+        rs.next();
+        date = (Date) rs.getObject(1);
+        time = (Time) rs.getObject(2);
+        ts = (Timestamp)rs.getObject(3);
+        check(date.toString(), "2001-02-03");
+        check(time.toString(), "14:15:16");
+        check(ts.toString(), "2007-08-09 10:11:12.141516171");
+
+        stat.execute("DROP TABLE TEST");
+    }
+
+    void testDatetimeWithCalendar() throws Exception {
+        trace("Test DATETIME with Calendar");
+        ResultSet rs;
+
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, D DATE, T TIME, TS TIMESTAMP)");
+        PreparedStatement prep = conn.prepareStatement("INSERT INTO TEST VALUES(?, ?, ?, ?)");
+        Calendar regular = Calendar.getInstance();
+        Calendar other = null;
+        String[] timezones = TimeZone.getAvailableIDs();
+        // search a locale that has a _different_ raw offset
+        for(int i=0; i<timezones.length; i++) {
+            TimeZone zone = TimeZone.getTimeZone(timezones[i]);
+            if(regular.getTimeZone().getRawOffset() != zone.getRawOffset()) {
+                other = Calendar.getInstance(zone);
+                break;
+            }
+        }
+        trace("regular offset = "+regular.getTimeZone().getRawOffset()+" other = "+other.getTimeZone().getRawOffset());
+
+        prep.setInt(1, 0);
+        prep.setDate(2, null, regular);
+        prep.setTime(3, null, regular);
+        prep.setTimestamp(4, null, regular);
+        prep.execute();
+
+        prep.setInt(1, 1);
+        prep.setDate(2, null, other);
+        prep.setTime(3, null, other);
+        prep.setTimestamp(4, null, other);
+        prep.execute();
+
+        prep.setInt(1, 2);
+        prep.setDate(2, java.sql.Date.valueOf("2001-02-03"), regular);
+        prep.setTime(3, java.sql.Time.valueOf("04:05:06"), regular);
+        prep.setTimestamp(4, java.sql.Timestamp.valueOf("2007-08-09 10:11:12.131415"), regular);
+        prep.execute();
+
+        prep.setInt(1, 3);
+        prep.setDate(2, java.sql.Date.valueOf("2101-02-03"), other);
+        prep.setTime(3, java.sql.Time.valueOf("14:05:06"), other);
+        prep.setTimestamp(4, java.sql.Timestamp.valueOf("2107-08-09 10:11:12.131415"), other);
+        prep.execute();
+
+        prep.setInt(1, 4);
+        prep.setDate(2, java.sql.Date.valueOf("2101-02-03"));
+        prep.setTime(3, java.sql.Time.valueOf("14:05:06"));
+        prep.setTimestamp(4, java.sql.Timestamp.valueOf("2107-08-09 10:11:12.131415"));
+        prep.execute();
+
+        rs=stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
+        testResultSetMeta(rs,4,
+            new String[]{"ID", "D", "T", "TS"},
+            new int[]{Types.INTEGER, Types.DATE, Types.TIME, Types.TIMESTAMP},
+            new int[]{10,8,6,23},
+            new int[]{0,0,0,10}
+        );
+
+        rs.next();
+        check(rs.getInt(1), 0);
+        check(rs.getDate(2, regular)==null && rs.wasNull());
+        check(rs.getTime(3, regular)==null && rs.wasNull());
+        check(rs.getTimestamp(3, regular)==null && rs.wasNull());
+
+        rs.next();
+        check(rs.getInt(1), 1);
+        check(rs.getDate(2, other)==null && rs.wasNull());
+        check(rs.getTime(3, other)==null && rs.wasNull());
+        check(rs.getTimestamp(3, other)==null && rs.wasNull());
+
+        rs.next();
+        check(rs.getInt(1), 2);
+        check(rs.getDate(2, regular).toString(), "2001-02-03");
+        check(rs.getTime(3, regular).toString(), "04:05:06");
+        checkFalse(rs.getTime(3, other).toString(), "04:05:06");
+        check(rs.getTimestamp(4, regular).toString(), "2007-08-09 10:11:12.131415");
+        checkFalse(rs.getTimestamp(4, other).toString(), "2007-08-09 10:11:12.131415");
+
+        rs.next();
+        check(rs.getInt("ID"), 3);
+        checkFalse(rs.getTimestamp("TS", regular).toString(), "2107-08-09 10:11:12.131415");
+        check(rs.getTimestamp("TS", other).toString(), "2107-08-09 10:11:12.131415");
+        checkFalse(rs.getTime("T", regular).toString(), "14:05:06");
+        check(rs.getTime("T", other).toString(), "14:05:06");
+        //checkFalse(rs.getDate(2, regular).toString(), "2101-02-03");
+//        check(rs.getDate("D", other).toString(), "2101-02-03");
+
+        rs.next();
+        check(rs.getInt("ID"), 4);
+        check(rs.getTimestamp("TS").toString(), "2107-08-09 10:11:12.131415");
+        check(rs.getTime("T").toString(), "14:05:06");
+        check(rs.getDate("D").toString(), "2101-02-03");
+
+        checkFalse(rs.next());
+        stat.execute("DROP TABLE TEST");
+    }
+
+    void testBlob() throws Exception {
+        trace("Test BLOB");
+        ResultSet rs;
+
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY,VALUE BLOB)");
+        stat.execute("INSERT INTO TEST VALUES(1,X'01010101')");
+        stat.execute("INSERT INTO TEST VALUES(2,X'02020202')");
+        stat.execute("INSERT INTO TEST VALUES(3,X'00')");
+        stat.execute("INSERT INTO TEST VALUES(4,X'ffFFff')");
+        stat.execute("INSERT INTO TEST VALUES(5,X'0bcec1')");
+        stat.execute("INSERT INTO TEST VALUES(6,NULL)");
+        rs=stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
+        testResultSetMeta(rs,2,
+            new String[]{"ID","VALUE"},
+            new int[]{Types.INTEGER,Types.BLOB},
+            new int[]{10,Integer.MAX_VALUE},
+            new int[]{0,0}
+        );
+        rs.next();
+        checkBytes(rs.getBytes(2),new byte[]{(byte)0x01,(byte)0x01,(byte)0x01,(byte)0x01});
+        check(!rs.wasNull());
+        rs.next();
+        checkBytes(rs.getBytes("value"),new byte[]{(byte)0x02,(byte)0x02,(byte)0x02,(byte)0x02});
+        check(!rs.wasNull());
+        rs.next();
+        checkBytes(readAllBytes(rs.getBinaryStream(2)),new byte[]{(byte)0x00});
+        check(!rs.wasNull());
+        rs.next();
+        checkBytes(readAllBytes(rs.getBinaryStream("VaLuE")),new byte[]{(byte)0xff,(byte)0xff,(byte)0xff});
+        check(!rs.wasNull());
+        rs.next();
+        InputStream in = rs.getBinaryStream("value");
+        byte[] b = readAllBytes(in);
+        checkBytes(b,new byte[]{(byte)0x0b,(byte)0xce,(byte)0xc1});
+        check(!rs.wasNull());
+        rs.next();
+        checkBytes(readAllBytes(rs.getBinaryStream("VaLuE")),null);
+        check(rs.wasNull());
+        check(rs.next()==false);
+        stat.execute("DROP TABLE TEST");
+    }
+
+    void testClob() throws Exception {
+        trace("Test CLOB");
+        ResultSet rs;
+        String string;
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY,VALUE CLOB)");
+        stat.execute("INSERT INTO TEST VALUES(1,'Test')");
+        stat.execute("INSERT INTO TEST VALUES(2,'Hello')");
+        stat.execute("INSERT INTO TEST VALUES(3,'World!')");
+        stat.execute("INSERT INTO TEST VALUES(4,'Hallo')");
+        stat.execute("INSERT INTO TEST VALUES(5,'Welt!')");
+        stat.execute("INSERT INTO TEST VALUES(6,NULL)");
+        stat.execute("INSERT INTO TEST VALUES(7,NULL)");
+        rs=stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
+        testResultSetMeta(rs,2,
+            new String[]{"ID","VALUE"},
+            new int[]{Types.INTEGER,Types.CLOB},
+            new int[]{10,Integer.MAX_VALUE},
+            new int[]{0,0}
+            );
+        rs.next();
+        string=rs.getString(2);
+        check(string!=null && string.equals("Test"));
+        check(!rs.wasNull());
+        rs.next();
+        InputStreamReader reader=null;
+        try {
+            reader=new InputStreamReader(rs.getAsciiStream(2),"ISO-8859-1");
+        } catch(Exception e) {
+            check(false);
+        }
+        string=readString(reader);
+        check(!rs.wasNull());
+        trace(string);
+        check(string!=null && string.equals("Hello"));
+        rs.next();
+        try {
+            reader=new InputStreamReader(rs.getAsciiStream("value"),"ISO-8859-1");
+        } catch(Exception e) {
+            check(false);
+        }
+        string=readString(reader);
+        check(!rs.wasNull());
+        trace(string);
+        check(string!=null && string.equals("World!"));
+        rs.next();
+        string=readString(rs.getCharacterStream(2));
+        check(!rs.wasNull());
+        trace(string);
+        check(string!=null && string.equals("Hallo"));
+        rs.next();
+        string=readString(rs.getCharacterStream("value"));
+        check(!rs.wasNull());
+        trace(string);
+        check(string!=null && string.equals("Welt!"));
+        rs.next();
+        check(rs.getCharacterStream(2)==null);
+        check(rs.wasNull());
+        rs.next();
+        check(rs.getAsciiStream("Value")==null);
+        check(rs.wasNull());
+
+        check(rs.getStatement()==stat);
+        check(rs.getWarnings()==null);
+        rs.clearWarnings();
+        check(rs.getWarnings()==null);
+        check(rs.getFetchDirection(), ResultSet.FETCH_FORWARD);
+        check(rs.getConcurrency(), ResultSet.CONCUR_UPDATABLE);
+        rs.next();
+        stat.execute("DROP TABLE TEST");
+    }
+
+    byte[] readAllBytes(InputStream in) throws Exception {
+        if(in==null) {
+            return null;
+        }
+        ByteArrayOutputStream out=new ByteArrayOutputStream();
+        try {
+            while(true) {
+                int b=in.read();
+                if(b==-1) {
+                    break;
+                }
+                out.write(b);
+            }
+            return out.toByteArray();
+        } catch(IOException e) {
+            check(false);
+            return null;
+        }
+    }
+
+    void checkBytes(byte[] test,byte[] good) throws Exception {
+        if(test==null || good==null) {
+            check(test==null && good==null);
+        } else {
+            trace("test.length="+test.length+" good.length="+good.length);
+            check(test.length, good.length);
+            for(int i=0;i<good.length;i++) {
+                check(test[i]==good[i]);
+            }
+        }
+    }
+
+    void checkColumnBigDecimal(ResultSet rs,int column,int i,String bd) throws Exception {
+        BigDecimal bd1=rs.getBigDecimal(column);
+        int i1=rs.getInt(column);
+        if(bd==null) {
+            trace("should be: null");
+            check(rs.wasNull());
+        } else {
+            trace("BigDecimal i="+i+" bd="+bd+" ; i1="+i1+" bd1="+bd1);
+            check(!rs.wasNull());
+            check(i1==i);
+            check(bd1.compareTo(new BigDecimal(bd))==0);
+        }
+    }
+
+}

h2/src/test/org/h2/test/jdbc/TestStatement.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.ResultSet;
+import java.sql.SQLException;
+import java.sql.Savepoint;
+import java.sql.Statement;
+
+import org.h2.test.TestBase;
+
+public class TestStatement extends TestBase {
+    
+    Connection conn;
+
+    public void test() throws Exception {
+        deleteDb("statement");
+        conn = getConnection("statement");
+        if(config.jdk14) {
+            testSavepoint();
+        }
+        testStatement();
+        if(config.jdk14) {
+            testIdentity();
+        }
+        conn.close();
+    }        
+
+    void testSavepoint() throws Exception {
+        Statement stat=conn.createStatement();
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))");
+        conn.setAutoCommit(false);
+        stat.execute("INSERT INTO TEST VALUES(0, 'Hi')");
+        Savepoint savepoint1 = conn.setSavepoint();
+        int id1 = savepoint1.getSavepointId();
+        try {
+            savepoint1.getSavepointName();
+            error("exception expected");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+        }
+        stat.execute("DELETE FROM TEST");
+        conn.rollback(savepoint1);
+        stat.execute("UPDATE TEST SET NAME='Hello'");
+        Savepoint savepoint2a = conn.setSavepoint();
+        Savepoint savepoint2 = conn.setSavepoint();
+        conn.releaseSavepoint(savepoint2a);
+        try {
+            savepoint2a.getSavepointId();
+            error("exception expected");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+        }
+        int id2 = savepoint2.getSavepointId();
+        check(id1 != id2);
+        stat.execute("UPDATE TEST SET NAME='Hallo' WHERE NAME='Hello'");
+        Savepoint savepointTest = conn.setSavepoint("Joe's");
+        stat.execute("DELETE FROM TEST");
+        check(savepointTest.getSavepointName(), "Joe's");
+        try {
+            savepointTest.getSavepointId();
+            error("exception expected");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+        }
+        conn.rollback(savepointTest);
+        conn.commit();
+        ResultSet rs = stat.executeQuery("SELECT NAME FROM TEST");
+        rs.next();
+        String name = rs.getString(1);
+        check(name, "Hallo");
+        checkFalse(rs.next());
+        try {
+            conn.rollback(savepoint2);
+            error("exception expected");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+        }
+        stat.execute("DROP TABLE TEST");
+        conn.setAutoCommit(true);
+    }
+    
+    void testStatement() throws Exception {
+        
+        Statement stat=conn.createStatement();
+        ResultSet rs;
+        int count;
+        boolean result;
+        
+        stat.execute("CREATE TABLE TEST(ID INT)");
+        stat.execute("SELECT * FROM TEST");
+        stat.execute("DROP TABLE TEST");        
+        
+        conn.getTypeMap();
+        
+        // this method should not throw an exception - if not supported, this calls are ignored
+       
+        if(config.jdk14) {
+            check(stat.getResultSetHoldability(), ResultSet.HOLD_CURSORS_OVER_COMMIT);
+        }
+        check(stat.getResultSetConcurrency(), ResultSet.CONCUR_UPDATABLE);
+        
+        stat.cancel();
+        stat.setQueryTimeout(10);
+        check(stat.getQueryTimeout()==10);
+        stat.setQueryTimeout(0);
+        check(stat.getQueryTimeout()==0);
+        // this is supposed to throw an exception
+        try {
+            stat.setQueryTimeout(-1);
+            error("setQueryTimeout(-1) didn't throw an exception");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+        }
+        check(stat.getQueryTimeout()==0);     
+        trace("executeUpdate");
+        count=stat.executeUpdate("CREATE TABLE TEST(ID INT PRIMARY KEY,VALUE VARCHAR(255))");
+        check(count,0);
+        count=stat.executeUpdate("INSERT INTO TEST VALUES(1,'Hello')");
+        check(count,1);
+        count=stat.executeUpdate("INSERT INTO TEST(VALUE,ID) VALUES('JDBC',2)");
+        check(count,1);
+        count=stat.executeUpdate("UPDATE TEST SET VALUE='LDBC' WHERE ID=2 OR ID=1");
+        check(count,2);
+        count=stat.executeUpdate("UPDATE TEST SET VALUE='\\LDBC\\' WHERE VALUE LIKE 'LDBC' ");
+        check(count,2);
+        count=stat.executeUpdate("UPDATE TEST SET VALUE='LDBC' WHERE VALUE LIKE '\\\\LDBC\\\\'");
+        trace("count:"+count);
+        check(count,2);
+        count=stat.executeUpdate("DELETE FROM TEST WHERE ID=-1");
+        check(count,0);
+        count=stat.executeUpdate("DELETE FROM TEST WHERE ID=2");
+        check(count,1);
+        try {
+            stat.executeUpdate("SELECT * FROM TEST");
+            error("executeUpdate allowed SELECT");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+            trace("no error - SELECT not allowed with executeUpdate");
+        }
+        count=stat.executeUpdate("DROP TABLE TEST");
+        check(count==0);
+        
+        trace("execute");
+        result=stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY,VALUE VARCHAR(255))");
+        check(result==false);
+        result=stat.execute("INSERT INTO TEST VALUES(1,'Hello')");
+        check(result==false);
+        result=stat.execute("INSERT INTO TEST(VALUE,ID) VALUES('JDBC',2)");
+        check(result==false);
+        result=stat.execute("UPDATE TEST SET VALUE='LDBC' WHERE ID=2");
+        check(result==false);
+        result=stat.execute("DELETE FROM TEST WHERE ID=3");
+        check(result==false);
+        result=stat.execute("SELECT * FROM TEST");
+        check(result==true);
+        result=stat.execute("DROP TABLE TEST");
+        check(result==false);
+        
+        trace("executeQuery");
+        try {
+            stat.executeQuery("CREATE TABLE TEST(ID INT PRIMARY KEY,VALUE VARCHAR(255))");
+            error("executeQuery allowed CREATE TABLE");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+            trace("no error - CREATE not allowed with executeQuery");
+        }
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY,VALUE VARCHAR(255))");
+        try {
+            stat.executeQuery("INSERT INTO TEST VALUES(1,'Hello')");
+            error("executeQuery allowed INSERT");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+            trace("no error - INSERT not allowed with executeQuery");
+        }
+        try {
+            stat.executeQuery("UPDATE TEST SET VALUE='LDBC' WHERE ID=2");
+            error("executeQuery allowed UPDATE");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+            trace("no error - UPDATE not allowed with executeQuery");
+        }
+        try {
+            stat.executeQuery("DELETE FROM TEST WHERE ID=3");
+            error("executeQuery allowed DELETE");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+            trace("no error - DELETE not allowed with executeQuery");
+        }
+        stat.executeQuery("SELECT * FROM TEST");
+        try {
+            stat.executeQuery("DROP TABLE TEST");
+            error("executeQuery allowed DROP");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+            trace("no error - DROP not allowed with executeQuery");
+        }
+        // getMoreResults
+        rs=stat.executeQuery("SELECT * FROM TEST");
+        checkFalse(stat.getMoreResults());
+        try {
+            // supposed to be closed now
+            rs.next();
+            error("getMoreResults didn't close this result set");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+            trace("no error - getMoreResults is supposed to close the result set");
+        }
+        check(stat.getUpdateCount()==-1);
+        count=stat.executeUpdate("DELETE FROM TEST");
+        checkFalse(stat.getMoreResults());
+        check(stat.getUpdateCount()==-1);
+        
+        stat.execute("DROP TABLE TEST");
+        stat.executeUpdate("DROP TABLE IF EXISTS TEST");
+        
+        check(stat.getWarnings()==null);
+        stat.clearWarnings();
+        check(stat.getWarnings()==null);
+        check(conn==stat.getConnection());
+        
+        stat.close();
+    }
+    
+    private void testIdentity() throws Exception {
+        Statement stat = conn.createStatement();
+        stat.execute("CREATE SEQUENCE SEQ");
+        stat.execute("CREATE TABLE TEST(ID INT)");
+        stat.execute("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)");
+        ResultSet rs = stat.getGeneratedKeys();
+        rs.next();
+        check(rs.getInt(1), 1);
+        checkFalse(rs.next());
+        stat.execute("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", Statement.RETURN_GENERATED_KEYS);
+        rs = stat.getGeneratedKeys();
+        rs.next();
+        check(rs.getInt(1), 2);        
+        checkFalse(rs.next());
+        stat.execute("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", new int[]{1});
+        rs = stat.getGeneratedKeys();
+        rs.next();
+        check(rs.getInt(1), 3);        
+        checkFalse(rs.next());
+        stat.execute("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", new String[]{"ID"});
+        rs = stat.getGeneratedKeys();
+        rs.next();
+        check(rs.getInt(1), 4);        
+        checkFalse(rs.next());
+        stat.executeUpdate("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", Statement.RETURN_GENERATED_KEYS);
+        rs = stat.getGeneratedKeys();
+        rs.next();
+        check(rs.getInt(1), 5);        
+        checkFalse(rs.next());
+        stat.executeUpdate("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", new int[]{1});
+        rs = stat.getGeneratedKeys();
+        rs.next();
+        check(rs.getInt(1), 6);        
+        checkFalse(rs.next());
+        stat.executeUpdate("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", new String[]{"ID"});
+        rs = stat.getGeneratedKeys();
+        rs.next();
+        check(rs.getInt(1), 7);        
+        checkFalse(rs.next());
+        stat.execute("DROP TABLE TEST");
+    }
+
+}

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/TestUpdatableResultSet.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.io.ByteArrayInputStream;
+import java.io.StringReader;
+import java.math.BigDecimal;
+import java.sql.*;
+
+import org.h2.test.TestBase;
+
+public class TestUpdatableResultSet extends TestBase {
+    
+    public void test() throws Exception {
+        testScroll();
+        testUpdateDeleteInsert();
+        testUpdateDataType();
+    }
+    
+    private void testScroll() throws Exception {
+        deleteDb("updatableResultSet");
+        Connection conn = getConnection("updatableResultSet");
+        Statement stat = conn.createStatement();
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR)");
+        stat.execute("INSERT INTO TEST VALUES(1, 'Hello'), (2, 'World'), (3, 'Test')");
+        
+        ResultSet rs = stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
+        check(rs.isBeforeFirst());
+        checkFalse(rs.isAfterLast());
+        check(rs.getRow(), 0);
+        
+        rs.next();
+        checkFalse(rs.isBeforeFirst());
+        checkFalse(rs.isAfterLast());
+        check(rs.getInt(1), 1);
+        check(rs.getRow(), 1);
+
+        rs.next();
+        checkFalse(rs.isBeforeFirst());
+        checkFalse(rs.isAfterLast());
+        check(rs.getInt(1), 2);
+        check(rs.getRow(), 2);
+        
+        rs.next();
+        checkFalse(rs.isBeforeFirst());
+        checkFalse(rs.isAfterLast());
+        check(rs.getInt(1), 3);
+        check(rs.getRow(), 3);
+
+        checkFalse(rs.next());
+        checkFalse(rs.isBeforeFirst());
+        check(rs.isAfterLast());
+        check(rs.getRow(), 0);
+        
+        check(rs.first());
+        check(rs.getInt(1), 1);
+        check(rs.getRow(), 1);
+       
+        check(rs.last());
+        check(rs.getInt(1), 3);
+        check(rs.getRow(), 3);
+        
+        check(rs.relative(0));
+        check(rs.getRow(), 3);
+        
+        check(rs.relative(-1));
+        check(rs.getRow(), 2);
+        
+        check(rs.relative(1));
+        check(rs.getRow(), 3);
+        
+        checkFalse(rs.relative(100));
+        check(rs.isAfterLast());
+        
+        checkFalse(rs.absolute(0));
+        check(rs.getRow(), 0);
+
+        check(rs.absolute(1));
+        check(rs.getRow(), 1);
+
+        check(rs.absolute(2));
+        check(rs.getRow(), 2);
+
+        check(rs.absolute(3));
+        check(rs.getRow(), 3);
+        
+        checkFalse(rs.absolute(4));
+        check(rs.getRow(), 0);        
+
+        try {
+            checkFalse(rs.absolute(0));
+            // actually, we allow it for compatibility
+            // error("absolute 0 not allowed");
+        } catch(SQLException e) {
+            checkNotGeneralException(e);
+        }
+
+        check(rs.absolute(3));
+        check(rs.getRow(), 3);
+
+        check(rs.absolute(-1));
+        check(rs.getRow(), 3);
+
+        checkFalse(rs.absolute(4));
+        check(rs.isAfterLast());
+        
+        checkFalse(rs.absolute(5));
+        check(rs.isAfterLast());
+        
+        check(rs.previous());
+        check(rs.getRow(), 3);
+
+        check(rs.previous());
+        check(rs.getRow(), 2);
+
+        conn.close();
+    }
+
+    private void testUpdateDataType() throws Exception {
+        deleteDb("updatableResultSet");
+        Connection conn = getConnection("updatableResultSet");
+        Statement stat = conn.createStatement();
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255), " +
+                "DEC DECIMAL(10,2), BOO BIT, BYE TINYINT, BIN BINARY(100), "+
+                "D DATE, T TIME, TS TIMESTAMP, DOU DOUBLE, REA REAL, LON BIGINT, "+
+                "OBI INT, SHO SMALLINT, CLO CLOB, BLO BLOB)");
+        ResultSet rs = stat.executeQuery("SELECT * FROM TEST");
+        ResultSetMetaData meta = rs.getMetaData();
+        check(meta.getColumnClassName(1), "java.lang.Integer");
+        check(meta.getColumnClassName(2), "java.lang.String");
+        check(meta.getColumnClassName(3), "java.math.BigDecimal");
+        check(meta.getColumnClassName(4), "java.lang.Boolean");
+        check(meta.getColumnClassName(5), "java.lang.Byte");
+        check(meta.getColumnClassName(6), "[B");
+        check(meta.getColumnClassName(7), "java.sql.Date");
+        check(meta.getColumnClassName(8), "java.sql.Time");
+        check(meta.getColumnClassName(9), "java.sql.Timestamp");
+        check(meta.getColumnClassName(10), "java.lang.Double");
+         check(meta.getColumnClassName(11), "java.lang.Float");
+        check(meta.getColumnClassName(12), "java.lang.Long");
+        check(meta.getColumnClassName(13), "java.lang.Integer");
+        check(meta.getColumnClassName(14), "java.lang.Short");
+        check(meta.getColumnClassName(15), "java.sql.Clob");
+        check(meta.getColumnClassName(16), "java.sql.Blob");
+        
+        rs.moveToInsertRow();
+        rs.updateInt(1, 0);
+        rs.updateNull(2);
+        rs.updateNull("DEC");
+        // 'not set' values are set to null
+        rs.insertRow();
+        
+        rs.moveToInsertRow();
+        rs.updateInt(1, 1);
+        rs.updateString(2, null);
+        rs.updateBigDecimal(3, null);
+        rs.updateBoolean(4, false);
+        rs.updateByte(5, (byte)0);
+        rs.updateBytes(6, null);
+        rs.updateDate(7, null);
+        rs.updateTime(8, null);
+        rs.updateTimestamp(9, null);
+        rs.updateDouble(10, 0.0);
+        rs.updateFloat(11, (float)0.0);
+        rs.updateLong(12, 0L);
+        rs.updateObject(13, null);
+        rs.updateShort(14, (short)0);
+        rs.updateCharacterStream(15, new StringReader("test"), 0);
+        rs.updateBinaryStream(16, new ByteArrayInputStream(new byte[]{(byte)0xff, 0x00}), 0);
+        rs.insertRow();
+
+        rs.moveToInsertRow();
+        rs.updateInt("ID", 2);
+        rs.updateString("NAME", "+");
+        rs.updateBigDecimal("DEC", new BigDecimal("1.2"));
+        rs.updateBoolean("BOO", true);
+        rs.updateByte("BYE", (byte)0xff);
+        rs.updateBytes("BIN", new byte[]{0x00, (byte)0xff});
+        rs.updateDate("D", Date.valueOf("2005-09-21"));
+        rs.updateTime("T", Time.valueOf("21:46:28"));
+        rs.updateTimestamp("TS", Timestamp.valueOf("2005-09-21 21:47:09.567890123"));
+        rs.updateDouble("DOU", 1.725);
+        rs.updateFloat("REA", (float)2.5);
+        rs.updateLong("LON", Long.MAX_VALUE);
+        rs.updateObject("OBI", new Integer(10));
+        rs.updateShort("SHO", Short.MIN_VALUE);
+        rs.updateCharacterStream("CLO", new StringReader("\u00ef\u00f6\u00fc"), 0); // auml ouml uuml
+        rs.updateBinaryStream("BLO", new ByteArrayInputStream(new byte[]{(byte)0xab, 0x12}), 0);
+        rs.insertRow();
+        
+        rs = stat.executeQuery("SELECT * FROM TEST ORDER BY ID NULLS FIRST");
+        rs.next();
+        check(rs.getInt(1) == 0);
+        check(rs.getString(2) == null && rs.wasNull());
+        check(rs.getBigDecimal(3) == null && rs.wasNull());
+        check(rs.getBoolean(4) == false && rs.wasNull());
+        check(rs.getByte(5) == 0 && rs.wasNull());
+        check(rs.getBytes(6) == null && rs.wasNull());
+        check(rs.getDate(7) == null && rs.wasNull());
+        check(rs.getTime(8) == null && rs.wasNull());
+        check(rs.getTimestamp(9) == null && rs.wasNull());
+        check(rs.getDouble(10) == 0.0 && rs.wasNull());
+        check(rs.getFloat(11) == 0.0 && rs.wasNull());
+        check(rs.getLong(12) == 0 && rs.wasNull());
+        check(rs.getObject(13) == null && rs.wasNull());
+        check(rs.getShort(14) == 0 && rs.wasNull());
+        check(rs.getCharacterStream(15) == null && rs.wasNull());
+        check(rs.getBinaryStream(16) == null && rs.wasNull());
+
+        rs.next();
+        check(rs.getInt(1) == 1);
+        check(rs.getString(2)==null && rs.wasNull());
+        check(rs.getBigDecimal(3) == null && rs.wasNull());
+        check(rs.getBoolean(4)==false && !rs.wasNull());
+        check(rs.getByte(5) == 0 && !rs.wasNull());
+        check(rs.getBytes(6) == null && rs.wasNull());
+        check(rs.getDate(7) == null && rs.wasNull());
+        check(rs.getTime(8) == null && rs.wasNull());
+        check(rs.getTimestamp(9) == null && rs.wasNull());
+        check(rs.getDouble(10) == 0.0 && !rs.wasNull());
+        check(rs.getFloat(11) == 0.0 && !rs.wasNull());
+        check(rs.getLong(12) == 0 && !rs.wasNull());
+        check(rs.getObject(13) == null && rs.wasNull());
+        check(rs.getShort(14) == 0 && !rs.wasNull());
+        check(rs.getString(15), "test");
+        check(rs.getBytes(16), new byte[]{(byte)0xff, 0x00});
+        
+        rs.next();
+        check(rs.getInt(1) == 2);
+        check(rs.getString(2), "+");
+        check(rs.getBigDecimal(3).toString(), "1.20");
+        check(rs.getBoolean(4)==true);
+        check((rs.getByte(5)&0xff) == 0xff);
+        check(rs.getBytes(6), new byte[]{0x00, (byte)0xff});
+        check(rs.getDate(7).toString(), "2005-09-21");
+        check(rs.getTime(8).toString(), "21:46:28");
+        check(rs.getTimestamp(9).toString(), "2005-09-21 21:47:09.567890123");
+        check(rs.getDouble(10) == 1.725);
+        check(rs.getFloat(11) == (float)2.5);
+        check(rs.getLong(12) == Long.MAX_VALUE);
+        check(((Integer)rs.getObject(13)).intValue(), 10);
+        check(rs.getShort(14) == Short.MIN_VALUE);       
+        check(rs.getString(15), "\u00ef\u00f6\u00fc"); // auml ouml uuml
+        check(rs.getBytes(16), new byte[]{(byte)0xab, 0x12});
+
+        checkFalse(rs.next());
+        stat.execute("DROP TABLE TEST");
+        conn.close();
+    }
+    
+    private void testUpdateDeleteInsert() throws Exception {
+        deleteDb("updatableResultSet");
+        Connection c1 = getConnection("updatableResultSet");
+        Connection c2 = getConnection("updatableResultSet");
+        Statement stat = c1.createStatement();
+        stat.execute("DROP TABLE IF EXISTS TEST");
+        stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))");
+        int max = 8;
+        for(int i=0; i<max; i++) {
+            stat.execute("INSERT INTO TEST VALUES("+i+", 'Hello"+i+"')");
+        }
+        ResultSet rs = stat.executeQuery("SELECT * FROM TEST");
+        int j=max;
+        while(rs.next()) {
+            int id = rs.getInt(1);
+            if(id % 2 == 0) {
+                Statement s2 = c2.createStatement();
+                s2.execute("UPDATE TEST SET NAME = NAME || '+' WHERE ID = "+rs.getInt(1));
+                if(id % 4 == 0) {
+                    rs.refreshRow();
+                }
+                rs.updateString(2, "Updated " + rs.getString(2));
+                rs.updateRow();
+            } else {
+                rs.deleteRow();
+            }
+            rs.moveToInsertRow();
+            rs.updateString(2, "Inserted " + j);
+            rs.updateInt(1, j);
+            j+= 2;
+            rs.insertRow();
+        }
+        rs = stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
+        while(rs.next()) {
+            int id = rs.getInt(1);
+            String name = rs.getString(2);
+            check(id % 2, 0);
+            if(id >= max) {
+                check("Inserted " + id, rs.getString(2));
+            } else {
+                if(id % 4 == 0) {
+                    check(rs.getString(2), "Updated Hello" + id + "+");
+                } else {
+                    check(rs.getString(2), "Updated Hello" + id);
+                }
+            }
+            trace("id="+id+" name="+name);
+        }
+        c2.close();
+        c1.close();
+        
+        // test scrollable result sets
+        Connection conn = getConnection("updatableResultSet");
+        for(int i=0; i<5; i++) {
+            testScrollable(conn, i);
+        }
+        conn.close();
+    }
+    
+    void testScrollable(Connection conn, int rows) throws Exception {
+        Statement stat = conn.createStatement();
+        stat.execute("CREATE TABLE IF NOT EXISTS TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))");
+        stat.execute("DELETE FROM TEST");
+        PreparedStatement prep = conn.prepareStatement("INSERT INTO TEST VALUES(?, ?)");
+        for (int i = 0; i < rows; i++) {
+            prep.setInt(1, i);
+            prep.setString(2, "Data "+i);
+            prep.execute();
+        }
+        Statement regular = conn.createStatement();
+        testScrollResultSet(regular, ResultSet.TYPE_FORWARD_ONLY, rows);
+        Statement scroll = conn.createStatement(
+                ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
+        testScrollResultSet(scroll, ResultSet.TYPE_SCROLL_INSENSITIVE, rows);
+    }
+
+    void testScrollResultSet(Statement stat, int type, int rows) throws Exception {
+        boolean error = false;
+        if (type == ResultSet.TYPE_FORWARD_ONLY) {
+            error = true;
+        }
+        ResultSet rs = stat.executeQuery("SELECT * FROM TEST");
+        check(rs.getType(), type);
+
+        checkState(rs, true, false, false, rows == 0);
+        for (int i = 0; i < rows; i++) {
+            rs.next();
+            checkState(rs, rows == 0, i == 0, i == rows - 1,
+                    (rows == 0 || i == rows));
+        }
+        try {
+            rs.beforeFirst();
+            checkState(rs, true, false, false, rows == 0);
+        } catch (SQLException e) {
+            if (!error) {
+                throw e;
+            }
+        }
+        try {
+            rs.afterLast();
+            checkState(rs, false, false, false, true);
+        } catch (SQLException e) {
+            if (!error) {
+                throw e;
+            }
+        }
+        try {
+            boolean valid = rs.first();
+            check(valid, rows > 0);
+            if (valid) {
+                checkState(rs, false, true, rows == 1, rows == 0);
+            }
+        } catch (SQLException e) {
+            if (!error) {
+                throw e;
+            }
+        }
+        try {
+            boolean valid = rs.last();
+            check(valid, rows > 0);
+            if (valid) {
+                checkState(rs, false, rows == 1, true, rows == 0);
+            }
+        } catch (SQLException e) {
+            if (!error) {
+                throw e;
+            }
+        }
+    }
+
+    void checkState(ResultSet rs, boolean beforeFirst, boolean first,
+            boolean last, boolean afterLast) throws Exception {
+        check(rs.isBeforeFirst(), beforeFirst);
+        check(rs.isFirst(), first);
+        check(rs.isLast(), last);
+        check(rs.isAfterLast(), afterLast);
+    }
+
+}

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();
+        
+    }
+
+}