Java Code Examples for java.sql.PreparedStatement#setCursorName()

private PreparedStatement createFloatStatementForStateChecking(
    int[] parameterExpectedValues, int[] PreparedStatementExpectedValues,
    Connection conn, String sql) 
throws SQLException {
    PreparedStatement s = 
        internalCreateFloatStatementForStateChecking(conn, sql);
    s.setCursorName("StokeNewington");
    s.setFetchDirection(ResultSet.FETCH_REVERSE);
    s.setFetchSize(888);
    s.setMaxFieldSize(317);
    s.setMaxRows(91);

    // PreparedStatement Create        
    assertStatementState(
        parameterExpectedValues, PreparedStatementExpectedValues, s);
    return s;
}
 

private PreparedStatement createFloatStatementForStateChecking(
        int[] parameterExpectedValues, int[] PreparedStatementExpectedValues,
        Connection conn, String sql)
        throws SQLException {
    PreparedStatement s =
            internalCreateFloatStatementForStateChecking(conn, sql);
    s.setCursorName("StokeNewington");
    s.setFetchDirection(ResultSet.FETCH_REVERSE);
    s.setFetchSize(888);
    s.setMaxFieldSize(317);
    s.setMaxRows(91);

    // PreparedStatement Create        
    assertStatementState(
            parameterExpectedValues, PreparedStatementExpectedValues, s);
    return s;
}
 

private void runWhereCurrentOf(Connection conn) throws SQLException {
  Statement stmtForTableAndInsert = conn.createStatement();
  stmtForTableAndInsert.execute("create table Employee"
      + "(firstname varchar(50) not null, lastname varchar(50) not null, "
      + "workdept varchar(50), bonus decimal(10,4), "
      + "primary key (firstname, lastname))");
  stmtForTableAndInsert
      .execute("insert into employee values('neeraj', 'kumar', 'rnd', 0.0), "
          + "('asif', 'shahid', 'rnd', 1.0), "
          + "('dada', 'ji', 'rnd', 2.0), ('sum', 'wale', 'rnd', 3.0)");
  conn.setTransactionIsolation(getIsolationLevel());
  PreparedStatement ps = conn.prepareStatement("SELECT workdept, bonus "
      + "FROM EMPLOYEE FOR UPDATE of workdept");
  ps.setCursorName("C1");
  ps.executeQuery();
  try {
    conn
        .prepareStatement("update employee set workdept = ? where current of C1");
    fail("exception expected");
  } catch (SQLException e) {
    if (!"0A000".equalsIgnoreCase(e.getSQLState())) {
      throw e;
    }
  }
}
 

private PreparedStatement createFloatStatementForStateChecking(
    int[] parameterExpectedValues, int[] PreparedStatementExpectedValues,
    Connection conn, String sql) 
throws SQLException {
    PreparedStatement s = 
        internalCreateFloatStatementForStateChecking(conn, sql);
    s.setCursorName("StokeNewington");
    s.setFetchDirection(ResultSet.FETCH_REVERSE);
    s.setFetchSize(888);
    s.setMaxFieldSize(317);
    s.setMaxRows(91);

    // PreparedStatement Create        
    assertStatementState(
        parameterExpectedValues, PreparedStatementExpectedValues, s);
    return s;
}
 

/**
 * Test that Statement.setCursorName affects only the next
 * execution and not any open ResultSet.
 */
