/** Comparisons that can't get pushed down. */ public void testComparision() throws SQLException { Statement st = createStatement(); st.execute("CALL SYSCS_UTIL.SYSCS_SET_RUNTIMESTATISTICS(1)"); JDBC.assertFullResultSet( st.executeQuery( "select * from t1" + " --derby-properties index = t1_c1\n" + "where c1 = c1"), FULL_TABLE); RuntimeStatisticsParser rtsp = SQLUtilities.getRuntimeStatisticsParser(st); assertTrue(rtsp.usedSpecificIndexForIndexScan("T1", "T1_C1")); JDBC.assertFullResultSet( st.executeQuery( "select * from t1" + " --derby-properties index = t1_c1\n" + "where c1 = c2"), FULL_TABLE); rtsp = SQLUtilities.getRuntimeStatisticsParser(st); assertTrue(rtsp.usedSpecificIndexForIndexScan("T1", "T1_C1")); JDBC.assertFullResultSet( st.executeQuery( "select * from t1" + " --derby-properties index = t1_c1\n" + "where c1 + 1 = 1 + c1"), FULL_TABLE); rtsp = SQLUtilities.getRuntimeStatisticsParser(st); assertTrue(rtsp.usedSpecificIndexForIndexScan("T1", "T1_C1")); st.close(); }
/** Make sure following fragments get treated as comments. */ public void testFragmentsAsComments() throws SQLException { String[] frags = { "--d", "-- de", "-- der", "--derb", "--derby comment", "-- derby another comment", "--derby-", "--derby-p", "--derby-pr", "--derby-pro", "--derby-prop", "--derby-prope", "--derby-proper", "-- derby-propert", "-- derby-properti", "-- derby-propertie", "-- derby-propertiex" }; Statement st = createStatement(); for (int i = 0; i < frags.length; i++) JDBC.assertFullResultSet(st.executeQuery(frags[i] + "\n VALUES 1 "), new String[][] {{"1"}}); st.close(); }
/** * Test that routine parameters and return types are handled correctly with 10.4 creating a * procedure in soft-upgrade. 10.4 simplified the stored format of the types by ensuring the * catalog type was written. See DERBY-2917 for details. * * @throws SQLException */ public void testRoutineParameters() throws SQLException { switch (getPhase()) { case PH_CREATE: break; case PH_SOFT_UPGRADE: Statement s = createStatement(); s.execute( "CREATE FUNCTION TYPES_10_4" + "(A INTEGER) RETURNS CHAR(10) " + "LANGUAGE JAVA " + "PARAMETER STYLE JAVA " + "NO SQL " + "EXTERNAL NAME 'java.lang.Integer.toHexString'"); // fall through to test it case PH_HARD_UPGRADE: case PH_POST_SOFT_UPGRADE: PreparedStatement ps = prepareStatement("VALUES TYPES_10_4(?)"); ps.setInt(1, 48879); // Don't use the single value check method here // because we want to check the returned value // was converted to its correct type of CHAR(10) // (so no trimming of values) JDBC.assertFullResultSet(ps.executeQuery(), new Object[][] {{"beef "}}, false); break; } }
void _fillTableOnServer( String serverHost, int serverPort, String dbPath, int startVal, int _noTuplesToInsert) throws Exception { ClientDataSourceInterface ds; if (JDBC.vmSupportsJNDI()) { ds = (ClientDataSourceInterface) Class.forName("org.apache.derby.jdbc.ClientDataSource").newInstance(); } else { ds = (ClientDataSourceInterface) Class.forName("org.apache.derby.jdbc.BasicClientDataSource40").newInstance(); } ds.setDatabaseName(dbPath); ds.setServerName(serverHost); ds.setPortNumber(serverPort); ds.setConnectionAttributes(useEncryption(false)); Connection conn = ds.getConnection(); PreparedStatement ps = conn.prepareStatement("insert into t values (?,?,?)"); for (int i = 0; i < _noTuplesToInsert; i++) { ps.setInt(1, (i + startVal)); ps.setString(2, "dilldall" + (i + startVal)); ps.setInt(3, (i + startVal) % (_noTuplesToInsert / 10)); ps.execute(); if ((i % 10000) == 0) conn.commit(); } _verify(conn, startVal + _noTuplesToInsert); conn.close(); }
/** Verify that statements are dependent on specified index. */ public void testDependenceOnIndex() throws SQLException { PreparedStatement ps = prepareStatement("select * from t1 " + "--derby-properties index = t1_c1"); JDBC.assertFullResultSet( ps.executeQuery(), new String[][] { {"1", "1", "1"}, {"2", "2", "2"}, {"3", "3", "3"}, {"4", "4", "4"}, }); Statement st = createStatement(); st.executeUpdate("drop index t1_c1"); assertStatementError("42Y46", ps); ps.close(); // add index to avoid exception when deleted in tearDown(). st.executeUpdate("create index t1_c1 on t1(c1)"); st.close(); }
public void testJoin() throws SQLException { Statement st = createStatement(); st.execute("CALL SYSCS_UTIL.SYSCS_SET_RUNTIMESTATISTICS(1)"); JDBC.assertFullResultSet( st.executeQuery( "select 1 from t1 a" + " --derby-properties index = t1_c1\n" + ",t2 b --derby-properties index = t2_c2"), new String[][] { {"1"}, {"1"}, {"1"}, {"1"}, {"1"}, {"1"}, {"1"}, {"1"}, {"1"}, {"1"}, {"1"}, {"1"}, {"1"}, {"1"}, {"1"}, {"1"}, }); RuntimeStatisticsParser rtsp = SQLUtilities.getRuntimeStatisticsParser(st); assertTrue(rtsp.usedSpecificIndexForIndexScan("T1", "T1_C1")); assertTrue(rtsp.usedSpecificIndexForIndexScan("T2", "T2_C2")); JDBC.assertFullResultSet( st.executeQuery( "select 1 from " + " --derby-properties joinOrder=fixed\n" + "t1, t2 where t1.c1 = t2.c1"), new String[][] { {"1"}, {"1"}, {"1"}, {"1"}, }); JDBC.assertFullResultSet( st.executeQuery( "select * from t1" + " --derby-properties index = t1_c1\n" + "left outer join t2 " + "--derby-properties index = t2_c2\n" + "on t1.c1 = t2.c1"), new String[][] { {"1", "1", "1", "1", "1", "1"}, {"2", "2", "2", "2", "2", "2"}, {"3", "3", "3", "3", "3", "3"}, {"4", "4", "4", "4", "4", "4"}, }); rtsp = SQLUtilities.getRuntimeStatisticsParser(st); assertTrue(rtsp.usedSpecificIndexForIndexScan("T1", "T1_C1")); assertTrue(rtsp.usedSpecificIndexForIndexScan("T2", "T2_C2")); st.close(); }
/** * Test that normalization of negative zero to positive zero works for doubles. In some JVMs this * used to give wrong results after runtime optimization. See DERBY-2447 and <a * href="http://bugs.sun.com/view_bug.do?bug_id=6833879">CR6833879</a> in Sun's bug database. */ public void testNegativeZeroDoubleJvmBug() throws SQLException { PreparedStatement ps = prepareStatement("values -cast(? as double)"); ps.setDouble(1, 0.0d); // Execute the statement many times so that the JVM is likely to // produce native, optimized code. for (int i = 0; i < 7000; i++) { JDBC.assertSingleValueResultSet(ps.executeQuery(), "0.0"); } }
public void testNullValue() throws SQLException { Statement st = createStatement(); st.execute("CALL SYSCS_UTIL.SYSCS_SET_RUNTIMESTATISTICS(1)"); JDBC.assertFullResultSet( st.executeQuery("select * from t1 " + "--derby-properties index = null"), FULL_TABLE); RuntimeStatisticsParser rtsp = SQLUtilities.getRuntimeStatisticsParser(st); assertTrue("force table scan", rtsp.usedTableScan()); JDBC.assertFullResultSet( st.executeQuery("select * from t1 " + "--derby-properties constraint = null"), FULL_TABLE); assertStatementError( "42Y56", st, "select * from t1 " + "--derby-properties joinStrategy = null"); st.close(); }
/** * Tests that the cache throws out the least frequently used statement when it reaches its maximum * capacity, and that the thrown out statement is closed in the process. * * <p>Note: This test assumes things about the replacement policy. * * @throws SQLException if a JDBC operation fails */ public void testEvictionFromCache() throws SQLException { // Initial setup. JDBCStatementCache cache = new JDBCStatementCache(2); final String sql1 = "values 1"; final String sql2 = "values 2"; final String sql3 = "values 3"; // Create three physical prepares statements. java.sql.PreparedStatement ps1 = prepareStatement(sql1); java.sql.PreparedStatement ps2 = prepareStatement(sql2); java.sql.PreparedStatement ps3 = prepareStatement(sql3); // Insert the two first physical statements, the get logical wrappers. StatementKey stmtKey1 = insertStatementIntoCache(cache, ps1, sql1); StatementKey stmtKey2 = insertStatementIntoCache(cache, ps2, sql2); LogicalStatementEntity logic1 = createLogicalStatementEntity(sql1, false, cache); LogicalStatementEntity logic2 = createLogicalStatementEntity(sql2, false, cache); // Insert the last physical statement and get the logical wrapper. StatementKey stmtKey3 = insertStatementIntoCache(cache, ps3, sql3); LogicalStatementEntity logic3 = createLogicalStatementEntity(sql3, false, cache); assertSame(ps1, logic1.getPhysPs()); assertSame(ps2, logic2.getPhysPs()); assertSame(ps3, logic3.getPhysPs()); // Close two first logical statements, putting them back into the cache. logic1.close(); logic2.close(); // Assert both of the statements are open. JDBC.assertSingleValueResultSet(ps1.executeQuery(), "1"); JDBC.assertSingleValueResultSet(ps2.executeQuery(), "2"); // Close the third statement. It should be cached, but since the cache // will exceed its maximum capacity, the first statement will be thrown // out and it should be closed in the process. logic3.close(); JDBC.assertSingleValueResultSet(ps3.executeQuery(), "3"); assertNull("ps1 still in the cache", cache.getCached(stmtKey1)); try { ps1.executeQuery(); fail("ps1 should have been closed by the cache"); } catch (SQLException sqle) { assertSQLState("XJ012", sqle); } // Make sure the right statements are returned from the cache. assertSame(ps2, cache.getCached(stmtKey2)); assertSame(ps3, cache.getCached(stmtKey3)); }
/** * Base suite of tests that will run in both embedded and client. * * @param name Name for the suite. */ private static TestSuite baseSuite(String name) { TestSuite suite = new TestSuite(name); suite.addTestSuite(UpdateXXXTest.class); // requires java.math.BigDecimal if (JDBC.vmSupportsJDBC3()) suite.addTest(new UpdateXXXTest("jdbc2testUpdateBigDecimal")); return suite; }
/** Index which includes columns in for update of list. */ public void testPropertyForUpdate() throws SQLException { Statement st = createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE); JDBC.assertFullResultSet( st.executeQuery("select * from t1 " + "--derby-properties index = t1_c1\n" + "for update"), FULL_TABLE); JDBC.assertFullResultSet( st.executeQuery( "select * from t1 exposedname " + "--derby-properties index = t1_c1\n" + "for update"), FULL_TABLE); JDBC.assertFullResultSet( st.executeQuery( "select * from t1 " + "--derby-properties index = t1_c1\n" + "for update of c2, c1"), FULL_TABLE); JDBC.assertFullResultSet( st.executeQuery( "select * from t1 exposedname " + "--derby-properties index = t1_c1\n" + "for update of c2, c1"), FULL_TABLE); JDBC.assertFullResultSet( st.executeQuery( "select * from t1 " + "--derby-properties constraint = cons1\n" + "for update"), FULL_TABLE); JDBC.assertFullResultSet( st.executeQuery( "select * from t1 exposedname " + "--derby-properties constraint = cons1\n" + "for update"), FULL_TABLE); JDBC.assertFullResultSet( st.executeQuery( "select * from t1 " + "--derby-properties constraint = cons1\n" + "for update of c2, c1"), FULL_TABLE); JDBC.assertFullResultSet( st.executeQuery( "select * from t1 exposedname " + "--derby-properties constraint = cons1\n" + "for update of c2, c1"), FULL_TABLE); st.close(); }
/** Test case insensitivity, spelling sensitivity and delimited index. */ public void testSpell() throws SQLException { Statement st = createStatement(); st.execute("CALL SYSCS_UTIL.SYSCS_SET_RUNTIMESTATISTICS(1)"); // the token derby-properties is case insensitive. JDBC.assertFullResultSet( st.executeQuery("select * from t1" + " --DeRbY-pRoPeRtIeS index = t1_c1"), FULL_TABLE); RuntimeStatisticsParser rtsp = SQLUtilities.getRuntimeStatisticsParser(st); assertTrue(rtsp.usedSpecificIndexForIndexScan("T1", "T1_C1")); // -- misspell derby-properties and make sure that // it gets treated as a regular comment // rather than optimizer override JDBC.assertFullResultSet( st.executeQuery("select * from t1 " + " --DeRbY-pRoPeRtIeAAAA index = t1_c1"), FULL_TABLE); rtsp = SQLUtilities.getRuntimeStatisticsParser(st); assertTrue( "not using t1_c1, but what derby thinks is best index.", rtsp.usedSpecificIndexForIndexScan("T1", "T1_C1C2C3")); // "--DeRbY-pRoPeRtIeSAAAA index = t1_c1" is // treated as "--DeRbY-pRoPeRtIeS AAAA index = t1_c1" assertStatementError( "42Y44", st, "select * from t1 " + " --DeRbY-pRoPeRtIeSAAAA index = t1_c1"); // -- force index, delimited identifier JDBC.assertFullResultSet( st.executeQuery("select * from t1 " + "--derby-properties index = \"t1_c2c1\""), FULL_TABLE); rtsp = SQLUtilities.getRuntimeStatisticsParser(st); assertTrue(rtsp.usedSpecificIndexForIndexScan("T1", "t1_c2c1")); // If the property spelled wrong gets treated // as an optimizer override, the following test will fail. assertStatementError( "42Y46", st, "select * from t1 " + " --DeRbY-pRoPeRtIeS index = t1_notexisting"); st.close(); }
/** * Creates a JUnit test suite containing all the tests (subsuites) in this package. The number of * tests included may depend on the environment in which this method is run. * * @return A test suite containing all tests in this package */ public static Test suite() { TestSuite suite = new TestSuite("management"); if (JDBC.vmSupportsJMX()) { suite.addTest(JMXTest.suite()); suite.addTest(ManagementMBeanTest.suite()); suite.addTest(InactiveManagementMBeanTest.suite()); suite.addTest(VersionMBeanTest.suite()); suite.addTest(JDBCMBeanTest.suite()); suite.addTest(NetworkServerMBeanTest.suite()); suite.addTest(CustomMBeanServerBuilderTest.suite()); } return suite; }
public void test_decimal_BigDecimal_BigDecimal() throws Exception { // // On small device platforms, this raises an exception in the byte-code // compiler. See DERBY-3697. // if (JDBC.vmSupportsJSR169()) { return; } declareAndRunFunction( "decimal_BigDecimal_BigDecimal", "decimal( 7, 2 )", new String[] {"decimal( 7, 2 )"}, "12345.67", "12345.67"); }
/** Verify that statements are dependent on specified constraint. */ public void testDependenceOnConstraint() throws SQLException { PreparedStatement ps = prepareStatement("select * from t1 " + "--derby-properties constraint = cons1"); JDBC.assertFullResultSet(ps.executeQuery(), FULL_TABLE); Statement st = createStatement(); st.executeUpdate("alter table t1 drop constraint cons1"); assertStatementError("42Y48", ps); // add cons1 to restore the test environment. st.executeUpdate("alter table t1 " + "add constraint cons1 primary key(c1, c2)"); ps.close(); st.close(); }
/** * Asserts that closing the logical statement and caching the physical one does close the logical * one but not the physical one. * * @throws SQLException if a JDBC operation fails */ public void testCloseWhenStatementShallBeCached() throws SQLException { // Initial setup. final String sql = "values 9"; java.sql.PreparedStatement ps = prepareStatement(sql); JDBCStatementCache cache = new JDBCStatementCache(10); StatementKey stmtKey = insertStatementIntoCache(cache, ps, sql); LogicalStatementEntity logic = createLogicalStatementEntity(sql, false, cache); assertSame(ps, logic.getPhysPs()); assertFalse(logic.isLogicalEntityClosed()); // Close the statement, it should go into the cache. logic.close(); assertTrue(logic.isLogicalEntityClosed()); // Use the physical statement. java.sql.ResultSet rs = ps.executeQuery(); JDBC.assertSingleValueResultSet(rs, "9"); // Get the statement from the cache. assertSame(ps, cache.getCached(stmtKey)); }
/** * Tests that a statement equal to one in the cache is not cached when closing the logical * statement, and that the physical statement is closed. * * @throws SQLException if a JDBC operation fails */ public void testCloseOnDuplicateStatement() throws SQLException { // Initial setup. final String sql = "values 7"; java.sql.PreparedStatement ps = prepareStatement(sql); JDBCStatementCache cache = new JDBCStatementCache(10); StatementKey stmtKey = insertStatementIntoCache(cache, ps, sql); LogicalStatementEntity logic = createLogicalStatementEntity(sql, false, cache); assertSame(ps, logic.getPhysPs()); assertFalse(logic.isLogicalEntityClosed()); // Put a statement into the cache. // assertTrue(cache.cacheStatement(stmtKey, ps)); // Create a second statement, equal to the first. java.sql.PreparedStatement psDupe = prepareStatement(sql); insertStatementIntoCache(cache, psDupe, sql); LogicalStatementEntity logicDupe = createLogicalStatementEntity(sql, false, cache); // Close the first logical entry, to put the physical statement back // into the cache. logic.close(); // When we ask the logical entity to close the statement now, the // underlying physical prepared statement should actually be closed. logicDupe.close(); assertTrue(logicDupe.isLogicalEntityClosed()); // Since we are possibly running in a pre-JDBC 4 environment, try do do // something to provoke an exception. try { psDupe.execute(); fail("Statement should have been closed and throw an exception"); } catch (SQLException sqle) { assertSQLState("XJ012", sqle); } // The cached statement should still be open. java.sql.PreparedStatement psCached = cache.getCached(stmtKey); assertSame(ps, psCached); java.sql.ResultSet rs = psCached.executeQuery(); JDBC.assertSingleValueResultSet(rs, "7"); }
/** * Check that even though we have set schema to a user schema, the metadata queries get run with * compilation schema as SYS. DERBY-2946 Test added for 10.4. * * @throws SQLException */ public void testMetaDataQueryRunInSYScompilationSchema() throws SQLException { // This test is for databases with territory based collation. That // feature was added in 10.3 codeline and hence there is no point in // doing any testing with pre-10.3 databases. if (!oldAtLeast(10, 3)) return; DataSource ds = JDBCDataSource.getDataSourceLogical("COLLATED_DB_10_3"); switch (getPhase()) { case PH_CREATE: // create the database if it was not already created. Note the // JDBC url attributes. JDBCDataSource.setBeanProperty( ds, "ConnectionAttributes", "create=true;territory=no;collation=TERRITORY_BASED"); ds.getConnection().close(); break; case PH_SOFT_UPGRADE: case PH_POST_SOFT_UPGRADE: case PH_HARD_UPGRADE: Connection con = ds.getConnection(); // First make the current schema as a user schema. And then run a // metadata query to make sure that it runs fine. If it does (which // is the expected behavior), then it will mean that the metadata // query is getting run with SYS as the compilation schema rather // than the current schema which is APP. Statement s = con.createStatement(); s.execute("SET SCHEMA APP"); DatabaseMetaData dmd = con.getMetaData(); ResultSet rs = dmd.getTables(null, "APP", null, null); JDBC.assertDrainResults(rs); s.close(); break; } }
public void testNestedLoopJoinStrategy() throws SQLException { Statement st = createStatement(); st.execute("CALL SYSCS_UTIL.SYSCS_SET_RUNTIMESTATISTICS(1)"); JDBC.assertFullResultSet( st.executeQuery( "select * from t1 a, t1 b " + "--derby-properties joinStrategy = nestedloop\n" + "where a.c1 = b.c1"), new String[][] { {"1", "1", "1", "1", "1", "1"}, {"2", "2", "2", "2", "2", "2"}, {"3", "3", "3", "3", "3", "3"}, {"4", "4", "4", "4", "4", "4"}, }); // RuntimeStatisticsParser rtsp = // SQLUtilities.getRuntimeStatisticsParser(st); // assertTrue(rtsp.usedHashJoin()); // assertTrue("not using t1_c1, but what derby thinks is best index.", // rtsp.usedSpecificIndexForIndexScan("T1", "T1_C1C2C3")); st.close(); }
public void testCreateDiskStoreDDLUT() throws Exception { // Test various legal and illegal forms of CREATE DISKSTORE // Catch exceptions from illegal syntax // Tests still not fixed marked FIXME // Array of DDL text to execute and sqlstates to expect Object[][] CreateDiskStoreUT = { {"CREATE DISKSTORE \"GFXD-DD-DISKSTORE\"", "X0Y68"}, {"CREATE DISKSTORE \"GFXD-DEFAULT-DISKSTORE\"", "X0Y68"}, {"CREATE DISKSTORE DISKSTORE", null}, {"CREATE DISKSTORE MYSTORE1", null}, {"CREATE DISKSTORE MYSTORE1", "X0Y68"}, {"CREATE DISKSTORE NULL", "42X01"}, {"CREATE DISKSTORE ''", "42X01"}, {"CREATE DISKSTORE \"*\"", "0A000"}, {"CREATE DISKSTORE SYS.MYDISKSTORE", "42X01"}, {"CREATE DISKSTORE QUEUESIZE QUEUESIZE 5", null}, {"CREATE DISKSTORE QUEUESIZE2 QUEUESIZE 5 QUEUESIZE 99", "42Y49"}, {"CREATE DISKSTORE BADSIZE ('MYDIR' -5000)", "42X44"}, // FIXME { "CREATE DISKSTORE BADSIZE2 ('MYDIR' 0)", "42X44" }, {"CREATE DISKSTORE BADSIZE3 ('MYDIR' +infinity)", "42X01"}, {"CREATE DISKSTORE BADSIZE4 ('MYDIR' x'41')", "22018"}, {"CREATE DISKSTORE BADSIZE5 ('MYDIR' 2147483648)", "22018"}, {"CREATE DISKSTORE BADSIZE6 ('MYDIR' 2147483647)", null}, {"CREATE DISKSTORE ML1 MAXLOGSIZE -5", "42X44"}, // FIXME { "CREATE DISKSTORE ML1 MAXLOGSIZE 0", "42X44" }, {"CREATE DISKSTORE ML3 MAXLOGSIZE 2147483647", null}, {"CREATE DISKSTORE ML4 MAXLOGSIZE 'hello'", "42X01"}, {"CREATE DISKSTORE AC1 AUTOCOMPACT true", null}, {"CREATE DISKSTORE AC2 AUTOCOMPACT false", null}, {"CREATE DISKSTORE AC3 AUTOCOMPACT 5", "42X01"}, {"CREATE DISKSTORE AC4 AUTOCOMPACT maybe", "42X01"}, {"CREATE DISKSTORE AC5 AUTOCOMPACT 'true'", "42X01"}, {"CREATE DISKSTORE AC6 AUTOCOMPACT \"false\"", "42X01"}, {"CREATE DISKSTORE AFC1 ALLOWFORCECOMPACTION true", null}, {"CREATE DISKSTORE AFC2 ALLOWFORCECOMPACTION false", null}, {"CREATE DISKSTORE AFC3 ALLOWFORCECOMPACTION 11", "42X01"}, {"CREATE DISKSTORE AFC4 ALLOWFORCECOMPACTION maybe", "42X01"}, {"CREATE DISKSTORE AFC5 ALLOWFORCECOMPACTION 'true'", "42X01"}, {"CREATE DISKSTORE AFC6 ALLOWFORCECOMPACTION \"false\"", "42X01"}, { "CREATE DISKSTORE AFC7 ALLOWFORCECOMPACTION true AUTOCOMPACT false", null }, // should probably be an error {"CREATE DISKSTORE CT1 COMPACTIONTHRESHOLD -5", "42X44"}, {"CREATE DISKSTORE CT2 COMPACTIONTHRESHOLD 0", null}, {"CREATE DISKSTORE CT3 COMPACTIONTHRESHOLD 100", null}, {"CREATE DISKSTORE CT4 COMPACTIONTHRESHOLD 55.2", "42X20"}, {"CREATE DISKSTORE CT5 COMPACTIONTHRESHOLD 175", "0A000"}, // replace with better sqlstate {"CREATE DISKSTORE CT6 COMPACTIONTHRESHOLD 'big'", "42X01"}, {"CREATE DISKSTORE CT7 COMPACTIONTHRESHOLD zero", "42X01"}, { "CREATE DISKSTORE CT8 COMPACTIONTHRESHOLD 50 AUTOCOMPACT false", null }, // should probably be an error { "CREATE DISKSTORE CT9 COMPACTIONTHRESHOLD 50 AUTOCOMPACT false ALLOWFORCECOMPACTION true", null }, // should probably be an error {"CREATE DISKSTORE TI1 TIMEINTERVAL -5", "42X44"}, {"CREATE DISKSTORE TI2 TIMEINTERVAL 0", null}, {"CREATE DISKSTORE TI3 TIMEINTERVAL 2147473648", null}, {"CREATE DISKSTORE TI4 TIMEINTERVAL '4'", "42X01"}, {"CREATE DISKSTORE TI5 TIMEINTERVAL five", "42X01"}, {"CREATE DISKSTORE WB1 WRITEBUFFERSIZE -5", "42X44"}, {"CREATE DISKSTORE WB2 WRITEBUFFERSIZE 0", null}, {"CREATE DISKSTORE WB3 WRITEBUFFERSIZE 2147473648", null}, {"CREATE DISKSTORE WB4 WRITEBUFFERSIZE 'awholelot'", "42X01"}, {"CREATE DISKSTORE WB5 WRITEBUFFERSIZE many", "42X01"}, {"CREATE DISKSTORE QS1 QUEUESIZE -5", "42X44"}, {"CREATE DISKSTORE QS2 QUEUESIZE 0", null}, {"CREATE DISKSTORE QS3 QUEUESIZE 2147473648", null}, {"CREATE DISKSTORE QS4 QUEUESIZE '10'", "42X01"}, {"CREATE DISKSTORE QS5 QUEUESIZE fifteen", "42X01"}, {"CREATE DISKSTORE DIRTEST1 ('D1', 'D1')", "X0Z19"}, {"CREATE DISKSTORE DIRTEST2 ('../D1', '../D1')", "X0Z19"}, // FIXME { "CREATE DISKSTORE DIRTEST3 ('SUBDIR1', 'SUBDIR2', 'SUBDIR3')", "42X01" }, // FIXME { "CREATE DISKSTORE DIRTEST4 ('/dev/nul')", "42X01" }, // or some other unwritable // directory {"CREATE DISKSTORE DIRTEST5 ('')", "0A000"}, // FIXME { "CREATE DISKSTORE DIRTEST6 ('*')", "0A000" }, // FIXME { "CREATE DISKSTORE DIRTEST7 ('?')", "0A000" }, // or any other illegal character {"CREATE DISKSTORE DIRTEST8 'DIR1' 700 TIMEINTERVAL 1000 'DIR2' 1000", null}, {"CREATE DISKSTORE DIRTEST9 'DIR1' 0", "42X01"}, { "CREATE DISKSTORE EVERYTHING1 'DIR1' 700 TIMEINTERVAL 1000 AUTOCOMPACT false QUEUESIZE 75 WRITEBUFFERSIZE 32767 COMPACTIONTHRESHOLD 25 MAXLOGSIZE 699 ALLOWFORCECOMPACTION false", null }, { "CREATE DISKSTORE EVERYTHING2 TIMEINTERVAL 999 WRITEBUFFERSIZE 19776 QUEUESIZE 0 AUTOCOMPACT true COMPACTIONTHRESHOLD 55 ALLOWFORCECOMPACTION true MAXLOGSIZE 125000 ('EVERYTHING1' 500, 'EVERYTHING2' 1500, 'EVERYTHING3')", "X0Z33" }, { "CREATE DISKSTORE EVERYTHING2 TIMEINTERVAL 999 WRITEBUFFERSIZE 19776 QUEUESIZE 0 AUTOCOMPACT true COMPACTIONTHRESHOLD 55 ALLOWFORCECOMPACTION true MAXLOGSIZE 500 ('EVERYTHING1' 500, 'EVERYTHING2' 1500, 'EVERYTHING3')", null } }; Connection conn = TestUtil.getConnection(); Statement stmt = conn.createStatement(); // Go through the array, execute each string[0], check sqlstate [1] // This will fail on the first one that succeeds where it shouldn't // or throws unknown exception JDBC.SQLUnitTestHelper(stmt, CreateDiskStoreUT); // TODO : verify columns in catalog }
// This test is the as-is LangScript conversion, without any partitioning clauses public void testLangScript_SchemasTestNoPartitioning() throws Exception { // This is a JUnit conversion of the Derby Lang Schemas.sql script // without any GemFireXD extensions // Catch exceptions from illegal syntax // Tests still not fixed marked FIXME // Array of SQL text to execute and sqlstates to expect // The first object is a String, the second is either // 1) null - this means query returns no rows and throws no exceptions // 2) a string - this means query returns no rows and throws expected SQLSTATE // 3) a String array - this means query returns rows which must match (unordered) given // resultset // - for an empty result set, an uninitialized size [0][0] array is used Object[][] Script_SchemasUT = { {"create table myschem.t(c int)", null}, {"insert into t values (1)", "42X05"}, {"insert into blah.t values (2)", "42Y07"}, {"insert into blah.blah.t values (3)", "42X01"}, {"insert into blah.blah.blah.t values (3)", "42X01"}, {"create table mycat.myschem.s(c int)", "42X01"}, {"create table myworld.mycat.myschem.s(c int)", "42X01"}, {" create table myschem.s(c int)", null}, {"insert into s values (1)", "42X05"}, {"insert into honk.s values (2)", "42Y07"}, {"insert into honk.blat.s values (3)", "42X01"}, {"insert into loud.honk.blat.s values (4)", "42X01"}, {"drop table xyzzy.t", "42Y07"}, {"drop table goodness.gosh.s", "42X01"}, {"drop table gosh.s", "42Y07"}, {"create table mytab (i int)", null}, {"create table APP.mytab2 (i int)", null}, {"insert into mytab values 1,2,3", null}, {"insert into APP.mytab2 values 1,2,3", null}, {"select i, mytab.i from mytab", new String[][] {{"1", "1"}, {"2", "2"}, {"3", "3"}}}, {"select APP.mytab2.i from APP.mytab2", new String[][] {{"1"}, {"2"}, {"3"}}}, {"select APP.mytab2.i from mytab2", new String[][] {{"1"}, {"2"}, {"3"}}}, {"select mytab2.i from APP.mytab2", new String[][] {{"1"}, {"2"}, {"3"}}}, {"select m.i from APP.mytab2 m", new String[][] {{"1"}, {"2"}, {"3"}}}, {"select nocatalogs.APP.mytab.i from mytab2", "42X04"}, {"drop table mytab", null}, {"drop table APP.mytab2", null}, {"create schema app", "X0Y68"}, {"create schema sys", "42939"}, {"drop schema does_not_exist RESTRICT", "42Y07"}, {"create schema app", "X0Y68"}, {"create schema APP", "X0Y68"}, {"create schema SYS", "42939"}, {"create schema sysibm", "42939"}, {"create schema syscat", "42939"}, {"create schema sysfun", "42939"}, {"create schema sysproc", "42939"}, {"create schema sysstat", "42939"}, {"create schema syscs_diag", "42939"}, {"create schema syscs_util", "42939"}, {"create schema nullid", "X0Y68"}, {"create schema sqlj", "X0Y68"}, {"create table syscat.foo1 (a int)", "42X62"}, {"create table sysfun.foo2 (a int)", "42X62"}, {"create table sysproc.foo3 (a int)", "42X62"}, {"create table sysstat.foo4 (a int)", "42X62"}, {"create table syscs_diag.foo6 (a int)", "42X62"}, {"create table nullid.foo7 (a int)", "42X62"}, {"create table sysibm.foo8 (a int)", "42X62"}, {"create table sqlj.foo8 (a int)", "42X62"}, {"create table syscs_util.foo9 (a int)", "42X62"}, {"create table SYSCAT.foo1 (a int)", "42X62"}, {"create table SYSFUN.foo2 (a int)", "42X62"}, {"create table SYSPROC.foo3 (a int)", "42X62"}, {"create table SYSSTAT.foo4 (a int)", "42X62"}, {"create table SYSCS_DIAG.foo6 (a int)", "42X62"}, {"create table SYSIBM.foo8 (a int)", "42X62"}, {"create table SQLJ.foo8 (a int)", "42X62"}, {"create table SYSCS_UTIL.foo9 (a int)", "42X62"}, { "drop schema app RESTRICT", null }, // GemFireXD allows dropping default APP schema, Derby did not! {"drop schema APP RESTRICT", "42Y07"}, {"drop schema sys RESTRICT", "42Y67"}, {"drop schema SYS RESTRICT", "42Y67"}, {"drop schema sysibm RESTRICT", "42Y67"}, {"drop schema syscat RESTRICT", "42Y67"}, {"drop schema sysfun RESTRICT", "42Y67"}, {"drop schema sysproc RESTRICT", "42Y67"}, {"drop schema sysstat RESTRICT", "42Y67"}, {"drop schema syscs_diag RESTRICT", "42Y67"}, {"drop schema syscs_util RESTRICT", "42Y67"}, {"drop schema nullid RESTRICT", "42Y67"}, {"drop schema sqlj RESTRICT", "42Y67"}, {"create schema app", null}, {"set schema app", null}, {"create table test (a int)", null}, {"set schema syscat", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema sysfun", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema sysproc", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema sysstat", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema sysstat", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema syscs_diag", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema syscs_util", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema nullid", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema sysibm", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema sqlj", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema SYSCAT", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema SYSFUN", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema SYSPROC", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema SYSSTAT", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema SYSSTAT", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema SYSCS_DIAG", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema SYSCS_UTIL", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema NULLID", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema SYSIBM", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema SQLJ", null}, {"create table foo1 (a int)", "42X62"}, {"create view foo1 as select * from app.test", "42X62"}, {"set schema app", null}, {"create table t1 (c1 int)", null}, { "create trigger sysblah.trig1 after update of c1 on t1 for each row insert into t1 values 1", "42X62" }, { "create procedure sysblah.dummy() language java external name 'NotReallyThere.NoMethod' parameter style java", "42X62" }, {"drop table t1", null}, {"create schema test", null}, {"create schema test", "X0Y68"}, { "select schemaname, authorizationid from sys.sysschemas where CAST(schemaname AS VARCHAR(128)) = 'TEST'", new String[][] {{"TEST", "APP"}} }, {"set schema test", null}, {"create table sampletab (c1 int constraint st_c1 check (c1 > 1), c2 char(20))", null}, {"insert into sampletab values (1,'in schema: TEST')", "23513"}, {"insert into sampletab values (2,'in schema: TEST')", null}, { "select schemaname, tablename, descriptor from sys.sysschemas s, sys.sysconglomerates c , sys.systables t where CAST(t.tablename AS VARCHAR(128)) = 'SAMPLETAB' and s.schemaid = c.schemaid and c.tableid = t.tableid", new String[][] {{"TEST", "SAMPLETAB", null}} }, {"create index ixsampletab on sampletab(c1)", null}, {"create index ix2sampletab on test.sampletab(c1)", null}, {"create view vsampletab as select * from sampletab", null}, {"create view v2sampletab as select * from test.sampletab", null}, {"set schema APP", null}, {"create table sampletab (c1 int constraint st_c1 check(c1 > 1), c2 char(20))", null}, {"insert into sampletab values (2,'in schema: APP')", null}, { "select schemaname, tablename, descriptor as descr from sys.sysschemas s, sys.sysconglomerates c , sys.systables t where CAST(t.tablename AS VARCHAR(128)) = 'SAMPLETAB' and s.schemaid = c.schemaid and c.tableid = t.tableid order by schemaname, tablename", new String[][] { {"APP", "SAMPLETAB", null}, {"TEST", "SAMPLETAB", "LOCALSORTEDMAP (1)"}, {"TEST", "SAMPLETAB", null} } }, // GEMFIREXD uses sortedmap, not btree indexes {"select * from sampletab", new String[][] {{"2", "in schema: APP"}}}, {"select * from test.sampletab", new String[][] {{"2", "in schema: TEST"}}}, {"drop schema test RESTRICT", "X0Y54"}, {"drop view test.vsampletab", null}, {"drop view test.v2sampletab", null}, {"drop index test.ixsampletab", null}, {"drop index test.ix2sampletab", "42X65"}, {"drop table sampletab", null}, {"drop table test.sampletab", null}, {"drop schema test RESTRICT", null}, {"create schema x", null}, {"set schema x", null}, {"create view vx as select * from sys.sysschemas", null}, {"drop schema x RESTRICT", "X0Y54"}, {"drop view x.vx", null}, {"create table x (x int)", null}, {"drop schema x restrict", "X0Y54"}, {"drop table x.x", null}, {"drop schema x cascade", "42X01"}, {"set schema app", null}, {"drop schema x restrict", null}, {"create schema test", null}, {"set schema test", null}, {"create table s (i int, s smallint, c char(30), vc char(30))", null}, {"create table t (i int, s smallint, c char(30), vc char(30))", null}, {"create table tt (ii int, ss smallint, cc char(30), vcvc char(30))", null}, {"create table ttt (iii int, sss smallint, ccc char(30), vcvcvc char(30))", null}, {"insert into s values (null, null, null, null)", null}, {"insert into s values (0, 0, '0', '0')", null}, {"insert into s values (1, 1, '1', '1')", null}, {"insert into t values (null, null, null, null)", null}, {"insert into t values (0, 0, '0', '0')", null}, {"insert into t values (1, 1, '1', '1')", null}, {"insert into t values (1, 1, '1', '1')", null}, {"insert into tt values (null, null, null, null)", null}, {"insert into tt values (0, 0, '0', '0')", null}, {"insert into tt values (1, 1, '1', '1')", null}, {"insert into tt values (1, 1, '1', '1')", null}, {"insert into tt values (2, 2, '2', '2')", null}, {"insert into ttt values (null, null, null, null)", null}, {"insert into ttt values (11, 11, '11', '11')", null}, {"insert into ttt values (11, 11, '11', '11')", null}, {"insert into ttt values (22, 22, '22', '22')", null}, {"set schema app", null}, {"insert into test.t values (2, 2, '2', '2')", null}, {"update test.t set s = 2 where i = 2", null}, {"update test.t set s = 2 where test.t.i = 2", null}, {"delete from test.t where i = 1", null}, { "select * from test.t", new String[][] {{null, null, null, null}, {"0", "0", "0", "0"}, {"2", "2", "2", "2"}} }, {"insert into test.t values (1, 1, '1', '1')", null}, {"insert into test.t values (1, 1, '1', '1')", null}, { "select * from test.t t1", new String[][] { {null, null, null, null}, {"0", "0", "0", "0"}, {"2", "2", "2", "2"}, {"1", "1", "1", "1"}, {"1", "1", "1", "1"} } }, { "select * from test.s where exists (select test.s.* from test.t)", new String[][] {{null, null, null, null}, {"0", "0", "0", "0"}, {"1", "1", "1", "1"}} }, { "DECLARE GLOBAL TEMPORARY TABLE SESSION.ISCT(c21 int) on commit delete rows not logged", null }, { "select count(*) from SYS.SYSSCHEMAS WHERE CAST(SCHEMANAME AS VARCHAR(128)) = 'SESSION'", new String[][] {{"0"}} }, {"drop table SESSION.ISCT", null}, {"create schema SYSDJD", "42939"}, {"drop schema SYSDJD restrict", "42Y07"} }; // Do not use partitioning as default, use replicate // (Some results are expected to be different with partitioning) skipDefaultPartitioned = true; Connection conn = TestUtil.getConnection(); Statement stmt = conn.createStatement(); // Go through the array, execute each string[0], check sqlstate [1] // This will fail on the first one that succeeds where it shouldn't // or throws unknown exception JDBC.SQLUnitTestHelper(stmt, Script_SchemasUT); }
// This test is the as-is LangScript conversion, without any partitioning clauses public void testLangScript_SelectTestNoPartitioning() throws Exception { // This is a JUnit conversion of the Derby Lang Select.sql script // without any GemFireXD extensions // Catch exceptions from illegal syntax // Tests still not fixed marked FIXME // Array of SQL text to execute and sqlstates to expect // The first object is a String, the second is either // 1) null - this means query returns no rows and throws no exceptions // 2) a string - this means query returns no rows and throws expected SQLSTATE // 3) a String array - this means query returns rows which must match (unordered) given // resultset // - for an empty result set, an uninitialized size [0][0] array is used Object[][] Script_SelectUT = { {"create table t(i int, s smallint)", null}, {"insert into t (i,s) values (1956,475)", null}, {"select i from t", new String[][] {{"1956"}}}, {"select i,s from t", new String[][] {{"1956", "475"}}}, {"select s,i from t", new String[][] {{"475", "1956"}}}, { "select i,i,s,s,i,i from t", new String[][] {{"1956", "1956", "475", "475", "1956", "1956"}} }, {"select 10 from t", new String[][] {{"10"}}}, {"select t.i from t", new String[][] {{"1956"}}}, {"select b.i from t b", new String[][] {{"1956"}}}, {"select *, 10, i from t", "42X01"}, {"select b.* from t b", new String[][] {{"1956", "475"}}}, {"select t.* from t", new String[][] {{"1956", "475"}}}, {"(select * from t)", new String[][] {{"1956", "475"}}}, // ?! {"select * from t where i", "42X19"}, {"select asdf.* from t", "42X10"}, {"drop table t", null}, // FIXME // This large collection of tables should be partitioned, but the join makes colocation very // difficult // Use replicated for now {"CREATE SCHEMA CONTENT", null}, { "CREATE TABLE CONTENT.CONTENT (ID INTEGER NOT NULL, CREATOR VARCHAR(128) NOT NULL, CREATION_DATE DATE NOT NULL, URL VARCHAR(256) NOT NULL, TITLE VARCHAR(128) NOT NULL, DESCRIPTION VARCHAR(512) NOT NULL, HEIGHT INTEGER NOT NULL, WIDTH INTEGER NOT NULL) REPLICATE", null }, {"ALTER TABLE CONTENT.CONTENT ADD CONSTRAINT CONTENT_ID PRIMARY KEY (ID)", null}, { "CREATE TABLE CONTENT.STYLE (ID INTEGER NOT NULL,DESCRIPTION VARCHAR(128) NOT NULL) REPLICATE", null }, {"ALTER TABLE CONTENT.STYLE ADD CONSTRAINT STYLE_ID PRIMARY KEY (ID)", null}, { "CREATE TABLE CONTENT.CONTENT_STYLE (CONTENT_ID INTEGER NOT NULL, STYLE_ID INTEGER NOT NULL) REPLICATE", null }, { "ALTER TABLE CONTENT.CONTENT_STYLE ADD CONSTRAINT CONTENTSTYLEID PRIMARY KEY (CONTENT_ID, STYLE_ID)", null }, { "CREATE TABLE CONTENT.KEYGEN (KEYVAL INTEGER NOT NULL, KEYNAME VARCHAR(256) NOT NULL) REPLICATE", null }, {"ALTER TABLE CONTENT.KEYGEN ADD CONSTRAINT PK_KEYGEN PRIMARY KEY (KEYNAME)", null}, { "CREATE TABLE CONTENT.RATING (ID INTEGER NOT NULL,RATING DOUBLE PRECISION NOT NULL,ENTRIES DOUBLE PRECISION NOT NULL) REPLICATE", null }, {"ALTER TABLE CONTENT.RATING ADD CONSTRAINT PK_RATING PRIMARY KEY (ID)", null}, {"INSERT INTO CONTENT.STYLE VALUES (1, 'BIRD')", null}, {"INSERT INTO CONTENT.STYLE VALUES (2, 'CAR')", null}, {"INSERT INTO CONTENT.STYLE VALUES (3, 'BUILDING')", null}, {"INSERT INTO CONTENT.STYLE VALUES (4, 'PERSON')", null}, { "INSERT INTO CONTENT.CONTENT values(1, 'djd', CURRENT DATE, 'http://url.1', 'title1', 'desc1', 100, 100)", null }, { "INSERT INTO CONTENT.CONTENT values(2, 'djd', CURRENT DATE, 'http://url.2', 'title2', 'desc2', 100, 100)", null }, { "INSERT INTO CONTENT.CONTENT values(3, 'djd', CURRENT DATE, 'http://url.3', 'title3', 'desc3', 100, 100)", null }, { "INSERT INTO CONTENT.CONTENT values(4, 'djd', CURRENT DATE, 'http://url.4', 'title4', 'desc4', 100, 100)", null }, { "INSERT INTO CONTENT.CONTENT values(5, 'djd', CURRENT DATE, 'http://url.5', 'title5', 'desc5', 100, 100)", null }, {"INSERT INTO CONTENT.CONTENT_STYLE VALUES(1,1)", null}, {"INSERT INTO CONTENT.CONTENT_STYLE VALUES(1,2)", null}, {"INSERT INTO CONTENT.CONTENT_STYLE VALUES(2,1)", null}, {"INSERT INTO CONTENT.CONTENT_STYLE VALUES(2,4)", null}, {"INSERT INTO CONTENT.CONTENT_STYLE VALUES(3,3)", null}, {"INSERT INTO CONTENT.CONTENT_STYLE VALUES(3,4)", null}, {"INSERT INTO CONTENT.CONTENT_STYLE VALUES(3,1)", null}, {"INSERT INTO CONTENT.CONTENT_STYLE VALUES(4,4)", null}, {"INSERT INTO CONTENT.CONTENT_STYLE VALUES(5,1)", null}, {"INSERT INTO CONTENT.RATING VALUES(1, 4.5, 1)", null}, {"INSERT INTO CONTENT.RATING VALUES(2, 4.0, 1)", null}, {"INSERT INTO CONTENT.RATING VALUES(3, 3.9, 1)", null}, {"INSERT INTO CONTENT.RATING VALUES(4, 4.1, 1)", null}, {"INSERT INTO CONTENT.RATING VALUES(5, 4.0, 1)", null}, { "select S.DESCRIPTION, FAV.MAXRATE, C.TITLE, C.URL FROM CONTENT.RATING R, CONTENT.CONTENT C, CONTENT.STYLE S, CONTENT.CONTENT_STYLE CS, (select S.ID, max(rating) from CONTENT.RATING R, CONTENT.CONTENT C, CONTENT.STYLE S, CONTENT.CONTENT_STYLE CS group by S.ID) AS FAV(FID,MAXRATE) where R.ID = C.ID AND C.ID = CS.CONTENT_ID AND CS.STYLE_ID = FAV.FID AND FAV.FID = S.ID AND FAV.MAXRATE = R.RATING", new String[][] { {"BIRD", "4.5", "title1", "http://url.1"}, {"CAR", "4.5", "title1", "http://url.1"} } }, {"drop table content.rating", null}, {"drop table content.content_style", null}, {"drop table content.content", null}, {"drop table content.style", null}, {"drop table content.keygen", null}, {"drop schema content restrict", null} }; // Start 1 client and 3 servers, use default partitioning startVMs(1, 3); Connection conn = TestUtil.getConnection(); Statement stmt = conn.createStatement(); // Go through the array, execute each string[0], check sqlstate [1] // This will fail on the first one that succeeds where it shouldn't // or throws unknown exception JDBC.SQLUnitTestHelper(stmt, Script_SelectUT); }