| /* |
| Derby - Class org.apache.derbyTesting.functionTests.tests.jdbcapi.CallableTest |
| Licensed to the Apache Software Foundation (ASF) under one |
| or more contributor license agreements. See the NOTICE file |
| distributed with this work for additional information |
| regarding copyright ownership. The ASF licenses this file |
| to you under the Apache License, Version 2.0 (the |
| "License"); you may not use this file except in compliance |
| with the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, |
| software distributed under the License is distributed on an |
| "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| KIND, either express or implied. See the License for the |
| specific language governing permissions and limitations |
| under the License. |
| */ |
| |
| package org.apache.derbyTesting.functionTests.tests.jdbcapi; |
| |
| import java.io.BufferedReader; |
| import java.io.ByteArrayInputStream; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.sql.BatchUpdateException; |
| import java.sql.CallableStatement; |
| import java.sql.Connection; |
| import java.sql.Date; // Used by testUpdateLongBinaryProc |
| import java.sql.DriverManager; |
| import java.sql.PreparedStatement; |
| import java.sql.ResultSet; |
| import java.sql.SQLException; |
| import java.sql.SQLFeatureNotSupportedException; |
| import java.sql.Statement; |
| import java.sql.Time; |
| import java.sql.Timestamp; |
| import java.sql.Types; |
| import java.util.Arrays; |
| import java.util.Calendar; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.TimeZone; |
| import junit.framework.Test; |
| import org.apache.derbyTesting.junit.BaseJDBCTestCase; |
| import org.apache.derbyTesting.junit.BaseTestSuite; |
| import org.apache.derbyTesting.junit.CleanDatabaseTestSetup; |
| import org.apache.derbyTesting.junit.JDBC; |
| import org.apache.derbyTesting.junit.TestConfiguration; |
| |
| /** |
| * Test the CallableStatement interface. |
| * <p> |
| * This test converts the old derbynet/callable.java test to JUnit. It |
| * exercises the CallableStatement interface with various combinations of |
| * |
| * IN, OUT and INOUT registered parameters, |
| * SQL functions and procedures, and |
| * different data types. |
| */ |
| public class CallableTest extends BaseJDBCTestCase { |
| |
| /** |
| * Routines that should be created before the tests are run and |
| * dropped when the tests have finished. |
| */ |
| private static final String[] ROUTINES = { |
| |
| "CREATE PROCEDURE TWO_IN_ONE_OUT_PROC " + |
| "(IN P1 INT, IN P2 INT, OUT P3 INT) " + |
| "NO SQL LANGUAGE JAVA PARAMETER STYLE JAVA EXTERNAL NAME '" + |
| CallableTest.class.getName() + ".twoInOneOutProc'", |
| |
| "CREATE FUNCTION ONE_IN_ONE_OUT_FUNC (P1 INT) RETURNS INT " + |
| "NO SQL LANGUAGE JAVA PARAMETER STYLE JAVA EXTERNAL NAME '" + |
| CallableTest.class.getName() + ".oneInOneOutFunc'", |
| |
| "CREATE FUNCTION NO_IN_ONE_OUT_FUNC() RETURNS INT " + |
| "NO SQL LANGUAGE JAVA PARAMETER STYLE JAVA EXTERNAL NAME '" + |
| CallableTest.class.getName() + ".noInOneOutFunc'", |
| |
| "CREATE PROCEDURE SYSTEM_OUT_PRINTLN_PROC() " + |
| "NO SQL LANGUAGE JAVA PARAMETER STYLE JAVA EXTERNAL NAME '" + |
| CallableTest.class.getName() + ".systemOutPrintlnProc'", |
| |
| "CREATE PROCEDURE UPDATE_LONGVARBINARY_PROC " + |
| "(P1 VARCHAR(10000) FOR BIT DATA) MODIFIES SQL DATA " + |
| "LANGUAGE JAVA PARAMETER STYLE JAVA EXTERNAL NAME '" + |
| CallableTest.class.getName() + ".updateLongVarbinaryProc'", |
| |
| "CREATE PROCEDURE NUMERIC_BOUNDARIES_PROC " + |
| "(OUT P1 DECIMAL(31,15), OUT P2 DECIMAL(31,15), " + |
| "OUT P3 DECIMAL(31,15)) " + |
| "READS SQL DATA LANGUAGE JAVA PARAMETER STYLE JAVA EXTERNAL NAME '" + |
| CallableTest.class.getName() + ".numericBoundariesProc'", |
| |
| "CREATE PROCEDURE NUMERIC_TYPES_IN_AND_OUT_PROC " + |
| "(IN P1 SMALLINT, IN P2 INT, IN P3 BIGINT, " + |
| "IN P4 REAL, IN P5 DOUBLE, IN P6 DECIMAL(6,3), " + |
| "OUT O1 SMALLINT, OUT O2 INT, OUT O3 BIGINT, " + |
| "OUT O4 REAL, OUT O5 DOUBLE, OUT O6 DECIMAL(6,3) ) " + |
| "NO SQL LANGUAGE JAVA PARAMETER STYLE JAVA EXTERNAL NAME '" + |
| CallableTest.class.getName() + ".manyTypesInAndOutProc'", |
| |
| "CREATE PROCEDURE NON_NUMERIC_TYPES_IN_AND_OUT_PROC " + |
| "(IN P1 DATE, IN P2 TIME, IN P3 TIMESTAMP, " + |
| "IN P4 VARCHAR(20) FOR BIT DATA, " + |
| "OUT O1 DATE, OUT O2 TIME, OUT O3 TIMESTAMP, " + |
| "OUT O4 VARCHAR(20) FOR BIT DATA) " + |
| "NO SQL LANGUAGE JAVA PARAMETER STYLE JAVA EXTERNAL NAME '" + |
| CallableTest.class.getName() + ".manyTypesInAndOutProc'", |
| |
| "CREATE PROCEDURE MANY_TYPES_INOUT_PROC " + |
| "(IN P1 SMALLINT, INOUT P2 SMALLINT, IN P3 INT, INOUT P4 INT, " + |
| "IN P5 BIGINT, INOUT P6 BIGINT, IN P7 REAL, INOUT P8 REAL, " + |
| "IN P9 DOUBLE, INOUT P10 DOUBLE, IN P11 TIME, INOUT P12 TIME) " + |
| "NO SQL LANGUAGE JAVA PARAMETER STYLE JAVA EXTERNAL NAME '" + |
| CallableTest.class.getName() + ".manyTypesInoutProc'", |
| |
| "CREATE PROCEDURE BIGDECIMAL_IN_AND_OUT_PROC " + |
| "(IN P1 DECIMAL(14,4), OUT P2 DECIMAL(14,4), " + |
| "IN P3 DECIMAL(14,4), OUT P4 DECIMAL(14,4), " + |
| "OUT P5 DECIMAL(14,4), OUT P6 DECIMAL(14,4), " + |
| "OUT P7 DECIMAL(14,4), OUT P8 DECIMAL(14,4), " + |
| "OUT P9 DECIMAL(14,4)) EXTERNAL NAME '" + |
| CallableTest.class.getName() + ".bigDecimalInAndOutProc' " + |
| "NO SQL LANGUAGE JAVA PARAMETER STYLE JAVA", |
| |
| "CREATE PROCEDURE BATCH_UPDATE_PROC " + |
| "(P1 INT, P2 INT) MODIFIES SQL DATA " + |
| "LANGUAGE JAVA PARAMETER STYLE JAVA EXTERNAL NAME '" + |
| CallableTest.class.getName() + ".batchUpdateProc'" |
| }; |
| |
| /** |
| * Tables that should be created before the tests are run and |
| * dropped when the tests have finished. The first element in each row |
| * is the name of the table and the second element is the SQL text that |
| * creates it. |
| */ |
| private static final String[][] TABLES = { |
| // LONGVARBINARY_TABLE is used by UPDATE_LONGVARBINARY_PROC |
| { "LONGVARBINARY_TABLE", |
| "CREATE TABLE LONGVARBINARY_TABLE (lvbc Long varchar for bit data)" }, |
| |
| // NUMERIC_BOUNDARIES_TABLE is used by NUMERIC_BOUNDARIES_PROC |
| { "NUMERIC_BOUNDARIES_TABLE", |
| "CREATE TABLE NUMERIC_BOUNDARIES_TABLE " + |
| "(maxcol NUMERIC(31,15), mincol NUMERIC(15,15), nulcol NUMERIC)"}, |
| |
| // BATCH_UPDATE is used by BATCH_UPDATE_PROC |
| { "BATCH_TABLE", |
| "CREATE TABLE BATCH_TABLE " + |
| "(id int, tag varchar(32), " + |
| "idval int constraint idval_ck check (idval >= 0))"}, |
| }; |
| |
| /** |
| * Creates a new <code>CallableTest</code> instance. |
| * |
| * @param name name of the test |
| */ |
| public CallableTest(String name) { |
| super(name); |
| } |
| |
| public static Test suite() { |
| BaseTestSuite suite = new BaseTestSuite("CallableTest"); |
| |
| suite.addTest(baseSuite("CallableTest:embedded")); |
| |
| suite.addTest(TestConfiguration.clientServerDecorator( |
| baseSuite("CallableTest:client"))); |
| |
| // Test with ConnectionPoolDataSource on client in order to exercise |
| // LogicalCallableStatement (DERBY-5871). |
| suite.addTest(TestConfiguration.clientServerDecorator( |
| TestConfiguration.connectionCPDecorator( |
| baseSuite("CallableTest:logical")))); |
| |
| // Test with XADataSource on embedded in order to exercise |
| // BrokeredCallableStatement (DERBY-5854). |
| suite.addTest(TestConfiguration.connectionXADecorator( |
| baseSuite("CallableTest:brokered"))); |
| |
| return suite; |
| } |
| |
| private static Test baseSuite(String name) { |
| |
| BaseTestSuite suite = new BaseTestSuite(name); |
| |
| // Add tests that every JVM should be able to run. |
| suite.addTestSuite(CallableTest.class); |
| |
| // Add tests that require JDBC 3 |
| if (JDBC.vmSupportsJDBC3()) { |
| |
| // Tests that require DriverManager. |
| suite.addTest |
| (new CallableTest("xtestUpdateLongBinaryProc")); |
| |
| // Tests that require DriverManager and batch update. |
| suite.addTest |
| (new CallableTest("xtestBatchUpdate")); |
| suite.addTest |
| (new CallableTest("xtestBatchUpdateError")); |
| |
| // Tests that get/set BigDecimal |
| suite.addTest |
| (new CallableTest("xtestBigDecimalInAndOutProc")); |
| suite.addTest |
| (new CallableTest("xtestNumericTypesInAndOutProc")); |
| |
| // Test that both requires DriverManager and BigDecimal |
| suite.addTest |
| (new CallableTest("xtestNumericBoundariesProc")); |
| } |
| |
| |
| return new CleanDatabaseTestSetup(suite) |
| { |
| /** |
| * Creates the tables and the stored procedures used in the test |
| * cases. |
| * @throws SQLException |
| */ |
| protected void decorateSQL(Statement s) throws SQLException |
| { |
| for (int i = 0; i < ROUTINES.length; i++) { |
| s.execute(ROUTINES[i]); |
| } |
| for (int i = 0; i < TABLES.length; i++) { |
| s.execute(TABLES[i][1]); |
| } |
| } |
| }; |
| } // End baseSuite |
| |
| /** |
| * Sets up the connection for a test case and clears all tables |
| * used in the test cases. |
| * @throws SQLException |
| */ |
| public void setUp() throws SQLException |
| { |
| Connection conn = getConnection(); |
| conn.setAutoCommit(false); |
| Statement s = createStatement(); |
| for (int i = 0; i < TABLES.length; i++) { |
| s.execute("DELETE FROM " + TABLES[i][0]); |
| } |
| s.close(); |
| conn.commit(); |
| } |
| |
| // TESTS |
| |
| /** |
| * Calls a SQL procedure with two input parameters and one output. |
| * @throws SQLException |
| */ |
| public void testTwoInOneOutProc() throws SQLException |
| { |
| CallableStatement cs = prepareCall |
| ("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| cs.setInt(1, 6); |
| cs.setInt(2, 9); |
| cs.registerOutParameter (3, java.sql.Types.INTEGER); |
| cs.execute(); |
| assertEquals("Sum of 6 and 9", 15, cs.getInt(3)); |
| |
| } |
| |
| /** |
| * Calls a SQL function with one input parameter and one output. |
| * @throws SQLException |
| */ |
| public void testOneInOneOutFunc() throws SQLException |
| { |
| CallableStatement cs = prepareCall |
| ("? = call ONE_IN_ONE_OUT_FUNC (?)"); |
| cs.registerOutParameter (1, java.sql.Types.INTEGER); |
| cs.setInt(2, 6); |
| cs.execute(); |
| assertEquals("Square of 6 then plus 6", 42, cs.getInt(1)); |
| } |
| |
| /** |
| * Calls a SQL function that takes no input parameter and returns one |
| * output. |
| * @throws SQLException |
| */ |
| public void testNoInOneOutFunc() throws SQLException |
| { |
| CallableStatement cs = prepareCall |
| ("? = call NO_IN_ONE_OUT_FUNC()"); |
| cs.registerOutParameter (1, java.sql.Types.INTEGER); |
| cs.execute(); |
| assertEquals("NO_IN_ONE_OUT_FUNC output value", 55, cs.getInt(1)); |
| |
| } |
| |
| public void testIsolationLevelChangeAfterFunctionCall() |
| throws SQLException { |
| CallableStatement cs = prepareCall("? = CALL NO_IN_ONE_OUT_FUNC()"); |
| cs.registerOutParameter(1, java.sql.Types.INTEGER); |
| cs.execute(); |
| assertEquals(55, cs.getInt(1)); |
| getConnection().setTransactionIsolation( |
| Connection.TRANSACTION_SERIALIZABLE); |
| } |
| |
| /** |
| * Calls a SQL procedure that outputs a message with System.out.println. |
| * Converted from the original test, but initially disabled because of the |
| * message output to system out. Easily enabled by changing method name to |
| * remove the initial "norun_" (the name becomes testSystemOutPrintlnProc). |
| * @throws SQLException |
| */ |
| public void norun_testSystemOutPrintlnProc() throws SQLException |
| { |
| CallableStatement cs = prepareCall |
| ("call SYSTEM_OUT_PRINTLN_PROC()"); |
| cs.execute(); |
| cs.close(); |
| } |
| |
| /** |
| * Calls a SQL procedure that takes numeric IN and OUT parameters. |
| * Excluded from JSR169/j2ME, which doesn't support get/set BigDecimal yet. |
| * @throws SQLException |
| */ |
| public void xtestNumericTypesInAndOutProc() throws SQLException |
| { |
| CallableStatement cs = prepareCall |
| ("call NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?,?,?,?,?)"); |
| |
| cs.setShort(1, (short) 3); |
| cs.setInt(2, 4); |
| cs.setLong(3, 5); |
| cs.setFloat(4, (float) 6.0); |
| cs.setDouble(5, 7.0); |
| cs.setBigDecimal(6, new BigDecimal("88.88")); |
| |
| cs.registerOutParameter (7, java.sql.Types.SMALLINT); |
| cs.registerOutParameter (8, java.sql.Types.INTEGER); |
| cs.registerOutParameter (9, java.sql.Types.BIGINT); |
| cs.registerOutParameter (10, java.sql.Types.REAL); |
| cs.registerOutParameter (11, java.sql.Types.DOUBLE); |
| cs.registerOutParameter (12, java.sql.Types.DECIMAL); |
| |
| cs.execute(); |
| |
| assertEquals("OUT short", (short) 3, cs.getShort(7)); |
| assertEquals("OUT int" , 4, cs.getInt(8)); |
| assertEquals("OUT long" , 5, cs.getLong(9)); |
| assertEquals("OUT float" , (float) 6.0, cs.getFloat(10), .0001); |
| assertEquals("OUT double" , 7.0, cs.getDouble(11), .0001); |
| assertDecimalSameValue("OUT decimal", "88.88", cs.getBigDecimal(12)); |
| |
| // test that setObject() does the right thing for BigDecimal. see derby-5488. |
| cs.setObject(3, new BigDecimal( "10" ) ); |
| cs.execute(); |
| assertEquals("OUT long" , 10, cs.getLong(9)); |
| |
| // test that setObject() does the right thing for BigInteger. see derby-5488. |
| cs.setObject(3, new BigInteger( "11" ) ); |
| cs.execute(); |
| assertEquals("OUT long" , 11, cs.getLong(9)); |
| } |
| |
| /** |
| * Calls a SQL procedure that takes non-numeric IN and OUT parameters. |
| * @throws SQLException |
| */ |
| public void testNonNumericTypesInAndOutProc() throws SQLException |
| { |
| CallableStatement cs = prepareCall |
| ("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?)"); |
| |
| cs.setDate(1, Date.valueOf("2002-05-12")); |
| cs.setTime(2, Time.valueOf("10:05:02")); |
| cs.setTimestamp(3, Timestamp.valueOf("2002-05-12 10:05:02.000000000")); |
| byte[] ba = new byte[2]; |
| ba[0] = 1; |
| ba[1] = 2; |
| cs.setBytes(4, ba); |
| |
| cs.registerOutParameter (5, java.sql.Types.DATE); |
| cs.registerOutParameter (6, java.sql.Types.TIME); |
| cs.registerOutParameter (7, java.sql.Types.TIMESTAMP); |
| cs.registerOutParameter (8, java.sql.Types.VARBINARY); |
| |
| cs.execute(); |
| |
| assertEquals("OUT date", Date.valueOf("2002-05-12"), cs.getDate(5)); |
| assertEquals("OUT time" , Time.valueOf("10:05:02"), cs.getTime(6)); |
| assertEquals("OUT timestamp" , |
| Timestamp.valueOf("2002-05-12 10:05:02.000000000"), |
| cs.getTimestamp(7)); |
| assertTrue(Arrays.equals(ba, cs.getBytes(8))); |
| } |
| |
| /** |
| * Test that the getters and setters for Date, Time and Timestamp work as |
| * expected when given a Calendar argument. Test case for DERBY-4615. |
| */ |
| public void testTimeAndDateWithCalendar() throws SQLException { |
| // Create calendars for some time zones to use when testing the |
| // setter methods. |
| Calendar[] cal1 = { |
| Calendar.getInstance(), // local calendar |
| Calendar.getInstance(TimeZone.getTimeZone("GMT")), |
| Calendar.getInstance(TimeZone.getTimeZone("Europe/Oslo")), |
| Calendar.getInstance(TimeZone.getTimeZone("Asia/Hong_Kong")), |
| }; |
| |
| // Use calendars for the same time zones in the getters, but create |
| // clones so that we don't get interference between the calendars. |
| Calendar[] cal2 = (Calendar[]) cal1.clone(); |
| for (int i = 0; i < cal2.length; i++) { |
| cal2[i] = (Calendar) cal2[i].clone(); |
| } |
| |
| // Now test all the combinations. |
| for (int i = 0; i < cal1.length; i++) { |
| for (int j = 0; j < cal2.length; j++) { |
| testTimeAndDateWithCalendar(cal1[i], cal2[j]); |
| } |
| } |
| } |
| |
| /** |
| * Private helper for {@link #testTimeAndDateWithCalendar()}. This method |
| * calls a procedure that takes Date, Time and Timestamp arguments and |
| * returns the exact same values. Call the setters with one calendar and |
| * the getters with another calendar, and verify that the expected |
| * conversion between time zones has happened. |
| * |
| * @param cal1 the calendar to use for the setter methods |
| * @param cal2 the calendar to use for the getter methods |
| */ |
| private void testTimeAndDateWithCalendar(Calendar cal1, Calendar cal2) |
| throws SQLException |
| { |
| println("Running " + getName() + "() with " + |
| cal1.getTimeZone().getDisplayName() + " and " + |
| cal2.getTimeZone().getDisplayName()); |
| |
| CallableStatement cs = prepareCall( |
| "call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?)"); |
| |
| Date d = Date.valueOf("2010-04-14"); |
| Time t = Time.valueOf("12:23:24"); |
| Timestamp ts = new Timestamp(System.currentTimeMillis()); |
| ts.setNanos(123456789); |
| |
| cs.setDate(1, d, cal1); |
| cs.setTime(2, t, cal1); |
| cs.setTimestamp(3, ts, cal1); |
| cs.setNull(4, Types.VARBINARY); // we don't care about VARBINARY here |
| |
| cs.registerOutParameter (5, java.sql.Types.DATE); |
| cs.registerOutParameter (6, java.sql.Types.TIME); |
| cs.registerOutParameter (7, java.sql.Types.TIMESTAMP); |
| cs.registerOutParameter (8, java.sql.Types.VARBINARY); |
| |
| cs.execute(); |
| |
| assertSameDate(d, cal1, cs.getDate(5, cal2), cal2); |
| assertSameTime(t, cal1, cs.getTime(6, cal2), cal2); |
| vetTimestamp(ts, cal1, cs.getTimestamp(7, cal2), cal2); |
| } |
| |
| /** |
| * Assert that two {@code java.util.Date} values have the same |
| * representation of their date components (year, month and day) in their |
| * respective time zones. |
| * |
| * @param expected the expected date |
| * @param cal1 a calendar representing the time zone of the expected date |
| * @param actual the actual date |
| * @param cal2 a calendar representing the time zone of the actual date |
| */ |
| private void assertSameDate(java.util.Date expected, Calendar cal1, |
| java.util.Date actual, Calendar cal2) { |
| cal1.clear(); |
| cal1.setTime(expected); |
| int expectedYear = cal1.get(Calendar.YEAR); |
| int expectedMonth = cal1.get(Calendar.MONTH); |
| int expectedDay = cal1.get(Calendar.DAY_OF_MONTH); |
| |
| cal2.clear(); |
| cal2.setTime(actual); |
| assertEquals("year", expectedYear, cal2.get(Calendar.YEAR)); |
| assertEquals("month", expectedMonth, cal2.get(Calendar.MONTH)); |
| assertEquals("day", expectedDay, cal2.get(Calendar.DAY_OF_MONTH)); |
| } |
| |
| /** |
| * Assert that two {@code java.util.Date} values have the same |
| * representation of their time components (hour, minute, second) in their |
| * respective time zones. |
| * |
| * @param expected the expected time |
| * @param cal1 a calendar representing the time zone of the expected time |
| * @param actual the actual time |
| * @param cal2 a calendar representing the time zone of the actual time |
| */ |
| private void assertSameTime(java.util.Date expected, Calendar cal1, |
| java.util.Date actual, Calendar cal2) { |
| cal1.clear(); |
| cal1.setTime(expected); |
| int expectedHour = cal1.get(Calendar.HOUR_OF_DAY); |
| int expectedMinute = cal1.get(Calendar.MINUTE); |
| int expectedSecond = cal1.get(Calendar.SECOND); |
| |
| cal2.clear(); |
| cal2.setTime(actual); |
| assertEquals("hour", expectedHour, cal2.get(Calendar.HOUR_OF_DAY)); |
| assertEquals("minute", expectedMinute, cal2.get(Calendar.MINUTE)); |
| assertEquals("second", expectedSecond, cal2.get(Calendar.SECOND)); |
| } |
| |
| /** |
| * Check that a {@code Timestamp} value is as expected when it has been |
| * passed to a stored procedure and read back again from that procedure, |
| * using different calendars for the {@code setTimestamp()} and |
| * {@code getTimestamp()} calls. |
| * |
| * @param original the original timestamp that was passed to the procedure |
| * @param cal1 the calendar object passed to {@code setTimestamp()} before |
| * calling the procedure |
| * @param returned the timestamp returned from the procedure |
| * @param cal2 the calendar object passed to {@code getTimestamp()} when |
| * reading the value returned by the procedure |
| */ |
| private void vetTimestamp(Timestamp original, Calendar cal1, |
| Timestamp returned, Calendar cal2) { |
| |
| // Initialize cal1 with values from the original timestamp. |
| cal1.clear(); |
| cal1.setTime(original); |
| |
| // The stored procedure itself doesn't have any knowledge about the |
| // calendar passed to setTimestamp() or getTimestamp(), so it will |
| // see the timestamp in the local timezone. Find out what it looks |
| // like in this intermediate state. |
| Calendar intermediate = Calendar.getInstance(); |
| intermediate.set(cal1.get(Calendar.YEAR), |
| cal1.get(Calendar.MONTH), |
| cal1.get(Calendar.DATE), |
| cal1.get(Calendar.HOUR_OF_DAY), |
| cal1.get(Calendar.MINUTE), |
| cal1.get(Calendar.SECOND)); |
| |
| // The returned timestamp will be based on the values in the |
| // intermediate representation, but using the calendar passed to |
| // getTimestamp(). |
| cal2.clear(); |
| cal2.set(intermediate.get(Calendar.YEAR), |
| intermediate.get(Calendar.MONTH), |
| intermediate.get(Calendar.DATE), |
| intermediate.get(Calendar.HOUR_OF_DAY), |
| intermediate.get(Calendar.MINUTE), |
| intermediate.get(Calendar.SECOND)); |
| |
| // Construct a new timestamp with the value we expect to be returned |
| // from getTimestamp(). |
| Timestamp expected = new Timestamp(cal2.getTimeInMillis()); |
| expected.setNanos(original.getNanos()); |
| |
| // Compare it with the actually returned value. |
| assertEquals(expected, returned); |
| } |
| |
| /** |
| * Calls a SQL procedure that takes INOUT parameters of various types. |
| * @throws SQLException |
| */ |
| public void testManyTypesInoutProc() throws SQLException |
| { |
| CallableStatement cs = prepareCall |
| ("call MANY_TYPES_INOUT_PROC(?,?,?,?,?,?,?,?,?,?,?,?)"); |
| |
| cs.registerOutParameter (2, java.sql.Types.SMALLINT); |
| cs.registerOutParameter (4, java.sql.Types.INTEGER); |
| cs.registerOutParameter (6, java.sql.Types.BIGINT); |
| cs.registerOutParameter (8, java.sql.Types.REAL); |
| cs.registerOutParameter (10, java.sql.Types.DOUBLE); |
| cs.registerOutParameter (12, java.sql.Types.TIME); |
| |
| cs.setShort(1, (short)6); |
| cs.setShort(2, (short)9); |
| cs.setInt(3, 6); |
| cs.setInt(4, 9); |
| cs.setLong(5, (long)99999); |
| cs.setLong(6, (long)88888888); |
| cs.setFloat(7, (float)6.123453); |
| cs.setFloat(8, (float)77777); |
| cs.setDouble(9, (double)6.123453); |
| cs.setDouble(10, (double)8888888888888.01234); |
| cs.setTime(11, Time.valueOf("11:06:03")); |
| cs.setTime(12, Time.valueOf("10:05:02")); |
| |
| cs.execute(); |
| |
| assertEquals("Short: Sum of 6 + 9", 15, cs.getShort(2)); |
| assertEquals("Int: Sum of 6 + 9", 15, cs.getInt(4)); |
| assertEquals("Long: Sum of 99999 + 88888888", 88988887, cs.getLong(6)); |
| assertEquals("Float: Sum of 6.123453 and 77777" , (float) 77783.123453, |
| cs.getFloat(8), .000001); |
| assertEquals("Double: Sum of Sum of 6.987654 and 8888888888888.01234", |
| 8.888888888894135e12, cs.getDouble(10), .000001); |
| assertEquals("Time: changed to", Time.valueOf("11:06:03"), |
| cs.getTime(12)); |
| |
| } |
| |
| /** |
| * Calls a SQL procedure that updates a long varbinary column. |
| * Uses DriverManager, so this test requires JDBC 2 DriverManager support. |
| * @throws SQLException |
| */ |
| public void xtestUpdateLongBinaryProc() throws SQLException |
| { |
| // Insert a row with an initial value that will be updated later. |
| Statement stmt = createStatement(); |
| stmt.executeUpdate( |
| "INSERT INTO LONGVARBINARY_TABLE VALUES(X'010305')"); |
| |
| // Build up a byte array that will replace the initial value. |
| int bytearrsize = 50; |
| byte[] bytearr=new byte[bytearrsize]; |
| String sbyteval=null; |
| for (int count=0;count<bytearrsize;count++) |
| { |
| sbyteval=Integer.toString(count%255); |
| bytearr[count]=Byte.parseByte(sbyteval); |
| } |
| |
| // Update the value in the database. |
| CallableStatement cstmt = prepareCall( |
| "CALL UPDATE_LONGVARBINARY_PROC(?)"); |
| cstmt.setObject(1,bytearr,java.sql.Types.LONGVARBINARY); |
| cstmt.executeUpdate(); |
| |
| // Retrieve the updated value and verify it's correct. |
| ResultSet rs = stmt.executeQuery( |
| "SELECT LVBC FROM LONGVARBINARY_TABLE"); |
| assertNotNull("SELECT from LONGVARBINARY_TABLE", rs); |
| |
| while (rs.next()) |
| { |
| byte[] retvalue = (byte[]) rs.getObject(1); |
| assertTrue(Arrays.equals(bytearr, retvalue)); |
| } |
| } |
| |
| /** |
| * Batches up calls to a SQL procedure that updates a value in a table. |
| * Uses DriverManager and Batch calls, so requires JDBC 2 support. |
| * @throws SQLException |
| */ |
| public void xtestBatchUpdate() throws SQLException |
| { |
| // Setup table data |
| Statement stmt = createStatement(); |
| stmt.executeUpdate("INSERT INTO BATCH_TABLE VALUES(1, 'STRING_1',10)"); |
| stmt.executeUpdate("INSERT INTO BATCH_TABLE VALUES(2, 'STRING_2',0)"); |
| stmt.executeUpdate("INSERT INTO BATCH_TABLE VALUES(3, 'STRING_3',0)"); |
| stmt.executeUpdate("INSERT INTO BATCH_TABLE VALUES(4, 'STRING_4a',0)"); |
| stmt.executeUpdate("INSERT INTO BATCH_TABLE VALUES(4, 'STRING_4b',0)"); |
| |
| // Setup batch to modify value to 10 * the id (makes verification easy). |
| CallableStatement cstmt = prepareCall("CALL BATCH_UPDATE_PROC(?,?)"); |
| cstmt.setInt(1,2); // Id 2's value will be updated to 20. |
| cstmt.setInt(2,20); |
| cstmt.addBatch(); |
| cstmt.setInt(1,3); // Id 3's value will be updated to 30. |
| cstmt.setInt(2,30); |
| cstmt.addBatch(); |
| cstmt.setInt(1,4); // Two rows will be updated to 40 for id 4. |
| cstmt.setInt(2,40); |
| cstmt.addBatch(); |
| cstmt.setInt(1,5); // No rows updated (no id 5). |
| cstmt.setInt(2,50); |
| cstmt.addBatch(); |
| |
| int[] updateCount=null; |
| try { |
| updateCount = cstmt.executeBatch(); |
| assertEquals("updateCount length", 4, updateCount.length); |
| |
| for(int i=0; i< updateCount.length; i++){ |
| if (usingEmbedded()) { |
| assertEquals("Batch updateCount", 0, updateCount[0]); |
| } |
| else if (usingDerbyNetClient()) { |
| assertEquals("Batch updateCount", -1, updateCount[0]); |
| } |
| } |
| } catch (BatchUpdateException b) { |
| assertSQLState("Unexpected SQL State", b.getSQLState(), b); |
| } |
| |
| // Retrieve the updated values and verify they are correct. |
| ResultSet rs = stmt.executeQuery( |
| "SELECT id, tag, idval FROM BATCH_TABLE order by id, tag"); |
| assertNotNull("SELECT from BATCH_TABLE", rs); |
| |
| while (rs.next()) |
| { |
| assertEquals(rs.getString(2), rs.getInt(1)*10, rs.getInt(3)); |
| } |
| } |
| |
| |
| /** |
| * Batches up many calls to a SQL procedure that updates a value in a table. |
| * All calls should succeed, except for one that should fail with a check |
| * constraint violation. |
| * Uses DriverManager and Batch calls, so requires JDBC 2 support. |
| * @throws SQLException |
| */ |
| public void xtestBatchUpdateError() throws SQLException |
| { |
| // Setup table data |
| Statement stmt = createStatement(); |
| stmt.executeUpdate("INSERT INTO BATCH_TABLE VALUES(1, 'STRING_1',0)"); |
| stmt.executeUpdate("INSERT INTO BATCH_TABLE VALUES(2, 'STRING_2',0)"); |
| stmt.executeUpdate("INSERT INTO BATCH_TABLE VALUES(3, 'STRING_3',0)"); |
| stmt.executeUpdate("INSERT INTO BATCH_TABLE VALUES(4, 'STRING_4',0)"); |
| |
| // Setup batch to modify values. |
| CallableStatement cstmt = prepareCall("CALL BATCH_UPDATE_PROC(?,?)"); |
| cstmt.setInt(1,1); // Set id 1's value to 10 |
| cstmt.setInt(2,10); |
| cstmt.addBatch(); |
| cstmt.setInt(1,2); // Set id 2's value to -5 (should fail) |
| cstmt.setInt(2,-5); |
| cstmt.addBatch(); |
| cstmt.setInt(1,3); // Set id 3's value to 30. |
| cstmt.setInt(2,30); |
| cstmt.addBatch(); |
| cstmt.setInt(1,4); // Set id 4's value to 40. |
| cstmt.setInt(2,40); |
| cstmt.addBatch(); |
| |
| int[] updateCount=null; |
| |
| try { |
| updateCount = cstmt.executeBatch(); |
| fail("Expected batchExecute to fail"); |
| } catch (BatchUpdateException b) { |
| |
| if (usingEmbedded()) { |
| assertSQLState("38000", b.getSQLState(), b); |
| } |
| else if (usingDerbyNetClient()) { |
| assertSQLState("XJ208", b.getSQLState(), b); |
| } |
| |
| updateCount = b.getUpdateCounts(); |
| |
| /* The updateCount is different for embedded and client because |
| * the embedded driver stops processing the batch after the |
| * failure, while the client driver continues processing (see |
| * DERBY-2301). |
| */ |
| if (usingEmbedded()) { |
| assertEquals("updateCount length", 1, updateCount.length); |
| assertEquals("Batch updateCount", 0, updateCount[0]); |
| } |
| else if (usingDerbyNetClient()) { |
| assertEquals("updateCount length", 4, updateCount.length); |
| for(int i=0; i< updateCount.length; i++){ |
| if(i == 1) // The second command in the batch failed. |
| assertEquals("Batch updateCount", -3, updateCount[i]); |
| else |
| assertEquals("Batch updateCount", -1, updateCount[i]); |
| } |
| } |
| } |
| |
| // Make sure the right rows in the table were updated. |
| ResultSet rs = stmt.executeQuery( |
| "SELECT id, tag, idval FROM BATCH_TABLE order by id, tag"); |
| assertNotNull("SELECT from BATCH_TABLE", rs); |
| |
| while (rs.next()) |
| { |
| /* Embedded and client results should be the same for the first |
| * two rows (the changed row for the first successful command in |
| * the batch, followed by the unchanged row for the second command, |
| * which failed). |
| * After the first two rows, results are different because the |
| * rest of the commands in the batch executed for client, but not |
| * for embedded. |
| */ |
| switch(rs.getInt(1)) |
| { |
| case 1: |
| assertEquals(rs.getString(2), 10, rs.getInt(3)); |
| break; |
| case 2: |
| assertEquals(rs.getString(2), 0, rs.getInt(3)); |
| break; |
| default: |
| if (usingEmbedded()) { |
| assertEquals(rs.getString(2), 0, rs.getInt(3)); |
| } |
| else if (usingDerbyNetClient()) { |
| assertEquals(rs.getString(2), rs.getInt(1)*10, |
| rs.getInt(3)); |
| } |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Calls a SQL procedure that populates OUT parameters with minimum, |
| * maximum, and null values fetched from a table with numeric columns. |
| * Pre-history: long, long ago this test was added to exercise a problem |
| * with converting BigDecimal to packed decimal, which left the Network |
| * Server cpu bound. |
| * Excluded from environments than don't have JDBC 2 DriverManager. |
| * Excluded from JSR169/j2ME, which doesn't support get/set BigDecimal yet. |
| * @throws SQLException |
| */ |
| public void xtestNumericBoundariesProc() throws SQLException |
| { |
| // Populate the test table |
| String SqlStatement= |
| "insert into NUMERIC_BOUNDARIES_TABLE " + |
| "values(999999999999999, 0.000000000000001, null)"; |
| Statement stmt = createStatement(); |
| stmt.executeUpdate(SqlStatement); |
| |
| // SELECT the values back by calling the SQL procedure. |
| CallableStatement cstmt = prepareCall( |
| "CALL NUMERIC_BOUNDARIES_PROC(?,?,?)"); |
| cstmt.registerOutParameter(1,java.sql.Types.NUMERIC,15); |
| cstmt.registerOutParameter(2,java.sql.Types.NUMERIC,15); |
| cstmt.registerOutParameter(3,java.sql.Types.NUMERIC,15); |
| |
| cstmt.execute(); |
| |
| assertDecimalSameValue("OUT 1", "999999999999999.000000000000000", |
| cstmt.getBigDecimal(1)); |
| assertDecimalSameValue("OUT 2", "0.000000000000001", |
| cstmt.getBigDecimal(2)); |
| assertNull("Expected OUT 3 to be null", cstmt.getBigDecimal(3)); |
| |
| } |
| |
| /** |
| * Calls a SQL procedure with BigDecimal IN and OUT parameters. |
| * Excluded from JSR169/j2ME, which doesn't support get/set BigDecimal yet. |
| * @throws SQLException |
| */ |
| public void xtestBigDecimalInAndOutProc() throws SQLException |
| { |
| CallableStatement cs = prepareCall |
| ("CALL BIGDECIMAL_IN_AND_OUT_PROC (?, ?, ?, ?, ?, ?, ?, ?, ?)"); |
| cs.setBigDecimal(1, new BigDecimal("33.333")); |
| cs.registerOutParameter (2, java.sql.Types.DECIMAL); |
| cs.setBigDecimal(3, new BigDecimal("-999.999999")); |
| cs.registerOutParameter (4, java.sql.Types.DECIMAL); |
| cs.registerOutParameter (5, java.sql.Types.DECIMAL); |
| cs.registerOutParameter (6, java.sql.Types.DECIMAL); |
| cs.registerOutParameter (7, java.sql.Types.DECIMAL); |
| cs.registerOutParameter (8, java.sql.Types.DECIMAL); |
| cs.registerOutParameter (9, java.sql.Types.DECIMAL); |
| cs.execute(); |
| |
| assertDecimalSameValue("OUT 2", "33.3330", cs.getBigDecimal(2)); |
| assertDecimalSameValue("OUT 4", "-33332.9966", cs.getBigDecimal(4)); |
| assertDecimalSameValue("OUT 5", "-966.6669", cs.getBigDecimal(5)); |
| assertDecimalSameValue("OUT 6", "0.0000", cs.getBigDecimal(6)); |
| assertDecimalSameValue("OUT 7", "0.0000", cs.getBigDecimal(7)); |
| assertDecimalSameValue("OUT 8", "99999999.0000", cs.getBigDecimal(8)); |
| assertDecimalSameValue("OUT 9", "-99999999.0000", cs.getBigDecimal(9)); |
| } |
| |
| /** |
| * Wrapper for BigDecimal compareTo. |
| * Called by the xtestBigDecimalInAndOutProc, |
| * xtestNumericTypesInAndOutProc, and |
| * xtestNumericBoundariesProc, methods. |
| */ |
| public void assertDecimalSameValue(String message, String expected_s, |
| BigDecimal actual) |
| { |
| BigDecimal expected = (new BigDecimal(expected_s)); |
| assertTrue(message + |
| " expected:<" + expected + "> but was:<" + actual.toString() + ">", |
| expected.compareTo(actual)==0); |
| } |
| |
| // SQL ROUTINES (functions and procedures) |
| |
| /** |
| * External code for the ONE_IN_ONE_OUT_FUNC SQL function, which squares |
| * the value of the input arg, then adds the input arg to that result. |
| * |
| * @param p1 integer input argument to be used in calculation |
| */ |
| public static int oneInOneOutFunc (int p1) |
| { |
| return (p1 * p1) + p1; |
| } |
| |
| /** |
| * External code for the TWO_IN_ONE_OUT_PROC SQL procedure, which sets the |
| * value of the third arg to the sum of the first two. |
| * |
| * @param p1 integer input parameter to be used in calculation |
| * @param p2 integer input parameter to be used in calculation |
| * @param p3 integer output parameter that stores result of the calculation |
| */ |
| public static void twoInOneOutProc (int p1, int p2, int[] p3) |
| { |
| p3[0] = p1 + p2; |
| } |
| |
| /** |
| * External code for the NO_IN_ONE_OUT_FUNC SQL function, which takes no |
| * parameters and returns the value 55. |
| */ |
| public static int noInOneOutFunc () |
| { |
| return 55; |
| } |
| |
| /** |
| * External code for the SYSTEM_OUT_PRINTLN_PROC SQL procedure, which |
| * outputs a message to System out. |
| */ |
| public static void systemOutPrintlnProc() |
| { |
| System.out.println("I'm doing something here..."); |
| } |
| |
| /** |
| * External code for the UPDATE_LONGVARBINARY_PROC SQL procedure, which |
| * sets the value of the Long varbinary column in the LONGVARBINARY_TABLE |
| * table given the input parameter. |
| * |
| * @param in_param input parameter to be used for database update |
| * @exception SQLException if a database error occurs |
| */ |
| public static void updateLongVarbinaryProc (byte[] in_param) |
| throws SQLException |
| { |
| Connection conn = |
| DriverManager.getConnection("jdbc:default:connection"); |
| PreparedStatement ps = |
| conn.prepareStatement("update LONGVARBINARY_TABLE set lvbc=?"); |
| |
| ps.setBytes(1,in_param); |
| ps.executeUpdate(); |
| |
| ps.close(); |
| conn.close(); |
| } |
| |
| /** |
| * External code for the NUMERIC_BOUNDARIES_PROC SQL procedure, which |
| * fetches max, min, and null values from a table with numeric columns. |
| * |
| * @param param1 output parameter that returns maxcol value |
| * @param param2 output parameter that returns mincol value |
| * @param param3 output parameter that returns nulcol value |
| * @exception SQLException if a database error occurs |
| */ |
| public static void numericBoundariesProc (BigDecimal[] param1, |
| BigDecimal[] param2, BigDecimal[] param3) throws SQLException |
| { |
| Connection conn = |
| DriverManager.getConnection("jdbc:default:connection"); |
| Statement stmt = conn.createStatement(); |
| |
| ResultSet rs = stmt.executeQuery |
| ("select maxcol, mincol, nulcol from NUMERIC_BOUNDARIES_TABLE"); |
| |
| if (rs.next()) |
| { |
| param1[0]=rs.getBigDecimal(1); |
| param2[0]=rs.getBigDecimal(2); |
| param3[0]=rs.getBigDecimal(3); |
| } |
| else |
| { |
| throw new SQLException("Data not found"); |
| } |
| |
| rs.close(); |
| stmt.close(); |
| conn.close(); |
| } |
| |
| |
| /** |
| * External code for the BIGDECIMAL_IN_AND_OUT_PROC SQL procedure, which |
| * tests INT and OUT parameters with the BigDecimal data type. |
| * |
| * @param bd1 input parameter |
| * @param bdr1 output parameter set to bd1 * bd2 |
| * @param bd2 input parameter |
| * @param bdr2 output parameter set to bd1 + bd2 |
| * @param bdr3 output parameter set to a fixed value |
| * @param bdr4 output parameter set to a fixed value |
| * @param bdr5 output parameter set to a fixed value |
| * @param bdr6 output parameter set to a fixed value |
| * @param bdr7 output parameter set to a fixed value |
| * |
| */ |
| public static void bigDecimalInAndOutProc (BigDecimal bd1, |
| BigDecimal bdr1[], BigDecimal bd2, BigDecimal bdr2[], |
| BigDecimal bdr3[], BigDecimal bdr4[], BigDecimal bdr5[], |
| BigDecimal bdr6[], BigDecimal bdr7[]) |
| { |
| bdr1[0] = bd1; |
| bdr2[0] = bd1.multiply(bd2); |
| bdr3[0] = bd1.add(bd2); |
| bdr4[0] = new BigDecimal(".00000"); |
| bdr5[0] = new BigDecimal("-.00000"); |
| bdr6[0] = new BigDecimal("99999999."); |
| bdr7[0] = new BigDecimal("-99999999."); |
| } |
| |
| /** |
| * External code for the NUMERIC_TYPES_IN_AND_OUT_PROC SQL procedure, |
| * which tests IN and OUT parameters with many numeric types. |
| * Also tests method overload for manyTypesInAndOutProc. |
| * |
| * @param s short input parameter |
| * @param i int input parameter |
| * @param l long input parameter |
| * @param f float input parameter |
| * @param d double input parameter |
| * @param bd BigDecimal input parameter |
| * @param sr short output parameter |
| * @param ir int output parameter |
| * @param lr long output parameter |
| * @param fr float output parameter |
| * @param dr double output parameter |
| * @param bdr BigDecimal output parameter |
| * |
| */ |
| public static void manyTypesInAndOutProc ( |
| short s, int i, long l, float f, double d, BigDecimal bd, |
| short[] sr, int[] ir, long[] lr,float[] fr,double[] dr,BigDecimal[] bdr |
| ) |
| { |
| sr[0] = s; |
| ir[0] = i; |
| lr[0] = l; |
| fr[0] = f; |
| dr[0] = d; |
| bdr[0] = bd; |
| } |
| |
| /** |
| * External code for the NON_NUMERIC_TYPES_IN_AND_OUT_PROC SQL procedure, |
| * which tests IN / OUT parameters with many non-numeric types. |
| * Also tests method overload for manyTypesInAndOutProc. |
| * |
| * @param dt date input parameter |
| * @param t time input parameter |
| * @param ts timestamp input parameter |
| * @param ba byte input parameter |
| * @param dtr date output parameter |
| * @param tr time output parameter |
| * @param tsr timestamp output parameter |
| * @param bar byte output parameter |
| * |
| */ |
| public static void manyTypesInAndOutProc ( |
| Date dt, Time t, Timestamp ts, byte[] ba, |
| Date[] dtr, Time[] tr, Timestamp[] tsr, byte[][] bar |
| ) |
| { |
| dtr[0] = dt; |
| tr[0] = t; |
| tsr[0] = ts; |
| bar[0] = ba; |
| } |
| |
| /** |
| * External code for the MANY_TYPES_INOUT_PROC SQL procedure, which tests |
| * INOUT parameters with many types. |
| * |
| * @param s1 short input parameter |
| * @param s2 short output parameter |
| * @param p1 int input parameter |
| * @param p2 int output parameter |
| * @param l1 long input parameter |
| * @param l2 long output parameter |
| * @param f1 float input parameter |
| * @param f2 float output parameter |
| * @param d1 double input parameter |
| * @param d2 double output parameter |
| * @param t1 time input parameter |
| * @param t2 time output parameter |
| */ |
| public static void manyTypesInoutProc ( |
| short s1, short s2[], int p1, int p2[], long l1, long l2[], |
| float f1, float f2[], double d1, double d2[], Time t1, Time t2[] |
| ) |
| { |
| p2[0] = p1 + p2[0]; |
| s2[0] = (short) (s1 + s2[0]); |
| l2[0] = l1 + l2[0]; |
| f2[0] = f1 + f2[0]; |
| d2[0] = d1 + d2[0]; |
| t2[0] = t1; |
| } |
| |
| /** |
| * External code for the BATCH_UPDATE_PROC SQL procedure, which updates |
| * data in a table for a given id. |
| * Called by xtestBatchUpdateProc. |
| * |
| * @param id Id to be updated |
| * @param id_newval New value to which the id should be updated |
| * @exception SQLException if a database error occurs |
| */ |
| public static void batchUpdateProc (int id, int id_newval) |
| throws SQLException |
| { |
| Connection conn = |
| DriverManager.getConnection("jdbc:default:connection"); |
| PreparedStatement ps = conn.prepareStatement |
| ("update BATCH_TABLE set idval=? where id=?"); |
| |
| ps.setInt(1, id_newval); |
| ps.setInt(2, id); |
| ps.executeUpdate(); |
| ps.close(); |
| conn.close(); |
| } |
| |
| |
| //jdbc 3.0 test methods |
| |
| public void testsetURL() throws SQLException, MalformedURLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| URL domain = new URL("http://www.apache.org"); |
| cs.setURL("URL",domain); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetNull() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setNull("P1",1); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetBoolean() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setBoolean("P1",true); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetByte() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NUMERIC_TYPES_IN_AND_OUT_PROC (?,?,?,?,?,?, ?,?,?,?,?,?)"); |
| try { |
| cs.setByte("P1",(byte)1); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetShort() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NUMERIC_TYPES_IN_AND_OUT_PROC (?,?,?,?,?,?, ?,?,?,?,?,?)"); |
| try { |
| cs.setShort("P1",(short)1); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| |
| public void testsetInt() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setInt("P1", 6); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetLong() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setLong("P1", (long)6000); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetFloat() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NUMERIC_TYPES_IN_AND_OUT_PROC (?,?,?,?,?,?, ?,?,?,?,?,?)"); |
| try { |
| cs.setFloat("P1",(float)6.123453); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetDouble() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NUMERIC_TYPES_IN_AND_OUT_PROC (?,?,?,?,?,?, ?,?,?,?,?,?)"); |
| try { |
| cs.setDouble("P5",(double)6.123453); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetDecimal() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NUMERIC_TYPES_IN_AND_OUT_PROC (?,?,?,?,?,?, ?,?,?,?,?,?)"); |
| try { |
| cs.setBigDecimal("P6",new BigDecimal("33.333")); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetString() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setString("P4","test"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetBytes() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setBytes("P1",new byte[] { (byte)0xe0, 0x4f, (byte)0xd0, |
| 0x20, (byte)0xea, 0x3a, 0x69, 0x10, (byte)0xa2, (byte)0xd8, 0x08, 0x00, 0x2b, |
| 0x30, 0x30, (byte)0x9d }); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetDate() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC (?,?,?,?,?,?,?,?)"); |
| try { |
| cs.setDate("P1",Date.valueOf("2013-07-13")); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetTime() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC (?,?,?,?,?,?,?,?)"); |
| try { |
| cs.setTime("P2",Time.valueOf("10:05:02")); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetTimestamp() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC (?,?,?,?,?,?,?,?)"); |
| try { |
| cs.setTimestamp("P3",Timestamp.valueOf("2002-05-12 10:05:02.000000000")); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetAsciiStream() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| cs.setAsciiStream("PAscii",is,1); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetBinaryStream() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| cs.setBinaryStream("PBinary",is,1); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetObject() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setObject("P1","Object",1,2); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetObject1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setObject("P1","Object",1); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetObject2() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setObject("P1","Object"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetCharacterStream() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| BufferedReader br = new BufferedReader(new InputStreamReader(is)); |
| cs.setCharacterStream("P1",br,1); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetDate1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC (?,?,?,?,?,?,?,?)"); |
| try { |
| cs.setDate("P1",Date.valueOf("2013-07-13"),Calendar.getInstance()); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetTime1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC (?,?,?,?,?,?,?,?)"); |
| try { |
| cs.setTime("P2",Time.valueOf("10:05:02"),Calendar.getInstance()); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetTimestamp1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC (?,?,?,?,?,?,?,?)"); |
| try { |
| cs.setTimestamp("P3",Timestamp.valueOf("2002-05-12 10:05:02.000000000"),Calendar.getInstance()); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetNull1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setNull("P1",1,"Null"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetString() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getString("P4"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetBoolean() throws SQLException |
| { |
| CallableStatement cs =prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getBoolean("P4"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetByte() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getByte("P1"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetShort() throws SQLException |
| { |
| CallableStatement cs =prepareCall("call NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getShort("P1"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetInt() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC (?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getInt("P4"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetLong() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getLong("P3"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetFloat() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getFloat("P5"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetDouble() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getDouble("P5"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetBytes() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getBytes("P1"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetDate() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getDate("P1"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetTime() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getTime("P2"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetTimestamp() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getTimestamp("P3"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetObject() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getObject("P4"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetBigDecimal() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?,?,?,?,?,?, ?,?)"); |
| try { |
| cs.getBigDecimal("P6"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| |
| public void testgetObject1() throws SQLException, MalformedURLException |
| { |
| Map<String, Class<?>> format = new HashMap<String, Class<?>>(); |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.getObject("P1",format); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetRef() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?, ?,?,?,?, ?, ?,?)"); |
| try { |
| cs.getRef("P4"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetBlob() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?, ?,?,?,?, ?, ?,?)"); |
| try { |
| cs.getBlob("P4"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetClob1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?, ?,?,?,?, ?, ?,?)"); |
| try { |
| cs.getClob("P4"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetArray() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?, ?,?,?,?, ?, ?,?)"); |
| try { |
| cs.getArray("P4"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetDate1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?, ?,?,?,?, ?, ?,?)"); |
| try { |
| cs.getDate("P1",Calendar.getInstance()); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetTime1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?, ?,?,?,?, ?, ?,?)"); |
| try { |
| cs.getTime("P2",Calendar.getInstance()); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetTimestamp1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?, ?,?,?,?, ?, ?,?)"); |
| try { |
| cs.getTimestamp("P3",Calendar.getInstance()); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetURL() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC(?,?,?,?,?, ?, ?,?)"); |
| try { |
| cs.getURL("P4"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testregisterOutParameter() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.registerOutParameter("String",1); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testregisterOutParameter1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.registerOutParameter("String",1,2); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testregisterOutParameter2() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.registerOutParameter("String",1); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testregisterOutParameter3() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.registerOutParameter("String1",1,"String2"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| //test methods for jdbc 4.0 |
| |
| public void testgetCharacterStream() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC (?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getCharacterStream("P4"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| |
| public void testgetNCharacterStream() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC (?, ?, ?,?,?, ?, ?,?)"); |
| try { |
| cs.getNCharacterStream("P4"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| |
| public void testgetNString() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC (?, ?, ?,?,?, ?, ?,?)"); |
| try { |
| cs.getNString("P4"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetRowId() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC (?, ?, ?,?,?, ?, ?,?)"); |
| try { |
| cs.getRowId("P4"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetRowId() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setRowId("P1",cs.getRowId("P2")); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetBlob() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setBlob("P1",cs.getBlob("P2")); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetClob() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setClob("P1",cs.getClob("P2")); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetNString() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setNString("P1","value"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetNCharacterStream1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| BufferedReader br = new BufferedReader(new InputStreamReader(is)); |
| cs.setNCharacterStream("P1",br); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetNCharacterStream2() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| BufferedReader br = new BufferedReader(new InputStreamReader(is)); |
| cs.setNCharacterStream("P1",br,(long)345678788); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetNClob() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setNClob("P1",cs.getNClob(1)); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetClob1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| BufferedReader br = new BufferedReader(new InputStreamReader(is)); |
| cs.setNClob("P1",br); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetClob2() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| BufferedReader br = new BufferedReader(new InputStreamReader(is)); |
| cs.setNClob("P1",br,(long)345678788); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetClobInputStream1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| cs.setBlob("P1",is); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetClobInputStream2() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| cs.setBlob("P1",is,(long)345678788); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetNClobInput1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| BufferedReader br = new BufferedReader(new InputStreamReader(is)); |
| cs.setNClob("P1",br); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetNClobInput2() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| BufferedReader br = new BufferedReader(new InputStreamReader(is)); |
| cs.setNClob("P1",br,(long)345678788); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| |
| public void testgetNClob() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC (?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getNClob("P4"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetSQLXML() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| cs.setSQLXML("P1",cs.getSQLXML(1)); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testgetSQLXML() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call NON_NUMERIC_TYPES_IN_AND_OUT_PROC (?,?,?,?,?,?,?,?)"); |
| try { |
| cs.getSQLXML("P4"); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetAsciiStream1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| cs.setAsciiStream("P1",is); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetAsciiStream2() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| cs.setAsciiStream("P1",is,(long)345678788); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetBinaryStream1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| cs.setBinaryStream("P1",is); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetBinaryStream2() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?, ?, ?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| cs.setBinaryStream("P1",is,(long)345678788); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetCharacterStream1() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?,?,?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| BufferedReader br = new BufferedReader(new InputStreamReader(is)); |
| cs.setCharacterStream("P1",br); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| public void testsetCharacterStream2() throws SQLException |
| { |
| CallableStatement cs = prepareCall("call TWO_IN_ONE_OUT_PROC (?,?,?)"); |
| try { |
| String str = "This is a String"; |
| InputStream is = new ByteArrayInputStream(str.getBytes()); |
| BufferedReader br = new BufferedReader(new InputStreamReader(is)); |
| cs.setCharacterStream("P1",br,(long)345678788); |
| fail("should have failed"); |
| } catch (SQLFeatureNotSupportedException e) { |
| assertSQLState("0A000", e); |
| } |
| } |
| |
| |
| |
| } |
| |
| |
| |
| |