public void derby2417testSetCursorNextExecute() throws SQLException
{
    // Assert setCursorName only affects the next execution.
    // For statements
    Statement s = createStatement();
    ResultSet rs = s.executeQuery("select * from t for update");
    s.setCursorName("AFTER_EXECUTE");
    assertFalse("AFTER_EXECUTE".equals(rs.getCursorName()));
    rs.close();
    rs = s.executeQuery("select * from t");
    assertEquals("AFTER_EXECUTE", rs.getCursorName());
    s.setCursorName("CHANGE_AGAIN");
    assertEquals("AFTER_EXECUTE", rs.getCursorName());
    rs.close();
    rs = s.executeQuery("select * from t");
    assertEquals("CHANGE_AGAIN", rs.getCursorName());
    s.close();

    // And prepared statements
    PreparedStatement ps = prepareStatement("select * from t for update");
    rs = ps.executeQuery();
    ps.setCursorName("AFTER_EXECUTE");
    assertFalse("AFTER_EXECUTE".equals(rs.getCursorName()));
    rs.close();
    rs = ps.executeQuery();
    assertEquals("AFTER_EXECUTE", rs.getCursorName());
    ps.setCursorName("CHANGE_AGAIN");
    assertEquals("AFTER_EXECUTE", rs.getCursorName());
    rs.close();
    rs = ps.executeQuery();
    assertEquals("CHANGE_AGAIN", rs.getCursorName());
    ps.close();

}
 

/**
 * Test that Statement.setCursorName affects only the next
 * execution and not any open ResultSet.
 */
public void derby2417testSetCursorNextExecute() throws SQLException
{   
    // Assert setCursorName only affects the next execution.
    // For statements
    Statement s = createStatement();
    ResultSet rs = s.executeQuery("select * from t for update");
    s.setCursorName("AFTER_EXECUTE");
    assertFalse("AFTER_EXECUTE".equals(rs.getCursorName()));
    rs.close();
    rs = s.executeQuery("select * from t");
    assertEquals("AFTER_EXECUTE", rs.getCursorName());
    s.setCursorName("CHANGE_AGAIN");
    assertEquals("AFTER_EXECUTE", rs.getCursorName());
    rs.close();
    rs = s.executeQuery("select * from t");
    assertEquals("CHANGE_AGAIN", rs.getCursorName());
    s.close();
    
    // And prepared statements
    PreparedStatement ps = prepareStatement("select * from t for update");
    rs = ps.executeQuery();
    ps.setCursorName("AFTER_EXECUTE");
    assertFalse("AFTER_EXECUTE".equals(rs.getCursorName()));
    rs.close();
    rs = ps.executeQuery();
    assertEquals("AFTER_EXECUTE", rs.getCursorName());
    ps.setCursorName("CHANGE_AGAIN");
    assertEquals("AFTER_EXECUTE", rs.getCursorName());
    rs.close();
    rs = ps.executeQuery();
    assertEquals("CHANGE_AGAIN", rs.getCursorName());
    ps.close();        
   
}
 

/**
 * Test cursor methods with parameter
 * 
 * @throws SQLException
 */
public void testCursorParam() throws SQLException {
    PreparedStatement select;
    ResultSet cursor;
    select = prepareStatement("select i, c from t where ?=1 for update");
    select.setInt(1, 1);
    cursor = select.executeQuery();
    // TEST: fetch of a row works
    assertTrue("FAIL: unable to fetch row.", cursor.next());
    assertEquals("FAIL: Wrong row on fetch with param", 1956, cursor
            .getInt(1));
    // TEST: Close and then fetch gets an error on fetch.
    cursor.close();
    assertNextError("XCL16", cursor);
    // restart the query for another test
    select.setBoolean(1, false);
    select.setCursorName("ForCoverageSake");
    cursor = select.executeQuery();
    assertEquals("ForCoverageSake", cursor.getCursorName());
    cursor.next();
    if (usingEmbedded()) {
        assertGetIntError(1, "24000", cursor);
    } else if (usingDerbyNetClient()) {
        assertGetIntError(1, "XJ121", cursor);
    }
    cursor.close();
}
 

/**
 * Test cursor methods with parameter
 *
 * @throws SQLException
 */
