| /* |
| * |
| * Derby - Class org.apache.derbyTesting.functionTests.tests.jdbc4.StatementTest |
| * |
| * 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.jdbc4; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.sql.CallableStatement; |
| import java.sql.Connection; |
| import java.sql.PreparedStatement; |
| import java.sql.ResultSet; |
| import java.sql.SQLException; |
| import java.sql.SQLTimeoutException; |
| import java.sql.Statement; |
| import junit.framework.Test; |
| import org.apache.derby.client.am.ClientStatement; |
| import org.apache.derby.impl.jdbc.EmbedResultSet; |
| import org.apache.derby.impl.sql.execute.RowUtil; |
| import org.apache.derby.shared.common.sanity.SanityManager; |
| import org.apache.derbyTesting.functionTests.tests.jdbcapi.BatchUpdateTest; |
| import org.apache.derbyTesting.functionTests.tests.jdbcapi.SetQueryTimeoutTest; |
| import org.apache.derbyTesting.functionTests.tests.jdbcapi.Wrapper41Statement; |
| import org.apache.derbyTesting.functionTests.util.SQLStateConstants; |
| import org.apache.derbyTesting.junit.BaseJDBCTestCase; |
| import org.apache.derbyTesting.junit.BaseTestSuite; |
| import org.apache.derbyTesting.junit.TestConfiguration; |
| |
| /** |
| * Tests for new methods added for Statement in JDBC4. |
| */ |
| public class StatementTest |
| extends BaseJDBCTestCase { |
| |
| /** Default statement used by the tests. */ |
| private Statement stmt = null; |
| |
| /** |
| * Create a new test with the given name. |
| * |
| * @param name name of the test. |
| */ |
| public StatementTest(String name) { |
| super(name); |
| } |
| |
| /** |
| * Create default connection and statement. |
| * |
| * @throws SQLException if setAutoCommit, createStatement or |
| * BaseJDBCTestCase.getConnection fails. |
| */ |
| protected void setUp() |
| throws SQLException { |
| getConnection().setAutoCommit(false); |
| // Create a default statement. |
| stmt = createStatement(); |
| assertFalse("First statement must be open initially", |
| stmt.isClosed()); |
| } |
| |
| /** |
| * Close default connection and statement if necessary. |
| * |
| * @throws SQLException if a database access exception occurs. |
| */ |
| protected void tearDown() |
| throws Exception { |
| // Close default statement |
| if (stmt != null) { |
| stmt.close(); |
| stmt = null; |
| } |
| |
| super.tearDown(); |
| } |
| |
| /** |
| * Check that <code>isClosed</code> returns <code>true</code> after |
| * the statement has been explicitly closed. |
| */ |
| public void testIsClosedBasic() |
| throws SQLException { |
| ResultSet rs = stmt.executeQuery("select count(*) from stmtTable"); |
| assertFalse("Statement should still be open", stmt.isClosed()); |
| rs.close(); |
| assertFalse("Statement should be open after ResultSet has been " + |
| "closed", stmt.isClosed()); |
| stmt.close(); |
| assertTrue("Statement should be closed, close() has been called", |
| stmt.isClosed()); |
| } |
| |
| /** |
| * Test that creating two statements on the same connection does not |
| * cause side effects on the statements. |
| */ |
| public void testIsClosedWithTwoStatementsOnSameConnection() |
| throws SQLException { |
| // Create a second statement on the default connection. |
| Statement stmt2 = createStatement(); |
| assertFalse("Second statement must be open initially", |
| stmt2.isClosed()); |
| assertFalse("First statement should not be closed when " + |
| "creating a second statement", stmt.isClosed()); |
| ResultSet rs = stmt2.executeQuery("select count(*) from stmtTable"); |
| assertFalse("Second statement should be open after call to " + |
| "execute()", stmt2.isClosed()); |
| assertFalse("First statement should be open after call to " + |
| "second statment's execute()", stmt.isClosed()); |
| stmt2.close(); |
| assertTrue("Second statement should be closed, close() has " + |
| "been called!", stmt2.isClosed()); |
| assertFalse("First statement should be open after call to " + |
| "second statment's close()", stmt.isClosed()); |
| } |
| |
| /** |
| * Test that the two statements created on the connection are closed |
| * when the connection itself is closed. |
| */ |
| public void testIsClosedWhenClosingConnection() |
| throws SQLException { |
| // Create an extra statement for good measure. |
| Statement stmt2 = createStatement(); |
| assertFalse("Second statement must be open initially", |
| stmt2.isClosed()); |
| // Exeute something on it, as opposed to the default statement. |
| stmt2.execute("select count(*) from stmtTable"); |
| assertFalse("Second statement should be open after call to " + |
| "execute()", stmt2.isClosed()); |
| // Close the connection. We must commit/rollback first, or else a |
| // "Invalid transaction state" exception is raised. |
| rollback(); |
| Connection con = getConnection(); |
| con.close(); |
| assertTrue("Connection should be closed after close()", |
| con.isClosed()); |
| assertTrue("First statement should be closed, as parent " + |
| "connection has been closed", stmt.isClosed()); |
| assertTrue("Second statement should be closed, as parent " + |
| "connection has been closed", stmt2.isClosed()); |
| } |
| |
| /** |
| * Check the state of the statement when the connection is first attempted |
| * closed when in an invalid transaction state, then closed after a |
| * commit. According to the JDBC 4 API documentation: </i>"It is strongly |
| * recommended that an application explictly commits or rolls back an |
| * active transaction prior to calling the close method. If the close |
| * method is called and there is an active transaction, |
| * the results are implementation-defined."</i> |
| * Derby throws an exception and keeps the connection open. |
| */ |
| public void testIsClosedWhenClosingConnectionInInvalidState() |
| throws SQLException { |
| stmt.executeQuery("select count(*) from stmtTable"); |
| // Connection should now be in an invalid transaction state. |
| Connection con = stmt.getConnection(); |
| try { |
| con.close(); |
| fail("Invalid transaction state exception was not thrown"); |
| } catch (SQLException sqle) { |
| String expectedState = |
| SQLStateConstants.INVALID_TRANSACTION_STATE_ACTIVE_SQL_TRANSACTION; |
| assertSQLState(expectedState, sqle); |
| } |
| assertFalse("Statement should still be open, because " + |
| "Connection.close() failed", stmt.isClosed()); |
| assertFalse("Connection should still be open", con.isClosed()); |
| // Do a commit here, since we do a rollback in another test. |
| con.commit(); |
| con.close(); |
| assertTrue("Connection should be closed after close()", |
| con.isClosed()); |
| assertTrue("Statement should be closed, because " + |
| "the connection has been closed", stmt.isClosed()); |
| stmt.close(); |
| assertTrue("Statement should still be closed", stmt.isClosed()); |
| } |
| |
| /** |
| * Execute a query on a statement after the parent connection has been |
| * closed. |
| */ |
| public void testStatementExecuteAfterConnectionClose() |
| throws SQLException { |
| Connection con = stmt.getConnection(); |
| con.close(); |
| assertTrue("Connection should be closed after close()", |
| con.isClosed()); |
| try { |
| stmt.executeQuery("select count(*) from stmtTable"); |
| } catch (SQLException sqle) { |
| assertEquals("Unexpected SQL state for performing " + |
| "operations on a closed statement.", |
| SQLStateConstants.CONNECTION_EXCEPTION_CONNECTION_DOES_NOT_EXIST, |
| sqle.getSQLState()); |
| } |
| assertTrue("Statement should be closed, because " + |
| "the connection has been closed", stmt.isClosed()); |
| } |
| |
| public void testIsWrapperForStatement() throws SQLException { |
| assertTrue(stmt.isWrapperFor(Statement.class)); |
| } |
| |
| public void testIsNotWrapperForPreparedStatement() throws SQLException { |
| assertFalse(stmt.isWrapperFor(PreparedStatement.class)); |
| } |
| |
| public void testIsNotWrapperForCallableStatement() throws SQLException { |
| assertFalse(stmt.isWrapperFor(CallableStatement.class)); |
| } |
| |
| public void testIsNotWrapperForResultSet() throws SQLException { |
| assertFalse(stmt.isWrapperFor(ResultSet.class)); |
| } |
| |
| public void testUnwrapStatement() throws SQLException { |
| Statement stmt2 = stmt.unwrap(Statement.class); |
| assertSame("Unwrap returned wrong object.", stmt, stmt2); |
| } |
| |
| public void testUnwrapPreparedStatement() { |
| try { |
| PreparedStatement ps = stmt.unwrap(PreparedStatement.class); |
| fail("Unwrap didn't fail."); |
| } catch (SQLException e) { |
| assertSQLState("XJ128", e); |
| } |
| } |
| |
| public void testUnwrapCallableStatement() { |
| try { |
| CallableStatement cs = stmt.unwrap(CallableStatement.class); |
| fail("Unwrap didn't fail."); |
| } catch (SQLException e) { |
| assertSQLState("XJ128", e); |
| } |
| } |
| |
| public void testUnwrapResultSet() throws SQLException { |
| try { |
| ResultSet rs = stmt.unwrap(ResultSet.class); |
| fail("Unwrap didn't fail."); |
| } catch (SQLException e) { |
| assertSQLState("XJ128", e); |
| } |
| } |
| |
| /** |
| * Tests isPoolable, setPoolable, and the default poolability. |
| */ |
| public void testPoolable() throws SQLException { |
| assertFalse("Statement cannot be poolable by default", |
| stmt.isPoolable()); |
| stmt.setPoolable(true); |
| assertTrue("Statement must be poolable", stmt.isPoolable()); |
| |
| stmt.setPoolable(false); |
| assertFalse("Statement cannot be poolable", stmt.isPoolable()); |
| } |
| |
| /** |
| * Test that Statement.setQueryTimeout() causes statements to |
| * raise SQLTimeoutException per the JDBC 4.1 spec clarification. |
| */ |
| public void test_jdbc4_1_queryTimeoutException() throws Exception |
| { |
| SQLException se = null; |
| |
| PreparedStatement ps = prepareStatement |
| ( |
| "select columnnumber from sys.syscolumns c, sys.systables t\n" + |
| "where t.tablename = 'SYSTABLES'\n" + |
| "and t.tableid = c.referenceid\n" + |
| "and mod( delay_st( 5, c.columnnumber ), 3 ) = 0" |
| ); |
| println( "Testing timeout exception for a " + ps.getClass().getName() ); |
| |
| SetQueryTimeoutTest.StatementExecutor executor = |
| new SetQueryTimeoutTest.StatementExecutor( ps, true, 1 ); |
| |
| executor.start(); |
| executor.join(); |
| |
| ps.close(); |
| |
| se = executor.getSQLException(); |
| |
| assertNotNull( se ); |
| assertEquals( SQLTimeoutException.class.getName(), se.getClass().getName() ); |
| } |
| |
| /** |
| * Test the closeOnCompletion() and isCloseOnCompletion() methods |
| * when using ResultSets which close implicitly. |
| */ |
| public void testCompletionClosure_jdbc4_1_implicitRSClosure() throws Exception |
| { |
| Connection conn = getConnection(); |
| conn.setHoldability( ResultSet.CLOSE_CURSORS_AT_COMMIT ); |
| conn.setAutoCommit( true ); |
| |
| PreparedStatement ps; |
| ResultSet rs; |
| Wrapper41Statement wrapper; |
| |
| ps = conn.prepareStatement( "values ( 1 )" ); |
| println( "Testing implicit closure WITH autocommit on a " + ps.getClass().getName() ); |
| |
| wrapper = new Wrapper41Statement( ps ); |
| wrapper.closeOnCompletion(); |
| |
| rs = ps.executeQuery(); |
| rs.next(); |
| rs.next(); |
| |
| assertTrue( rs.isClosed() ); |
| assertTrue( ps.isClosed() ); |
| |
| conn.setAutoCommit( false ); |
| |
| // now retry the experiment with an explicit commit |
| |
| ps = conn.prepareStatement( "values ( 1 )" ); |
| println( "Testing implicit closure WITHOUT autocommit on a " + ps.getClass().getName() ); |
| |
| wrapper = new Wrapper41Statement( ps ); |
| wrapper.closeOnCompletion(); |
| |
| rs = ps.executeQuery(); |
| rs.next(); |
| rs.next(); |
| |
| assertFalse( rs.isClosed() ); |
| assertFalse( ps.isClosed() ); |
| |
| conn.commit(); |
| |
| assertTrue( rs.isClosed() ); |
| assertTrue( ps.isClosed() ); |
| } |
| |
| /** |
| * Test the large update methods added by JDBC 4.2. |
| */ |
| public void testLargeUpdate_jdbc4_2() throws Exception |
| { |
| Connection conn = getConnection(); |
| |
| largeUpdate_jdbc4_2( conn ); |
| } |
| |
| public static void largeUpdate_jdbc4_2( Connection conn ) |
| throws Exception |
| { |
| // |
| // This test makes use of a debug entry point which is a NOP |
| // in an insane production build. |
| // |
| if (!SanityManager.DEBUG) { return; } |
| else { println( "Running largeUpdate_jdbc4_2() on debug code." ); } |
| |
| conn.prepareStatement |
| ( |
| "create procedure setRowCountBase( newBase bigint )\n" + |
| "language java parameter style java no sql\n" + |
| "external name 'org.apache.derbyTesting.functionTests.tests.jdbc4.StatementTest.setRowCountBase'\n" |
| ).execute(); |
| conn.prepareStatement |
| ( |
| "create table bigintTable( col1 int generated always as identity, col2 bigint )" |
| ).execute(); |
| |
| StatementWrapper sw = new StatementWrapper( conn.createStatement() ); |
| |
| largeUpdateTest( sw, (long) Integer.MAX_VALUE ); |
| largeUpdateTest( sw, 0L); |
| |
| largeBatchTest( sw, (long) Integer.MAX_VALUE ); |
| largeBatchTest( sw, 0L); |
| |
| largeMaxRowsTest( sw, ((long) Integer.MAX_VALUE) + 1L ); |
| |
| largeBatchUpdateExceptionTest( sw, ((long) Integer.MAX_VALUE) + 1L ); |
| } |
| private static void largeUpdateTest( StatementWrapper sw, long rowCountBase ) |
| throws Exception |
| { |
| // |
| // This test makes use of a debug entry point which is a NOP |
| // in an insane production build. |
| // |
| if (!SanityManager.DEBUG) { return; } |
| else { println( "Running largeUpdateTest() on debug code." ); } |
| |
| // poke the rowCountBase into the engine. all returned row counts will be |
| // increased by this amount |
| setRowCountBase( sw.getWrappedStatement(), false, rowCountBase ); |
| |
| largeUpdateTest( sw, rowCountBase, 1L ); |
| largeUpdateTest( sw, rowCountBase, 3L ); |
| } |
| private static void largeUpdateTest( StatementWrapper sw, long rowCountBase, long rowCount ) |
| throws Exception |
| { |
| StringBuffer buffer = new StringBuffer(); |
| buffer.append( "insert into bigintTable( col2 ) values " ); |
| for ( long i = 0L; i < rowCount; i++ ) |
| { |
| if ( i > 0L ) { buffer.append( ", " ); } |
| buffer.append( "( " + i + " )" ); |
| } |
| String text = buffer.toString(); |
| |
| long expectedResult = rowCountBase + rowCount; |
| |
| vetUpdateSize( sw, (int) expectedResult, |
| sw.getWrappedStatement().executeUpdate( text ), expectedResult ); |
| vetUpdateSize( sw, (int) expectedResult, |
| sw.getWrappedStatement().executeUpdate( text, Statement.RETURN_GENERATED_KEYS ), expectedResult ); |
| vetUpdateSize( sw, (int) expectedResult, |
| sw.getWrappedStatement().executeUpdate( text, new int[] { 1 } ), expectedResult ); |
| vetUpdateSize( sw, (int) expectedResult, |
| sw.getWrappedStatement().executeUpdate( text, new String[] { "COL1" } ), expectedResult ); |
| |
| vetUpdateSize( sw, expectedResult, sw.executeLargeUpdate( text ), expectedResult ); |
| vetUpdateSize( sw, expectedResult, sw.executeLargeUpdate( text, Statement.RETURN_GENERATED_KEYS ), expectedResult ); |
| vetUpdateSize( sw, expectedResult, sw.executeLargeUpdate( text, new int[] { 1 } ), expectedResult ); |
| vetUpdateSize( sw, expectedResult, sw.executeLargeUpdate( text, new String[] { "COL1" } ), expectedResult ); |
| } |
| private static void vetUpdateSize( StatementWrapper sw, int expected, int actual, long longAnswer ) |
| throws Exception |
| { |
| assertEquals( expected, actual ); |
| assertEquals( expected, sw.getWrappedStatement().getUpdateCount() ); |
| assertEquals( longAnswer, sw.getLargeUpdateCount() ); |
| } |
| private static void vetUpdateSize( StatementWrapper sw, long expected, long actual, long longAnswer ) |
| throws Exception |
| { |
| assertEquals( expected, actual ); |
| assertEquals( (int) expected, sw.getWrappedStatement().getUpdateCount() ); |
| assertEquals( longAnswer, sw.getLargeUpdateCount() ); |
| } |
| private static void largeBatchTest( StatementWrapper sw, long rowCountBase ) |
| throws Exception |
| { |
| // |
| // This test makes use of a debug entry point which is a NOP |
| // in an insane production build. |
| // |
| if (!SanityManager.DEBUG) { return; } |
| |
| println( "Large batch test with rowCountBase = " + rowCountBase ); |
| |
| // poke the rowCountBase into the engine. all returned row counts will be |
| // increased by this amount |
| sw.getWrappedStatement().clearBatch(); |
| setRowCountBase( sw.getWrappedStatement(), false, rowCountBase ); |
| |
| long[] expectedResult = new long[] { rowCountBase + 1L, rowCountBase + 1L, rowCountBase + 2L }; |
| |
| createBatch( sw ); |
| assertEquals( sw.getWrappedStatement().executeBatch(), squashLongs( expectedResult ) ); |
| |
| createBatch( sw ); |
| assertEquals( sw.executeLargeBatch(), expectedResult ); |
| } |
| private static void createBatch( StatementTest.StatementWrapper sw ) |
| throws Exception |
| { |
| sw.getWrappedStatement().clearBatch(); |
| truncate( sw ); |
| sw.getWrappedStatement().addBatch( "insert into bigintTable( col2 ) values ( 1 )" ); |
| sw.getWrappedStatement().addBatch( "update bigintTable set col2 = 2" ); |
| sw.getWrappedStatement().addBatch( "insert into bigintTable( col2 ) values ( 3 ), ( 4 )" ); |
| } |
| private static void largeMaxRowsTest( StatementWrapper sw, long maxRows ) |
| throws Exception |
| { |
| // |
| // This test makes use of a debug entry point which is a NOP |
| // in an insane production build. |
| // |
| if (!SanityManager.DEBUG) { return; } |
| |
| println( "Large max rows test with maxRows = " + maxRows ); |
| |
| long expectedRowCount = 3L; |
| |
| truncate( sw ); |
| sw.getWrappedStatement().execute( "insert into bigintTable( col2 ) values ( 1 ), ( 2 ), ( 3 ), ( 4 ), ( 5 )" ); |
| |
| setRowCountBase( sw.getWrappedStatement(), usingDerbyNetClient(), maxRows - expectedRowCount ); |
| |
| sw.setLargeMaxRows( maxRows ); |
| |
| ResultSet rs = sw.getWrappedStatement().executeQuery( "select * from bigintTable" ); |
| int rowCount = 0; |
| while( rs.next() ) { rowCount++; } |
| rs.close(); |
| |
| setRowCountBase( sw.getWrappedStatement(), usingDerbyNetClient(), 0L ); |
| |
| assertEquals( expectedRowCount, rowCount ); |
| assertEquals( maxRows, sw.getLargeMaxRows() ); |
| } |
| private static void largeBatchUpdateExceptionTest( StatementWrapper sw, long rowCountBase ) |
| throws Exception |
| { |
| // |
| // This test makes use of a debug entry point which is a NOP |
| // in an insane production build. |
| // |
| if (!SanityManager.DEBUG) { return; } |
| |
| println( "Large batch update exception test with rowCountBase = " + rowCountBase ); |
| |
| sw.getWrappedStatement().clearBatch(); |
| sw.getWrappedStatement().execute( "create table intTable( col1 int generated always as identity, col2 int )" ); |
| |
| // poke the rowCountBase into the engine. all returned row counts will be |
| // increased by this amount |
| setRowCountBase( sw.getWrappedStatement(), false, rowCountBase ); |
| |
| // |
| // Create a batch of statements. The last one will die on an overflow condition. |
| // |
| sw.getWrappedStatement().addBatch( "insert into intTable( col2 ) values ( 1 )" ); |
| sw.getWrappedStatement().addBatch( "insert into intTable( col2 ) values ( 1 )" ); |
| sw.getWrappedStatement().addBatch( "update intTable set col2 = 2147483647 + 1" ); |
| |
| if ( usingEmbedded() ) |
| { |
| BatchUpdateTest.assertBatchExecuteError |
| ( |
| "22003", sw.getWrappedStatement(), |
| new long[] { rowCountBase + 1L, rowCountBase + 1L } |
| ); |
| } |
| else if ( usingDerbyNetClient() ) |
| { |
| BatchUpdateTest.assertBatchExecuteError |
| ( |
| "XJ208", sw.getWrappedStatement(), |
| new long[] { rowCountBase + 1L, rowCountBase + 1L, -3 } |
| ); |
| } |
| |
| sw.getWrappedStatement().clearBatch(); |
| setRowCountBase( sw.getWrappedStatement(), false, 0L ); |
| } |
| |
| public static void setRowCountBase |
| ( Statement stmt, boolean onClient, long rowCountBase ) |
| throws Exception |
| { |
| if ( onClient ) |
| { |
| ClientStatement.setFetchedRowBase( rowCountBase ); |
| } |
| else |
| { |
| stmt.execute( "call setRowCountBase( " + rowCountBase + " )" ); |
| } |
| } |
| private static void truncate( StatementTest.StatementWrapper sw ) |
| throws Exception |
| { |
| sw.getWrappedStatement().execute( "truncate table bigintTable" ); |
| } |
| private static int[] squashLongs( long[] longs ) |
| { |
| int count = (longs == null) ? 0 : longs.length; |
| int[] ints = new int[ count ]; |
| for ( int i = 0; i < count; i++ ) { ints[ i ] = (int) longs[ i ]; } |
| |
| return ints; |
| } |
| |
| /** |
| * Create test suite for StatementTest. |
| */ |
| public static Test suite() { |
| BaseTestSuite suite = new BaseTestSuite("StatementTest suite"); |
| // Decorate test suite with a TestSetup class. |
| suite.addTest(new StatementTestSetup( |
| new BaseTestSuite(StatementTest.class))); |
| suite.addTest(TestConfiguration.clientServerDecorator( |
| new StatementTestSetup(new BaseTestSuite(StatementTest.class)))); |
| return suite; |
| } |
| |
| //////////////////////////////////////////////////////////////////////// |
| // |
| // NESTED JDBC 4.2 WRAPPER AROUND A Statement |
| // |
| //////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * <p> |
| * This wrapper is used to expose JDBC 4.2 methods which can run on |
| * VM rev levels lower than Java 8. |
| * </p> |
| */ |
| public static class StatementWrapper |
| { |
| private Statement _wrappedStatement; |
| |
| public StatementWrapper( Statement wrappedStatement ) |
| { |
| _wrappedStatement = wrappedStatement; |
| } |
| |
| public Statement getWrappedStatement() { return _wrappedStatement; } |
| |
| // New methods added by JDBC 4.2 |
| public long[] executeLargeBatch() throws SQLException |
| { |
| return ((long[]) invoke |
| ( |
| "executeLargeBatch", |
| new Class[] {}, |
| new Object[] {} |
| )); |
| } |
| public long executeLargeUpdate( String sql ) throws SQLException |
| { |
| return ((Long) invoke |
| ( |
| "executeLargeUpdate", |
| new Class[] { String.class }, |
| new Object[] { sql } |
| )).longValue(); |
| } |
| public long executeLargeUpdate( String sql, int autoGeneratedKeys) throws SQLException |
| { |
| return ((Long) invoke |
| ( |
| "executeLargeUpdate", |
| new Class[] { String.class, Integer.TYPE }, |
| new Object[] { sql, autoGeneratedKeys } |
| )).longValue(); |
| } |
| public long executeLargeUpdate( String sql, int[] columnIndexes ) throws SQLException |
| { |
| return ((Long) invoke |
| ( |
| "executeLargeUpdate", |
| new Class[] { String.class, columnIndexes.getClass() }, |
| new Object[] { sql, columnIndexes } |
| )).longValue(); |
| } |
| public long executeLargeUpdate( String sql, String[] columnNames ) throws SQLException |
| { |
| return ((Long) invoke |
| ( |
| "executeLargeUpdate", |
| new Class[] { String.class, columnNames.getClass() }, |
| new Object[] { sql, columnNames } |
| )).longValue(); |
| } |
| public long getLargeMaxRows() throws SQLException |
| { |
| return ((Long) invoke |
| ( |
| "getLargeMaxRows", |
| new Class[] {}, |
| new Object[] {} |
| )).longValue(); |
| } |
| public long getLargeUpdateCount() throws SQLException |
| { |
| return ((Long) invoke |
| ( |
| "getLargeUpdateCount", |
| new Class[] {}, |
| new Object[] {} |
| )).longValue(); |
| } |
| public void setLargeMaxRows( long max ) throws SQLException |
| { |
| invoke |
| ( |
| "setLargeMaxRows", |
| new Class[] { Long.TYPE }, |
| new Object[] { max } |
| ); |
| } |
| |
| |
| // Reflection minion |
| protected Object invoke( String methodName, Class[] argTypes, Object[] argValues ) |
| throws SQLException |
| { |
| try { |
| Method method = _wrappedStatement.getClass().getMethod( methodName, argTypes ); |
| |
| return method.invoke( _wrappedStatement, argValues ); |
| } |
| catch (NoSuchMethodException nsme) { throw wrap( nsme ); } |
| catch (SecurityException se) { throw wrap( se ); } |
| catch (IllegalAccessException iae) { throw wrap( iae ); } |
| catch (IllegalArgumentException iare) { throw wrap( iare ); } |
| catch (InvocationTargetException ite) { throw wrap( ite ); } |
| } |
| private SQLException wrap( Throwable t ) { return new SQLException( t.getMessage(), t ); } |
| } |
| |
| //////////////////////////////////////////////////////////////////////// |
| // |
| // PROCEDURE FOR BUMPING THE RETURNED ROW COUNT, FOR TESTING JDBC 4.2. |
| // |
| //////////////////////////////////////////////////////////////////////// |
| |
| /** Set the base which is used for returned row counts and fetched row counters */ |
| public static void setRowCountBase( long newBase ) |
| { |
| EmbedResultSet.setFetchedRowBase( newBase ); |
| RowUtil.setRowCountBase( newBase ); |
| } |
| |
| } // End class StatementTest |
