package SQLite.JDBC2z;
import java.sql.*;
import java.util.*;
public class JDBCStatement implements java.sql.Statement {
protected JDBCConnection conn;
protected JDBCResultSet rs;
protected int updcnt;
protected int maxrows = 0;
private ArrayList<String> batch;
public JDBCStatement(JDBCConnection conn) {
this.conn = conn;
this.updcnt = 0;
this.rs = null;
this.batch = null;
}
public void setFetchSize(int fetchSize) throws SQLException {
if (fetchSize != 1) {
throw new SQLException("fetch size not 1");
}
}
public int getFetchSize() throws SQLException {
return 1;
}
public int getMaxRows() throws SQLException {
return maxrows;
}
public void setMaxRows(int max) throws SQLException {
if (max < 0) {
throw new SQLException("max must be >= 0 (was " + max + ")");
}
maxrows = max;
}
public void setFetchDirection(int fetchDirection) throws SQLException {
throw new SQLException("not supported");
}
public int getFetchDirection() throws SQLException {
return ResultSet.FETCH_UNKNOWN;
}
public int getResultSetConcurrency() throws SQLException {
return ResultSet.CONCUR_READ_ONLY;
}
public int getResultSetType() throws SQLException {
return ResultSet.TYPE_SCROLL_INSENSITIVE;
}
public void setQueryTimeout(int seconds) throws SQLException {
// BEGIN android-changed: more closely follow specification:
// "[throws SQLException if] this method is called on a closed Statement or the condition
// seconds >= 0 is not satisfied"
// (http://java.sun.com/javase/6/docs/api/java/sql/Statement.html#setQueryTimeout(int))
if (isClosed()) {
throw new SQLException("can't set a query timeout on a closed statement");
} else if (seconds < 0) {
throw new SQLException("can't set a query timeout of less than 0 seconds");
} else if (seconds == 0) {
// An argument of 0 seconds should set an unlimited timeout. However, since this was not
// done previously, I assume it isn't implemented and use the same implementation.
conn.timeout = 5000;
} else {
conn.timeout = seconds * 1000;
}
// END android-changed
}
public int getQueryTimeout() throws SQLException {
return conn.timeout / 1000; // android-changed: should return seconds
}
public ResultSet getResultSet() throws SQLException {
return rs;
}
ResultSet executeQuery(String sql, String args[], boolean updonly)
throws SQLException {
SQLite.TableResult tr = null;
if (rs != null) {
rs.close();
rs = null;
}
updcnt = -1;
if (conn == null || conn.db == null) {
throw new SQLException("stale connection");
}
int busy = 0;
boolean starttrans = !conn.autocommit && !conn.intrans;
while (true) {
try {
if (starttrans) {
conn.db.exec("BEGIN TRANSACTION", null);
conn.intrans = true;
}
if (args == null) {
if (updonly) {
conn.db.exec(sql, null);
} else {
tr = conn.db.get_table(sql, maxrows);
}
} else {
if (updonly) {
conn.db.exec(sql, null, args);
} else {
tr = conn.db.get_table(sql, maxrows, args);
}
}
updcnt = (int) conn.db.changes();
} catch (SQLite.Exception e) {
if (conn.db.is3() &&
conn.db.last_error() == SQLite.Constants.SQLITE_BUSY &&
conn.busy3(conn.db, ++busy)) {
try {
if (starttrans && conn.intrans) {
conn.db.exec("ROLLBACK", null);
conn.intrans = false;
}
} catch (SQLite.Exception ee) {
}
try {
int ms = 20 + busy * 10;
if (ms > 1000) {
ms = 1000;
}
synchronized (this) {
this.wait(ms);
}
} catch (java.lang.Exception eee) {
}
continue;
}
throw new SQLException(e.toString());
}
break;
}
if (!updonly && tr == null) {
throw new SQLException("no result set produced");
}
if (!updonly && tr != null) {
rs = new JDBCResultSet(new TableResultX(tr), this);
}
return rs;
}
public ResultSet executeQuery(String sql) throws SQLException {
return executeQuery(sql, null, false);
}
public boolean execute(String sql) throws SQLException {
return executeQuery(sql) != null;
}
public void cancel() throws SQLException {
if (conn == null || conn.db == null) {
throw new SQLException("stale connection");
}
conn.db.interrupt();
}
public void clearWarnings() throws SQLException {
}
public Connection getConnection() throws SQLException {
return conn;
}
public void addBatch(String sql) throws SQLException {
if (batch == null) {
batch = new ArrayList<String>(1);
}
batch.add(sql);
}
public int[] executeBatch() throws SQLException {
if (batch == null) {
return new int[0];
}
int[] ret = new int[batch.size()];
for (int i = 0; i < ret.length; i++) {
ret[i] = EXECUTE_FAILED;
}
int errs = 0;
for (int i = 0; i < ret.length; i++) {
try {
execute((String) batch.get(i));
ret[i] = updcnt;
} catch (SQLException e) {
++errs;
}
}
if (errs > 0) {
throw new BatchUpdateException("batch failed", ret);
}
return ret;
}
public void clearBatch() throws SQLException {
if (batch != null) {
batch.clear();
batch = null;
}
}
public void close() throws SQLException {
clearBatch();
conn = null;
}
public int executeUpdate(String sql) throws SQLException {
executeQuery(sql, null, true);
return updcnt;
}
public int getMaxFieldSize() throws SQLException {
return 0;
}
public boolean getMoreResults() throws SQLException {
if (rs != null) {
rs.close();
rs = null;
}
return false;
}
public int getUpdateCount() throws SQLException {
return updcnt;
}
public SQLWarning getWarnings() throws SQLException {
return null;
}
public void setCursorName(String name) throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public void setEscapeProcessing(boolean enable) throws SQLException {
throw new SQLException("not supported");
}
public void setMaxFieldSize(int max) throws SQLException {
throw new SQLException("not supported");
}
public boolean getMoreResults(int x) throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public ResultSet getGeneratedKeys() throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public int executeUpdate(String sql, int autokeys)
throws SQLException {
if (autokeys != Statement.NO_GENERATED_KEYS) {
throw new SQLFeatureNotSupportedException("generated keys not supported");
}
return executeUpdate(sql);
}
public int executeUpdate(String sql, int colIndexes[])
throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public int executeUpdate(String sql, String colIndexes[])
throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public boolean execute(String sql, int autokeys)
throws SQLException {
if (autokeys != Statement.NO_GENERATED_KEYS) {
throw new SQLFeatureNotSupportedException("autogenerated keys not supported");
}
return execute(sql);
}
public boolean execute(String sql, int colIndexes[])
throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public boolean execute(String sql, String colIndexes[])
throws SQLException {
throw new SQLFeatureNotSupportedException();
}
public int getResultSetHoldability() throws SQLException {
return ResultSet.HOLD_CURSORS_OVER_COMMIT;
}
public boolean isClosed() throws SQLException {
return conn == null; // android-changed: pretty sure this is correct, since it matches what's done in close()
}
public void setPoolable(boolean yes) throws SQLException {
if (yes) {
throw new SQLException("poolable statements not supported");
}
}
public boolean isPoolable() throws SQLException {
return false;
}
public <T> T unwrap(java.lang.Class<T> iface) throws SQLException {
throw new SQLException("unsupported");
}
public boolean isWrapperFor(java.lang.Class iface) throws SQLException {
return false;
}
}