public void testCursorParam() throws SQLException {
    PreparedStatement select;
    ResultSet cursor;
    // GemStone changes BEGIN
    //select = prepareStatement("select i, c from t where ?=1 for update");
    select = prepareStatement("select i, c from t where ?=1 order by i desc");
    // GemStone changes END

    select.setInt(1, 1);
    cursor = select.executeQuery();
    // TEST: fetch of a row works
    assertTrue("FAIL: unable to fetch row.", cursor.next());
    assertEquals("FAIL: Wrong row on fetch with param", 1956, cursor
            .getInt(1));
    // TEST: Close and then fetch gets an error on fetch.
    cursor.close();
    assertNextError("XCL16", cursor);
    // restart the query for another test
    select.setBoolean(1, false);
    select.setCursorName("ForCoverageSake");
    cursor = select.executeQuery();
    assertEquals("ForCoverageSake", cursor.getCursorName());
    cursor.next();
    if (usingEmbedded()) {
        assertGetIntError(1, "24000", cursor);
    } else if (usingDerbyNetClient()) {
        assertGetIntError(1, "XJ121", cursor);
    }
    cursor.close();
}
 

/**
 * Test that Statement.setCursorName affects only the next
 * execution and not any open ResultSet.
 */
public void derby2417testSetCursorNextExecute() throws SQLException
{
    // Assert setCursorName only affects the next execution.
    // For statements
    Statement s = createStatement();
    ResultSet rs = s.executeQuery("select * from t for update");
    s.setCursorName("AFTER_EXECUTE");
    assertFalse("AFTER_EXECUTE".equals(rs.getCursorName()));
    rs.close();
    rs = s.executeQuery("select * from t");
    assertEquals("AFTER_EXECUTE", rs.getCursorName());
    s.setCursorName("CHANGE_AGAIN");
    assertEquals("AFTER_EXECUTE", rs.getCursorName());
    rs.close();
    rs = s.executeQuery("select * from t");
    assertEquals("CHANGE_AGAIN", rs.getCursorName());
    s.close();

    // And prepared statements
    PreparedStatement ps = prepareStatement("select * from t for update");
    rs = ps.executeQuery();
    ps.setCursorName("AFTER_EXECUTE");
    assertFalse("AFTER_EXECUTE".equals(rs.getCursorName()));
    rs.close();
    rs = ps.executeQuery();
    assertEquals("AFTER_EXECUTE", rs.getCursorName());
    ps.setCursorName("CHANGE_AGAIN");
    assertEquals("AFTER_EXECUTE", rs.getCursorName());
    rs.close();
    rs = ps.executeQuery();
    assertEquals("CHANGE_AGAIN", rs.getCursorName());
    ps.close();

}
 

/**
 * Test cursor methods with parameter
 *
 * @throws SQLException
 */
public void testCursorParam() throws SQLException {
    PreparedStatement select;
    ResultSet cursor;
    // GemStone changes BEGIN
    //select = prepareStatement("select i, c from t where ?=1 for update");
    select = prepareStatement("select i, c from t where ?=1 order by i desc");
    // GemStone changes END

    select.setInt(1, 1);
    cursor = select.executeQuery();
    // TEST: fetch of a row works
    assertTrue("FAIL: unable to fetch row.", cursor.next());
    assertEquals("FAIL: Wrong row on fetch with param", 1956, cursor
            .getInt(1));
    // TEST: Close and then fetch gets an error on fetch.
    cursor.close();
    assertNextError("XCL16", cursor);
    // restart the query for another test
    select.setBoolean(1, false);
    select.setCursorName("ForCoverageSake");
    cursor = select.executeQuery();
    assertEquals("ForCoverageSake", cursor.getCursorName());
    cursor.next();
    if (usingEmbedded()) {
        assertGetIntError(1, "24000", cursor);
    } else if (usingDerbyNetClient()) {
        assertGetIntError(1, "XJ121", cursor);
    }
    cursor.close();
}
 

