/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed 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 tests.java.sql;
import SQLite.Database;
import SQLite.Function;
import SQLite.FunctionContext;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargetClass;
import junit.extensions.TestSetup;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import tests.support.Support_SQL;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
/**
* Functional test for the Statement.setQueryTimeout() method. Adopted from
* Apache Derby project (Apache License 2.0).
*
* TODO Test requires transaction isolation to be supported. => Ticket 69
*
* This test consists of four parts: 1. Executes a SELECT
* query in 4 different threads concurrently. The query calls a user-defined,
* server-side function which delays the execution, so that it takes several
* seconds even though the data volume is really low. The fetch operations take
* longer time than the timeout value set. Hence, this part tests getting
* timeouts from calls to ResultSet.next(). Two connections are used, two
* threads execute their statement in the context of one connection, the other
* two threads in the context of the other connection. Of the 4 threads, only
* one executes its statement with a timeout value. This way, the test ensures
* that the correct statement is affected by setQueryTimeout(), regardless of
* what connection/transaction it and other statements are executed in the
* context of.
*
* 2. Executes an INSERT query in multiple threads. This part tests
* getting timeouts from calls to Statement.execute(). Each thread executes the
* query in the context of a separate connection. There is no point in executing
* multiple statements on the same connection; since only one statement per
* connection executes at a time, there will be no interleaving of execution
* between them (contrary to the first part of this test, where calls to
* ResultSet.next() may be interleaved between the different threads). Half of
* the threads execute their statement with a timeout value set, this is to
* verify that the correct statements are affected by the timeout, while the
* other statements execute to completion.
* 3. Sets an invalid (negative)
* timeout. Verifies that the correct exception is thrown.
* 4. Tests that the query timeout value is not forgotten after the execution of a statement.
*/
@TestTargetClass(Statement.class)
public class QueryTimeoutTest extends TestCase {
private static Statement statement;
private static final int TIMEOUT = 1; // In seconds
private static final int CONNECTIONS = 100;
private static Connection[] connections = new Connection[CONNECTIONS];
private static void printSQLException(SQLException e) {
while (e != null) {
e.printStackTrace();
e = e.getNextException();
}
}
/**
* This Exception class is used for getting fail-fast behaviour in this
* test. There is no point in wasting cycles running a test to the end when
* we know that it has failed. In order to enable chaining of exceptions in
* J2ME, this class defines its own "cause", duplicating existing
* functionality in J2SE.
*/
private static class TestFailedException extends Exception {
private Throwable cause;
public TestFailedException(Throwable t) {
super();
cause = t;
}
public TestFailedException(String message) {
super(message);
cause = null;
}
public TestFailedException(String message, Throwable t) {
super(message);
cause = t;
}
public String toString() {
if (cause != null) {
return super.toString() + ": " + cause.toString();
} else {
return super.toString();
}
}
public void printStackTrace() {
super.printStackTrace();
if (cause != null) {
if (cause instanceof SQLException) {
QueryTimeoutTest.printSQLException((SQLException) cause);
} else {
cause.printStackTrace();
}
}
}
}
/**
* Used for executing the SQL statements for setting up this test (the
* preparation phase). The queries testing setQueryTimeout() are run by the
* StatementExecutor class.
*/
private static void exec(Connection connection, String queryString,
Collection ignoreExceptions) throws TestFailedException {
Statement statement = null;
try {
statement = connection.createStatement();
System.out.println(" Executing "+queryString);
statement.execute(queryString);
} catch (SQLException e) {
String sqlState = e.getSQLState();
if (!ignoreExceptions.contains(sqlState)) {
throw new TestFailedException(e); // See finally block below
}
} finally {
if (statement != null) {
try {
statement.close();
} catch (SQLException ee) {
// This will discard an exception possibly thrown above :-(
// But we don't worry too much about this, since:
// 1. This is just a test
// 2. We don't expect close() to throw
// 3. If it does, this will be inspected by a developer
throw new TestFailedException(ee);
}
}
}
}
// Convenience method
private static void exec(Connection connection, String queryString)
throws TestFailedException {
exec(connection, queryString, Collections.EMPTY_SET);
}
private static void dropTables(Connection conn, String tablePrefix)
throws TestFailedException {
Collection ignore = new HashSet();
//ignore.add("42Y55");
exec(conn, "drop table if exists " + tablePrefix + "_orig;", ignore);
exec(conn, "drop table if exists " + tablePrefix + "_copy;", ignore);
}
private static void prepareTables(Connection conn, String tablePrefix)
throws TestFailedException {
System.out.println("Initializing tables with prefix " + tablePrefix);
dropTables(conn, tablePrefix);
exec(conn, "create table " + tablePrefix + "_orig (a int)");
exec(conn, "create table " + tablePrefix + "_copy (a int)");
for (int i = 0; i < 7; i++) {
exec(conn, "insert into " + tablePrefix + "_orig"
+ " values ("+i+");");
}
}
private static String getFetchQuery(String tablePrefix) {
/**
* The reason for using the mod function here is to force at least one
* invocation of ResultSet.next() to read more than one row from the
* table before returning. This is necessary since timeout is checked
* only when reading rows from base tables, and when the first row is
* read, the query still has not exceeded the timeout.
*/
return "select a from " + tablePrefix
+ "_orig where mod(DELAY(1,a),3)=0";
}
private static String getExecQuery(String tablePrefix) {
return "insert into " + tablePrefix + "_copy select a from "
+ tablePrefix + "_orig where DELAY(1,1)=1";
}
private static class StatementExecutor extends Thread {
private PreparedStatement statement;
private boolean doFetch;
private int timeout;
private SQLException sqlException;
private String name;
private long highestRunTime;
public StatementExecutor(PreparedStatement statement, boolean doFetch,
int timeout) {
this.statement = statement;
this.doFetch = doFetch;
this.timeout = timeout;
highestRunTime = 0;
sqlException = null;
if (timeout > 0) {
try {
statement.setQueryTimeout(timeout);
} catch (SQLException e) {
sqlException = e;
}
}
}
private void setHighestRunTime(long runTime) {
synchronized (this) {
highestRunTime = runTime;
}
}
public long getHighestRunTime() {
synchronized (this) {
return highestRunTime;
}
}
private boolean fetchRow(ResultSet resultSet) throws SQLException {
long startTime = System.currentTimeMillis();
boolean hasNext = resultSet.next();
long endTime = System.currentTimeMillis();
long runTime = endTime - startTime;
if (runTime > highestRunTime) setHighestRunTime(runTime);
return hasNext;
}
public void run() {
if (sqlException != null) return;
ResultSet resultSet = null;
try {
if (doFetch) {
long startTime = System.currentTimeMillis();
resultSet = statement.executeQuery();
long endTime = System.currentTimeMillis();
setHighestRunTime(endTime - startTime);
while (fetchRow(resultSet)) {
yield();
}
} else {
long startTime = System.currentTimeMillis();
statement.execute();
long endTime = System.currentTimeMillis();
setHighestRunTime(endTime - startTime);
}
} catch (SQLException e) {
synchronized (this) {
sqlException = e;
}
} finally {
if (resultSet != null) {
try {
resultSet.close();
} catch (SQLException ex) {
if (sqlException != null) {
System.err.println("Discarding previous exception");
sqlException.printStackTrace();
}
sqlException = ex;
}
}
}
}
public SQLException getSQLException() {
synchronized (this) {
return sqlException;
}
}
}
/**
* This method compares a thrown SQLException's SQLState value to an
* expected SQLState. If they do not match, a TestFailedException is thrown
* with the given message string.
*/
private static void expectException(String expectSqlState,
SQLException sqlException, String failMsg)
throws TestFailedException {
if (sqlException == null) {
throw new TestFailedException(failMsg);
} else {
String sqlState = sqlException.getSQLState();
if (!expectSqlState.equals(sqlState)) {
throw new TestFailedException(sqlException);
}
}
}
// A convenience method which wraps a SQLException
private static PreparedStatement prepare(Connection conn, String query)
throws TestFailedException {
try {
return conn.prepareStatement(query);
} catch (SQLException e) {
throw new TestFailedException(e);
}
}
/**
* Part 1 of this test.
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Testing timeout with fetch operations",
method = "setQueryTimeout",
args = {int.class}
)
public static void testTimeoutWithFetch() throws TestFailedException {
System.out.println("Testing timeout with fetch operations");
Connection conn1 = connections[0];
Connection conn2 = connections[1];
try {
conn1.setAutoCommit(false);
conn2.setAutoCommit(false);
} catch (SQLException e) {
throw new TestFailedException("Unexpected Exception", e);
}
// The idea with these 4 statements is as follows:
// A - should time out
// B - different stmt on the same connection; should NOT time out
// C - different stmt on different connection; should NOT time out
// D - here just to create equal contention on conn1 and conn2
PreparedStatement statementA = prepare(conn1, getFetchQuery("t"));
PreparedStatement statementB = prepare(conn1, getFetchQuery("t"));
PreparedStatement statementC = prepare(conn2, getFetchQuery("t"));
PreparedStatement statementD = prepare(conn2, getFetchQuery("t"));
StatementExecutor[] statementExecutor = new StatementExecutor[4];
statementExecutor[0] = new StatementExecutor(statementA, true, TIMEOUT);
statementExecutor[1] = new StatementExecutor(statementB, true, 0);
statementExecutor[2] = new StatementExecutor(statementC, true, 0);
statementExecutor[3] = new StatementExecutor(statementD, true, 0);
for (int i = 3; i >= 0; --i) {
statementExecutor[i].start();
}
for (int i = 0; i < 4; ++i) {
try {
statementExecutor[i].join();
} catch (InterruptedException e) {
throw new TestFailedException("Should never happen", e);
}
}
/**
* Actually, there is no guarantee that setting a query timeout for a
* statement will actually cause a timeout, even if execution of the
* statement takes longer than the specified timeout. However, these
* queries execute significantly longer than the specified query
* timeout. Also, the cancellation mechanism implemented should be quite
* responsive. In sum, we expect the statement to always time out. If it
* does not time out, however, we print the highest execution time for
* the query, as an assistance in determining why it failed. Compare the
* number to the TIMEOUT constant in this class (note that the TIMEOUT
* constant is in seconds, while the execution time is in milliseconds).
*/
expectException("XCL52", statementExecutor[0].getSQLException(),
"fetch did not time out. Highest execution time: "
+ statementExecutor[0].getHighestRunTime() + " ms");
System.out.println("Statement 0 timed out");
for (int i = 1; i < 4; ++i) {
SQLException sqlException = statementExecutor[i].getSQLException();
if (sqlException != null) {
throw new TestFailedException("Unexpected exception in " + i,
sqlException);
}
System.out.println("Statement " + i + " completed");
}
try {
statementA.close();
statementB.close();
statementC.close();
statementD.close();
conn1.commit();
conn2.commit();
} catch (SQLException e) {
throw new TestFailedException(e);
}
}
/**
*
* @test {@link java.sql.Statement#setQueryTimeout(int) }
*
* Part two of this test.
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "test timeout with st.exec()",
method = "setQueryTimeout",
args = {int.class}
)
public static void testTimeoutWithExec()
throws TestFailedException {
System.out.println("Testing timeout with an execute operation");
for (int i = 0; i < connections.length; ++i) {
try {
connections[i].setAutoCommit(true);
} catch (SQLException e) {
throw new TestFailedException("Unexpected Exception", e);
}
}
PreparedStatement statements[] = new PreparedStatement[connections.length];
for (int i = 0; i < statements.length; ++i) {
statements[i] = prepare(connections[i], getExecQuery("t"));
}
StatementExecutor[] executors = new StatementExecutor[statements.length];
for (int i = 0; i < executors.length; ++i) {
int timeout = (i % 2 == 0) ? TIMEOUT : 0;
executors[i] = new StatementExecutor(statements[i], false, timeout);
}
for (int i = 0; i < executors.length; ++i) {
executors[i].start();
}
for (int i = 0; i < executors.length; ++i) {
try {
executors[i].join();
} catch (InterruptedException e) {
throw new TestFailedException("Should never happen", e);
}
}
/**
* Actually, there is no guarantee that setting a query timeout for a
* statement will actually cause a timeout, even if execution of the
* statement takes longer than the specified timeout. However, these
* queries execute significantly longer than the specified query
* timeout. Also, the cancellation mechanism implemented should be quite
* responsive. In sum, we expect the statement to always time out. If it
* does not time out, however, we print the highest execution time for
* the query, as an assistance in determining why it failed. Compare the
* number to the TIMEOUT constant in this class (note that the TIMEOUT
* constant is in seconds, while the execution time is in milliseconds).
*/
for (int i = 0; i < executors.length; ++i) {
int timeout = (i % 2 == 0) ? TIMEOUT : 0;
if (timeout > 0) {
expectException("XCL52", executors[i].getSQLException(),
"exec did not time out. Execution time: "
+ executors[i].getHighestRunTime() + " ms");
} else {
SQLException sqlException = executors[i].getSQLException();
if (sqlException != null) {
throw new TestFailedException(sqlException);
}
}
}
System.out
.println("Statements that should time out timed out, and statements that should complete completed");
for (int i = 0; i < statements.length; ++i) {
try {
statements[i].close();
} catch (SQLException e) {
throw new TestFailedException(e);
}
}
}
/**
*
* @test {@link java.sql.Statement#setQueryTimeout(int) }
*
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Testing setting a negative timeout value",
method = "setQueryTimeout",
args = {int.class}
)
public static void testInvalidTimeoutValue(Connection conn)
throws TestFailedException {
try {
conn.setAutoCommit(true);
} catch (SQLException e) {
throw new TestFailedException("Unexpected Exception", e);
}
// Create statement
PreparedStatement stmt = null;
try {
stmt = conn.prepareStatement("select * from sys.systables");
} catch (SQLException e) {
throw new TestFailedException("Unexpected Exception", e);
}
// Set (invalid) timeout value - expect exception
try {
stmt.setQueryTimeout(-1);
} catch (SQLException e) {
expectException("XJ074", e,
"negative timeout value should give exception");
}
System.out
.println("Negative timeout value caused exception, as expected");
// Execute the statement and fetch result
ResultSet rs = null;
try {
rs = stmt.executeQuery();
System.out.println("Execute returned a ResultSet");
rs.close();
} catch (SQLException e) {
throw new TestFailedException("Unexpected Exception", e);
} finally {
try {
stmt.close();
} catch (SQLException e) {
// This will discard an exception possibly thrown above :-(
// But we don't worry too much about this, since:
// 1. This is just a test
// 2. We don't expect close() to throw
// 3. If it does, this will be inspected by a developer
throw new TestFailedException("close should not throw", e);
}
}
}
/**
*
* @test {@link java.sql.Statement#setQueryTimeout(int) }
*
* Part two of this test.
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "timeout with executeUpdate call",
method = "setQueryTimeout",
args = {int.class}
)
public static void testTimeoutWithExecuteUpdate()
throws TestFailedException {
System.out.println("Testing timeout with executeUpdate call.");
try {
Statement stmt = connections[0].createStatement();
stmt.setQueryTimeout(TIMEOUT);
stmt.executeUpdate(getExecQuery("t"));
} catch (SQLException sqle) {
expectException("XCL52", sqle, "Should have timed out.");
}
}
/** Test for DERBY-1692. */
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Testing that Statement considers timeout.",
method = "setQueryTimeout",
args = {int.class}
)
public static void testRememberTimeoutValue()
throws TestFailedException {
String sql = getFetchQuery("t");
try {
Statement stmt = connections[0].createStatement();
statementRemembersTimeout(stmt);
PreparedStatement ps = connections[0].prepareStatement(sql);
statementRemembersTimeout(ps);
CallableStatement cs = connections[0].prepareCall(sql);
statementRemembersTimeout(cs);
} catch (SQLException sqle) {
throw new TestFailedException("Unexpected Exception", sqle);
}
}
public static void statementRemembersTimeout(Statement stmt)
throws SQLException, TestFailedException {
System.out.println("Testing that Statement remembers timeout.");
stmt.setQueryTimeout(1);
for (int i = 0; i < 3; i++) {
try {
ResultSet rs = stmt.executeQuery(getFetchQuery("t"));
while (rs.next()) {
// do nothing
}
throw new TestFailedException("Should have timed out.");
} catch (SQLException sqle) {
expectException("XCL52", sqle, "Should have timed out.");
}
}
stmt.close();
}
private static void statementRemembersTimeout(PreparedStatement ps)
throws SQLException, TestFailedException {
String name = (ps instanceof CallableStatement) ? "CallableStatement"
: "PreparedStatement";
System.out.println("Testing that " + name + " remembers timeout.");
ps.setQueryTimeout(1);
for (int i = 0; i < 3; i++) {
try {
ResultSet rs = ps.executeQuery();
while (rs.next()) {
// do nothing
}
throw new TestFailedException("Should have timed out.");
} catch (SQLException sqle) {
expectException("XCL52", sqle, "Should have timed out.");
}
}
ps.close();
}
/**
* A function
* arg0 : int seconds
*
*/
static class Delay implements SQLite.Function {
public void function(FunctionContext fc, String[] args) {
int seconds = new Integer(args[0]).intValue();
int value = new Integer(args[1]).intValue();
try {
Thread.sleep(seconds * 1000);
} catch (InterruptedException e) {
// Ignore
}
fc.set_result(value);
}
public void last_step(FunctionContext fc) {
// TODO Auto-generated method stub
}
public void step(FunctionContext fc, String[] args) {
// TODO Auto-generated method stub
}
}
/**
* The actual main bulk of this test. Sets up the environment, prepares
* tables, runs the tests, and shuts down.
*/
public static Test suite() {
TestSetup setup = new TestSetup( new TestSuite (QueryTimeoutTest.class)) {
public void setUp() {
// Establish connections
Support_SQL.loadDriver();
try {
for (int i = 0; i < connections.length; ++i) {
connections[i] = Support_SQL.getConnection();
}
for (int i = 0; i < connections.length; ++i) {
connections[i]
.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
}
// setup Delay function
prepare();
} catch (Throwable e) {
fail("Unexpected SQLException " + e.toString());
}
System.out.println("Connections set up");
}
public void tearDown() {
for (int i = connections.length - 1; i >= 0; --i) {
if (connections[i] != null) {
try {
connections[i].close();
} catch (SQLException ex) {
printSQLException(ex);
}
}
}
System.out.println("Closed connections");
}
public void prepare() throws TestFailedException {
System.out.println("Preparing for testing queries with timeout");
Database db = new Database();
Connection conn = connections[0];
try {
db.open(Support_SQL.getFilename(), 1);
conn.setAutoCommit(true);
} catch (Exception e) {
throw new TestFailedException("Unexpected Exception", e);
}
Function delayFc = new Delay();
db.create_function("DELAY", 2, delayFc);
prepareTables(conn, "t");
}
};
TestSuite ts = new TestSuite();
ts.addTestSuite(QueryTimeoutTest.class);
return setup;
}
}