/**
    * Test what happens to a positioned update when the cursor
    * it is compiled against changes to the SQL provided, changeToSQL. 
    * This test first prepares a cursor initialCursor 
    * using with the given name (or system name if null is passed in)
    * A cursor is opened and a positioned update is opened that updates.
    * 
    * If sqlState is null then no error is expected and thus the
    * positioned statement must update a single row.
    * Otherwise sqlState is the exected exception for the update.
    * 
    * If no error is expected then three rows will be either
    * updated or deleted depending on the positioned statement.
    * 
    * If an error is expected then two rows will be updated
    * or deleted.
    */
private void cursorChange(String sqlState,
           String cursorName,
           String initialCursor,
           String positionedStatement,
           String changeToCursor) throws SQLException {

	PreparedStatement select = prepareStatement(initialCursor);
	if (cursorName != null)
		select.setCursorName(cursorName);

	ResultSet cursor = select.executeQuery(); // cursor is now open

	// TEST: find the cursor during compilation
	cursorName = cursor.getCursorName();
	PreparedStatement update = prepareStatement(
               positionedStatement + cursorName);
	assertTrue(cursor.next());
	assertUpdateCount(update, 1);
	cursor.close();

	// now prepare the a cursor with the same name but different SQL.
	PreparedStatement selectdd = prepareStatement(changeToCursor);
	selectdd.setCursorName(cursorName);
	cursor = selectdd.executeQuery();
	assertTrue(cursor.next());
       if (sqlState != null)
	    assertStatementError(sqlState,update);
       else
           assertUpdateCount(update, 1);

	cursor.close();
	
	// now execute the original statement again and the positioned update
	// will work.
	cursor = select.executeQuery();
	cursor.next();
	assertUpdateCount(update, 1);

	cursor.close();
	update.close();
	selectdd.close();
	select.close();

}
 

/**
    * Test what happens to a positioned update when the cursor
    * it is compiled against changes to the SQL provided, changeToSQL. 
    * This test first prepares a cursor initialCursor 
    * using with the given name (or system name if null is passed in)
    * A cursor is opened and a positioned update is opened that updates.
    * 
    * If sqlState is null then no error is expected and thus the
    * positioned statement must update a single row.
    * Otherwise sqlState is the exected exception for the update.
    * 
    * If no error is expected then three rows will be either
    * updated or deleted depending on the positioned statement.
    * 
    * If an error is expected then two rows will be updated
    * or deleted.
    */
private void cursorChange(String sqlState,
           String cursorName,
           String initialCursor,
           String positionedStatement,
           String changeToCursor) throws SQLException {

	PreparedStatement select = prepareStatement(initialCursor);
	if (cursorName != null)
		select.setCursorName(cursorName);

	ResultSet cursor = select.executeQuery(); // cursor is now open

	// TEST: find the cursor during compilation
	cursorName = cursor.getCursorName();
	PreparedStatement update = prepareStatement(
               positionedStatement + cursorName);
	assertTrue(cursor.next());
	assertUpdateCount(update, 1);
	cursor.close();

	// now prepare the a cursor with the same name but different SQL.
	PreparedStatement selectdd = prepareStatement(changeToCursor);
	selectdd.setCursorName(cursorName);
	cursor = selectdd.executeQuery();
	assertTrue(cursor.next());
       if (sqlState != null)
	    assertStatementError(sqlState,update);
       else
           assertUpdateCount(update, 1);

	cursor.close();
	
	// now execute the original statement again and the positioned update
	// will work.
	cursor = select.executeQuery();
	cursor.next();
	assertUpdateCount(update, 1);

	cursor.close();
	update.close();
	selectdd.close();
	select.close();

}
 

/**
    * Test read only statements.
 */
public void testReadOnlyCursors() throws SQLException {
	
	String[] readOnlySQL = 
	{
           "select I, C from t for read only",
           "select I, C from t for fetch only",
           "select I, C FROM T ORDER BY 1",
           "values (1, 2, 3)",
           
           // TEST: Update of cursor with a union
           "select I, C from t union all select I, C from t",
           // TEST: Update of cursor with a join
           "select t1.I, t1.C from t t1, t t2 where t1.I = t2.I",
           // TEST: Update of cursor with a derived table
           "select I, C from (select * from t) t1",
           // TEST: Update of cursor with a subquery
           "select I, C from t where I in (select I from t)"
                  
	};
       
       // NOTE: JDK 1.4 javadoc for ResultSet.getCursorName()
       // says it will throw an execption if the statement
       // cannot support a positioned update. However that
       // line was removed in JavaSE 6 (JDBC 4) javadoc.
       
       for (int i = 0; i < readOnlySQL.length; i++)
       {
           // The system will not give a cursor name
           // to a read only statement.
           PreparedStatement select = prepareStatement(readOnlySQL[i]);
           ResultSet cursor = select.executeQuery();
           assertNull(readOnlySQL[i], cursor.getCursorName());
           cursor.close();
           
           // but will if the user supplies one.
           select.setCursorName("PLEASE_UPDATE");
           cursor = select.executeQuery();
           assertEquals(readOnlySQL[i], "PLEASE_UPDATE", cursor.getCursorName());
           
           // but the cursor is marked as read only so positioned
           // statements will fail.
           assertCompileError("42X23",
                   "DELETE FROM T WHERE CURRENT OF PLEASE_UPDATE");
           
           assertCompileError("42X23",
               "UPDATE T SET I = 3 WHERE CURRENT OF PLEASE_UPDATE");
           
           cursor.close();
           select.close();
       }
}
 

/**
 * Test CurrentOfResultSet
 */
//GemFireXD does not support UPDATE WHERE CURRENT OF
//public void testCurrentOfResultSet() throws Exception {
public void _testCurrentOfResultSet() throws Exception {
    createTestTable("dept", DS, "dept_data");
    createTestTable("emp", ES+","+DNO+")", "emp_data");

    PreparedStatement selForUpd = prepareStatement
        ("select * from dept for update of dname");
    selForUpd.setCursorName("C1");
    ResultSet rs = selForUpd.executeQuery();
    // CurrentOfResultSet, NormalizeResultSet,
    // ProjectRestrictResultSet, UpdateResultSet
    PreparedStatement tst = prepareStatement
        ("update dept set dname = ? where current of C1");

    PreparedStatement sel = prepareStatement("select dname from dept");

    Object[][][] expected = new Object[][][] {
        {{"foobar___0"},{"OFC       "},{"CS        "}},
        {{"foobar___0"},{"foobar___1"},{"CS        "}},
        {{"foobar___0"},{"foobar___1"},{"foobar___2"}}
    };

    for (int i = 0; i < expected.length; ++i) {
        assertTrue(rs.next());
        tst.setObject(1, expected[i][i][0]);
        tst.executeUpdate();
        ResultSet sel_rs = sel.executeQuery();
        assertResultSet("i="+i+" ?="+expected[i][i][0],
                        expected[i], sel_rs);
        // Re-execute tst with the same parameters
        tst.executeUpdate();
        sel_rs = sel.executeQuery();
        assertResultSet("Ri="+i+" ?="+expected[i][i][0],
                        expected[i], sel_rs);
    }
    assertFalse(rs.next());
    rs.close();
    tst.close();
    sel.close();
    selForUpd.close();
}
 

/**
    * Test read only statements.
 */
public void testReadOnlyCursors() throws SQLException {
	
	String[] readOnlySQL = 
	{
           "select I, C from t for read only",
           "select I, C from t for fetch only",
           "select I, C FROM T ORDER BY 1",
           "values (1, 2, 3)",
           
           // TEST: Update of cursor with a union
           "select I, C from t union all select I, C from t",
           // TEST: Update of cursor with a join
           "select t1.I, t1.C from t t1, t t2 where t1.I = t2.I",
           // TEST: Update of cursor with a derived table
           "select I, C from (select * from t) t1",
           // TEST: Update of cursor with a subquery
           "select I, C from t where I in (select I from t)"
                  
	};
       
       // NOTE: JDK 1.4 javadoc for ResultSet.getCursorName()
       // says it will throw an execption if the statement
       // cannot support a positioned update. However that
       // line was removed in JavaSE 6 (JDBC 4) javadoc.
       
       for (int i = 0; i < readOnlySQL.length; i++)
       {
           // The system will not give a cursor name
           // to a read only statement.
           PreparedStatement select = prepareStatement(readOnlySQL[i]);
           ResultSet cursor = select.executeQuery();
           assertNull(readOnlySQL[i], cursor.getCursorName());
           cursor.close();
           
           // but will if the user supplies one.
           select.setCursorName("PLEASE_UPDATE");
           cursor = select.executeQuery();
           assertEquals(readOnlySQL[i], "PLEASE_UPDATE", cursor.getCursorName());
           
           // but the cursor is marked as read only so positioned
           // statements will fail.
           assertCompileError("42X23",
                   "DELETE FROM T WHERE CURRENT OF PLEASE_UPDATE");
           
           assertCompileError("42X23",
               "UPDATE T SET I = 3 WHERE CURRENT OF PLEASE_UPDATE");
           
           cursor.close();
           select.close();
       }
}
 

/**
    * Test what happens to a positioned update when the cursor
    * it is compiled against changes to the SQL provided, changeToSQL. 
    * This test first prepares a cursor initialCursor 
    * using with the given name (or system name if null is passed in)
    * A cursor is opened and a positioned update is opened that updates.
    * 
    * If sqlState is null then no error is expected and thus the
    * positioned statement must update a single row.
    * Otherwise sqlState is the exected exception for the update.
    * 
    * If no error is expected then three rows will be either
    * updated or deleted depending on the positioned statement.
    * 
    * If an error is expected then two rows will be updated
    * or deleted.
    */
private void cursorChange(String sqlState,
           String cursorName,
           String initialCursor,
           String positionedStatement,
           String changeToCursor) throws SQLException {

	PreparedStatement select = prepareStatement(initialCursor);
	if (cursorName != null)
		select.setCursorName(cursorName);

	ResultSet cursor = select.executeQuery(); // cursor is now open

	// TEST: find the cursor during compilation
	cursorName = cursor.getCursorName();
	PreparedStatement update = prepareStatement(
               positionedStatement + cursorName);
	assertTrue(cursor.next());
	assertUpdateCount(update, 1);
	cursor.close();

	// now prepare the a cursor with the same name but different SQL.
	PreparedStatement selectdd = prepareStatement(changeToCursor);
	selectdd.setCursorName(cursorName);
	cursor = selectdd.executeQuery();
	assertTrue(cursor.next());
       if (sqlState != null)
	    assertStatementError(sqlState,update);
       else
           assertUpdateCount(update, 1);

	cursor.close();
	
	// now execute the original statement again and the positioned update
	// will work.
	cursor = select.executeQuery();
	cursor.next();
	assertUpdateCount(update, 1);

	cursor.close();
	update.close();
	selectdd.close();
	select.close();

}
 

@Test
public void testPreparedStatementConfig() throws SQLException {
    PreparedStatement preparedStatement = swConnection.prepareStatement("INSERT INTO test VALUES( ? , ?)", 1);
    preparedStatement.setInt(1, 1);
    preparedStatement.setString(2, "a");
    preparedStatement.getUpdateCount();
    preparedStatement.setFetchDirection(1);
    preparedStatement.getFetchDirection();
    preparedStatement.getResultSetConcurrency();
    preparedStatement.getResultSetType();
    preparedStatement.isClosed();
    preparedStatement.setPoolable(false);
    preparedStatement.isPoolable();
    preparedStatement.getWarnings();
    preparedStatement.clearWarnings();
    preparedStatement.setCursorName("test");
    preparedStatement.setMaxFieldSize(11);
    preparedStatement.getMaxFieldSize();
    preparedStatement.setMaxRows(10);
    preparedStatement.getMaxRows();
    preparedStatement.getParameterMetaData();
    preparedStatement.setEscapeProcessing(true);
    preparedStatement.setFetchSize(1);
    preparedStatement.getFetchSize();
    preparedStatement.setQueryTimeout(1);
    preparedStatement.getQueryTimeout();
    Connection connection = preparedStatement.getConnection();

    preparedStatement.execute();

    preparedStatement.getMoreResults();
    preparedStatement.getMoreResults(1);
    preparedStatement.getResultSetHoldability();
    preparedStatement.getMetaData();
    preparedStatement.getResultSet();

    preparedStatement.close();
    verify(mysqlPreparedStatement).getUpdateCount();
    verify(mysqlPreparedStatement).getMoreResults();
    verify(mysqlPreparedStatement).setFetchDirection(anyInt());
    verify(mysqlPreparedStatement).getFetchDirection();
    verify(mysqlPreparedStatement).getResultSetType();
    verify(mysqlPreparedStatement).isClosed();
    verify(mysqlPreparedStatement).setPoolable(anyBoolean());
    verify(mysqlPreparedStatement).getWarnings();
    verify(mysqlPreparedStatement).clearWarnings();
    verify(mysqlPreparedStatement).setCursorName(anyString());
    verify(mysqlPreparedStatement).setMaxFieldSize(anyInt());
    verify(mysqlPreparedStatement).getMaxFieldSize();
    verify(mysqlPreparedStatement).setMaxRows(anyInt());
    verify(mysqlPreparedStatement).getMaxRows();
    verify(mysqlPreparedStatement).setEscapeProcessing(anyBoolean());
    verify(mysqlPreparedStatement).getResultSetConcurrency();
    verify(mysqlPreparedStatement).getResultSetConcurrency();
    verify(mysqlPreparedStatement).getResultSetType();
    verify(mysqlPreparedStatement).getMetaData();
    verify(mysqlPreparedStatement).getParameterMetaData();
    verify(mysqlPreparedStatement).getMoreResults(anyInt());
    verify(mysqlPreparedStatement).setFetchSize(anyInt());
    verify(mysqlPreparedStatement).getFetchSize();
    verify(mysqlPreparedStatement).getQueryTimeout();
    verify(mysqlPreparedStatement).setQueryTimeout(anyInt());
    verify(mysqlPreparedStatement).getResultSet();
    assertThat(connection, CoreMatchers.<Connection>is(swConnection));
}
 

/**
 * Test CurrentOfResultSet
 */
//GemFireXD does not support UPDATE WHERE CURRENT OF
//public void testCurrentOfResultSet() throws Exception {
public void _testCurrentOfResultSet() throws Exception {
    createTestTable("dept", DS, "dept_data");
    createTestTable("emp", ES+","+DNO+")", "emp_data");

    PreparedStatement selForUpd = prepareStatement
        ("select * from dept for update of dname");
    selForUpd.setCursorName("C1");
    ResultSet rs = selForUpd.executeQuery();
    // CurrentOfResultSet, NormalizeResultSet,
    // ProjectRestrictResultSet, UpdateResultSet
    PreparedStatement tst = prepareStatement
        ("update dept set dname = ? where current of C1");

    PreparedStatement sel = prepareStatement("select dname from dept");

    Object[][][] expected = new Object[][][] {
        {{"foobar___0"},{"OFC       "},{"CS        "}},
        {{"foobar___0"},{"foobar___1"},{"CS        "}},
        {{"foobar___0"},{"foobar___1"},{"foobar___2"}}
    };

    for (int i = 0; i < expected.length; ++i) {
        assertTrue(rs.next());
        tst.setObject(1, expected[i][i][0]);
        tst.executeUpdate();
        ResultSet sel_rs = sel.executeQuery();
        assertResultSet("i="+i+" ?="+expected[i][i][0],
                        expected[i], sel_rs);
        // Re-execute tst with the same parameters
        tst.executeUpdate();
        sel_rs = sel.executeQuery();
        assertResultSet("Ri="+i+" ?="+expected[i][i][0],
                        expected[i], sel_rs);
    }
    assertFalse(rs.next());
    rs.close();
    tst.close();
    sel.close();
    selForUpd.close();
}
 

/**
 * Test CurrentOfResultSet
 */
public void testCurrentOfResultSet() throws Exception {
    createTestTable("dept", DS, "dept_data");
    createTestTable("emp", ES+","+DNO+")", "emp_data");

    PreparedStatement selForUpd = prepareStatement
        ("select * from dept for update of dname");
    selForUpd.setCursorName("C1");
    ResultSet rs = selForUpd.executeQuery();
    // CurrentOfResultSet, NormalizeResultSet,
    // ProjectRestrictResultSet, UpdateResultSet
    PreparedStatement tst = prepareStatement
        ("update dept set dname = ? where current of C1");

    PreparedStatement sel = prepareStatement("select dname from dept");

    Object[][][] expected = new Object[][][] {
        {{"foobar___0"},{"OFC       "},{"CS        "}},
        {{"foobar___0"},{"foobar___1"},{"CS        "}},
        {{"foobar___0"},{"foobar___1"},{"foobar___2"}}
    };

    for (int i = 0; i < expected.length; ++i) {
        assertTrue(rs.next());
        tst.setObject(1, expected[i][i][0]);
        tst.executeUpdate();
        ResultSet sel_rs = sel.executeQuery();
        assertResultSet("i="+i+" ?="+expected[i][i][0],
                        expected[i], sel_rs);
        // Re-execute tst with the same parameters
        tst.executeUpdate();
        sel_rs = sel.executeQuery();
        assertResultSet("Ri="+i+" ?="+expected[i][i][0],
                        expected[i], sel_rs);
    }
    assertFalse(rs.next());
    rs.close();
    tst.close();
    sel.close();
    selForUpd.close();
}
 

/**
    * Test read only statements.
 */
public void testReadOnlyCursors() throws SQLException {
	
	String[] readOnlySQL = 
	{
           "select I, C from t for read only",
           "select I, C from t for fetch only",
           "select I, C FROM T ORDER BY 1",
           "values (1, 2, 3)",
           
           // TEST: Update of cursor with a union
           "select I, C from t union all select I, C from t",
           // TEST: Update of cursor with a join
           "select t1.I, t1.C from t t1, t t2 where t1.I = t2.I",
           // TEST: Update of cursor with a derived table
           "select I, C from (select * from t) t1",
           // TEST: Update of cursor with a subquery
           "select I, C from t where I in (select I from t)"
                  
	};
       
       // NOTE: JDK 1.4 javadoc for ResultSet.getCursorName()
       // says it will throw an execption if the statement
       // cannot support a positioned update. However that
       // line was removed in JavaSE 6 (JDBC 4) javadoc.
       
       for (int i = 0; i < readOnlySQL.length; i++)
       {
           // The system will not give a cursor name
           // to a read only statement.
           PreparedStatement select = prepareStatement(readOnlySQL[i]);
           ResultSet cursor = select.executeQuery();
           assertNull(readOnlySQL[i], cursor.getCursorName());
           cursor.close();
           
           // but will if the user supplies one.
           select.setCursorName("PLEASE_UPDATE");
           cursor = select.executeQuery();
           assertEquals(readOnlySQL[i], "PLEASE_UPDATE", cursor.getCursorName());
           
           // but the cursor is marked as read only so positioned
           // statements will fail.
           assertCompileError("42X23",
                   "DELETE FROM T WHERE CURRENT OF PLEASE_UPDATE");
           
           assertCompileError("42X23",
               "UPDATE T SET I = 3 WHERE CURRENT OF PLEASE_UPDATE");
           
           cursor.close();
           select.close();
       }
}