private void setAutoCommitSend(boolean autoCommit) {
if (clientVersion >= Constants.TCP_PROTOCOL_VERSION_8) {
for (int i = 0, count = 0; i < transferList.size(); i++) {
Transfer transfer = transferList.get(i);
try {
traceOperation("SESSION_SET_AUTOCOMMIT", autoCommit ? 1 : 0);
transfer.writeInt(SessionRemote.SESSION_SET_AUTOCOMMIT).writeBoolean(autoCommit);
done(transfer);
} catch (IOException e) {
removeServer(e, i--, ++count);
}
}
} else {
if (autoCommit) {
if (autoCommitTrue == null) {
autoCommitTrue = prepareCommand("SET AUTOCOMMIT TRUE", Integer.MAX_VALUE);
}
autoCommitTrue.executeUpdate();
} else {
if (autoCommitFalse == null) {
autoCommitFalse = prepareCommand("SET AUTOCOMMIT FALSE", Integer.MAX_VALUE);
}
autoCommitFalse.executeUpdate();
}
}
}
/**
* Executes a query (select statement) and returns the result set. If another result set exists
* for this statement, this will be closed (even if this statement fails).
*
* @param sql the SQL statement to execute
* @return the result set
*/
public ResultSet executeQuery(String sql) throws SQLException {
try {
int id = getNextId(TraceObject.RESULT_SET);
if (isDebugEnabled()) {
debugCodeAssign(
"ResultSet", TraceObject.RESULT_SET, id, "executeQuery(" + quote(sql) + ")");
}
checkClosed();
closeOldResultSet();
sql = conn.translateSQL(sql, escapeProcessing);
synchronized (session) {
CommandInterface command = conn.prepareCommand(sql, fetchSize);
ResultInterface result;
boolean scrollable = resultSetType != ResultSet.TYPE_FORWARD_ONLY;
boolean updatable = resultSetConcurrency == ResultSet.CONCUR_UPDATABLE;
setExecutingStatement(command);
try {
result = command.executeQuery(maxRows, scrollable);
} finally {
setExecutingStatement(null);
}
command.close();
resultSet =
new JdbcResultSet(conn, this, result, id, closedByResultSet, scrollable, updatable);
}
return resultSet;
} catch (Exception e) {
throw logAndConvert(e);
}
}
/**
* Changes the current transaction isolation level. Calling this method will commit an open
* transaction, even if the new level is the same as the old one, except if the level is not
* supported. Internally, this method calls SET LOCK_MODE. The following isolation levels are
* supported:
*
* <ul>
* <li>Connection.TRANSACTION_READ_UNCOMMITTED = SET LOCK_MODE 0: no locking (should only be
* used for testing).
* <li>Connection.TRANSACTION_SERIALIZABLE = SET LOCK_MODE 1: table level locking.
* <li>Connection.TRANSACTION_READ_COMMITTED = SET LOCK_MODE 3: table level locking, but read
* locks are released immediately (default).
* </ul>
*
* This setting is not persistent. Please note that using TRANSACTION_READ_UNCOMMITTED while at
* the same time using multiple connections may result in inconsistent transactions.
*
* @param level the new transaction isolation level: Connection.TRANSACTION_READ_UNCOMMITTED,
* Connection.TRANSACTION_READ_COMMITTED, or Connection.TRANSACTION_SERIALIZABLE
* @throws SQLException if the connection is closed or the isolation level is not supported
*/
public void setTransactionIsolation(int level) throws SQLException {
try {
debugCodeCall("setTransactionIsolation", level);
checkClosed();
int lockMode;
switch (level) {
case Connection.TRANSACTION_READ_UNCOMMITTED:
lockMode = Constants.LOCK_MODE_OFF;
break;
case Connection.TRANSACTION_READ_COMMITTED:
lockMode = Constants.LOCK_MODE_READ_COMMITTED;
break;
case Connection.TRANSACTION_REPEATABLE_READ:
case Connection.TRANSACTION_SERIALIZABLE:
lockMode = Constants.LOCK_MODE_TABLE;
break;
default:
throw DbException.getInvalidValueException("" + level, "level");
}
commit();
setLockMode = prepareCommand("SET LOCK_MODE ?", setLockMode);
setLockMode.getParameters().get(0).setValue(ValueInt.get(lockMode), false);
setLockMode.executeUpdate();
} catch (Exception e) {
throw logAndConvert(e);
}
}
/**
* Executes an arbitrary statement. If another result set exists for this statement, this will be
* closed (even if this statement fails).
*
* <p>If the statement is a create or drop and does not throw an exception, the current
* transaction (if any) is committed after executing the statement. If auto commit is on, and the
* statement is not a select, this statement will be committed.
*
* @param sql the SQL statement to execute
* @return true if a result set is available, false if not
*/
public boolean execute(String sql) throws SQLException {
try {
int id = getNextId(TraceObject.RESULT_SET);
if (isDebugEnabled()) {
debugCodeCall("execute", sql);
}
checkClosedForWrite();
closeOldResultSet();
sql = conn.translateSQL(sql, escapeProcessing);
CommandInterface command = conn.prepareCommand(sql, fetchSize);
boolean returnsResultSet;
synchronized (session) {
setExecutingStatement(command);
try {
if (command.isQuery()) {
returnsResultSet = true;
boolean scrollable = resultSetType != ResultSet.TYPE_FORWARD_ONLY;
boolean updatable = resultSetConcurrency == ResultSet.CONCUR_UPDATABLE;
ResultInterface result = command.executeQuery(maxRows, scrollable);
resultSet =
new JdbcResultSet(conn, this, result, id, closedByResultSet, scrollable, updatable);
} else {
returnsResultSet = false;
updateCount = command.executeUpdate();
}
} finally {
setExecutingStatement(null);
}
}
command.close();
return returnsResultSet;
} catch (Exception e) {
throw logAndConvert(e);
}
}
/** INTERNAL */
public void setQueryTimeout(int seconds) throws SQLException {
try {
debugCodeCall("setQueryTimeout", seconds);
checkClosed();
setQueryTimeout = prepareCommand("SET QUERY_TIMEOUT ?", setQueryTimeout);
setQueryTimeout.getParameters().get(0).setValue(ValueInt.get(seconds * 1000), false);
setQueryTimeout.executeUpdate();
} catch (Exception e) {
throw logAndConvert(e);
}
}
private void checkClusterDisableAutoCommit(String serverList) {
if (autoCommit && transferList.size() > 1) {
setAutoCommitSend(false);
CommandInterface c = prepareCommand("SET CLUSTER " + serverList, Integer.MAX_VALUE);
// this will set autoCommit to false
c.executeUpdate();
// so we need to switch it on
autoCommit = true;
cluster = true;
}
}
@Override
public String format(PreparedStatement stmt) {
try {
if (stmt instanceof JdbcPreparedStatement) {
String sql = (String) ReflectUtil.getValue(SQL_FIELD, stmt);
boolean insert = false;
if (sql.toUpperCase().startsWith("INSERT INTO")) {
int pos = sql.indexOf("(");
sql = sql.substring(0, pos) + "SET " + sql.substring(pos + 1);
sql = sql.substring(0, sql.indexOf(" VALUES"));
insert = true;
}
CommandInterface command = (CommandInterface) ReflectUtil.getValue(COMMAND_FIELD, stmt);
ObjectArray<? extends ParameterInterface> parameters = command.getParameters();
int pos = 0;
for (int i = 0; i < parameters.size(); i++) {
ParameterInterface parameter = parameters.get(i);
Value value = parameter.getParamValue();
if (insert) {
String string = "=" + value;
pos = sql.indexOf(',', pos);
if (pos == -1) {
pos = sql.indexOf(')');
sql = sql.substring(0, pos) + string;
break;
}
sql = sql.substring(0, pos) + string + sql.substring(pos);
pos += string.length() + 1;
} else {
pos = sql.indexOf('?');
sql = sql.substring(0, pos) + value + sql.substring(pos + 1);
}
}
return sql;
}
} catch (Throwable t) {
// $FALL-THROUGH$
}
return super.format(stmt);
}
/**
* Returns the current transaction isolation level.
*
* @return the isolation level.
* @throws SQLException if the connection is closed
*/
public int getTransactionIsolation() throws SQLException {
try {
debugCodeCall("getTransactionIsolation");
checkClosed();
getLockMode = prepareCommand("CALL LOCK_MODE()", getLockMode);
ResultInterface result = getLockMode.executeQuery(0, false);
result.next();
int lockMode = result.currentRow()[0].getInt();
result.close();
int transactionIsolationLevel;
switch (lockMode) {
case Constants.LOCK_MODE_OFF:
transactionIsolationLevel = Connection.TRANSACTION_READ_UNCOMMITTED;
break;
case Constants.LOCK_MODE_READ_COMMITTED:
transactionIsolationLevel = Connection.TRANSACTION_READ_COMMITTED;
break;
case Constants.LOCK_MODE_TABLE:
case Constants.LOCK_MODE_TABLE_GC:
transactionIsolationLevel = Connection.TRANSACTION_SERIALIZABLE;
break;
default:
throw DbException.throwInternalError("lockMode:" + lockMode);
}
return transactionIsolationLevel;
} catch (Exception e) {
throw logAndConvert(e);
}
}
/**
* Gets the current catalog name.
*
* @return the catalog name
* @throws SQLException if the connection is closed
*/
public String getCatalog() throws SQLException {
try {
debugCodeCall("getCatalog");
checkClosed();
if (catalog == null) {
CommandInterface cat = prepareCommand("CALL DATABASE()", Integer.MAX_VALUE);
ResultInterface result = cat.executeQuery(0, false);
result.next();
catalog = result.currentRow()[0].getString();
cat.close();
}
return catalog;
} catch (Exception e) {
throw logAndConvert(e);
}
}
/**
* Switches auto commit on or off. Calling this function does not commit the current transaction.
*
* @param autoCommit true for auto commit on, false for off
* @throws SQLException if the connection is closed
*/
public synchronized void setAutoCommit(boolean autoCommit) throws SQLException {
try {
if (isDebugEnabled()) {
debugCode("setAutoCommit(" + autoCommit + ");");
}
checkClosed();
if (autoCommit) {
setAutoCommitTrue = prepareCommand("SET AUTOCOMMIT TRUE", setAutoCommitTrue);
setAutoCommitTrue.executeUpdate();
} else {
setAutoCommitFalse = prepareCommand("SET AUTOCOMMIT FALSE", setAutoCommitFalse);
setAutoCommitFalse.executeUpdate();
}
} catch (Exception e) {
throw logAndConvert(e);
}
}
private boolean getInternalAutoCommit() {
getAutoCommit = prepareCommand("CALL AUTOCOMMIT()", getAutoCommit);
ResultInterface result = getAutoCommit.executeQuery(0, false);
result.next();
boolean autoCommit = result.currentRow()[0].getBoolean().booleanValue();
result.close();
return autoCommit;
}
// ## Java 1.4 begin ##
public Savepoint setSavepoint(String name) throws SQLException {
try {
int id = getNextId(TraceObject.SAVEPOINT);
if (isDebugEnabled()) {
debugCodeAssign(
"Savepoint", TraceObject.SAVEPOINT, id, "setSavepoint(" + quote(name) + ")");
}
checkClosed();
CommandInterface set =
prepareCommand("SAVEPOINT " + JdbcSavepoint.getName(name, 0), Integer.MAX_VALUE);
set.executeUpdate();
JdbcSavepoint savepoint = new JdbcSavepoint(this, 0, name, trace, id);
return savepoint;
} catch (Exception e) {
throw logAndConvert(e);
}
}
/**
* Cancels a currently running statement. This method must be called from within another thread
* than the execute method.
*
* @throws SQLException if this object is closed
*/
public void cancel() throws SQLException {
try {
debugCodeCall("cancel");
checkClosed();
// executingCommand can be reset by another thread
CommandInterface c = executingCommand;
try {
if (c != null) {
c.cancel();
}
} finally {
setExecutingStatement(null);
}
} catch (Exception e) {
throw logAndConvert(e);
}
}
/**
* Read the serializer name from the persistent database settings.
*
* @return the serializer
*/
private String readSerializationSettings() {
String javaObjectSerializerFQN = null;
CommandInterface ci =
prepareCommand(
"SELECT VALUE FROM INFORMATION_SCHEMA.SETTINGS "
+ " WHERE NAME='JAVA_OBJECT_SERIALIZER'",
Integer.MAX_VALUE);
try {
ResultInterface result = ci.executeQuery(0, false);
if (result.next()) {
Value[] row = result.currentRow();
javaObjectSerializerFQN = row[0].getString();
}
} finally {
ci.close();
}
return javaObjectSerializerFQN;
}
/**
* INTERNAL. Set the statement that is currently running.
*
* @param c the command
*/
protected void setExecutingStatement(CommandInterface c) {
if (c == null) {
conn.setExecutingStatement(null);
} else {
conn.setExecutingStatement(this);
lastExecutedCommandType = c.getCommandType();
}
executingCommand = c;
}
private int executeUpdateInternal(String sql) throws SQLException {
checkClosedForWrite();
try {
closeOldResultSet();
sql = JdbcConnection.translateSQL(sql, escapeProcessing);
CommandInterface command = conn.prepareCommand(sql, fetchSize);
synchronized (session) {
setExecutingStatement(command);
try {
updateCount = command.executeUpdate();
} finally {
setExecutingStatement(null);
}
}
command.close();
return updateCount;
} finally {
afterWriting();
}
}
/** INTERNAL */
public int getQueryTimeout() throws SQLException {
try {
debugCodeCall("getQueryTimeout");
checkClosed();
getQueryTimeout =
prepareCommand(
"SELECT VALUE FROM INFORMATION_SCHEMA.SETTINGS WHERE NAME=?", getQueryTimeout);
getQueryTimeout.getParameters().get(0).setValue(ValueString.get("QUERY_TIMEOUT"), false);
ResultInterface result = getQueryTimeout.executeQuery(0, false);
result.next();
int queryTimeout = result.currentRow()[0].getInt();
result.close();
if (queryTimeout == 0) {
return 0;
}
// round to the next second, otherwise 999 millis would return 0 seconds
return (queryTimeout + 999) / 1000;
} catch (Exception e) {
throw logAndConvert(e);
}
}
/**
* Executes a statement (insert, update, delete, create, drop) and returns the update count. If
* another result set exists for this statement, this will be closed (even if this statement
* fails).
*
* <p>If the statement is a create or drop and does not throw an exception, the current
* transaction (if any) is committed after executing the statement. If auto commit is on, this
* statement will be committed.
*
* @param sql the SQL statement
* @return the update count (number of row affected by an insert, update or delete, or 0 if no
* rows or the statement was a create, drop, commit or rollback)
* @throws SQLException if a database error occurred or a select statement was executed
*/
public int executeUpdate(String sql) throws SQLException {
try {
debugCodeCall("executeUpdate", sql);
checkClosedForWrite();
closeOldResultSet();
sql = conn.translateSQL(sql, escapeProcessing);
CommandInterface command = conn.prepareCommand(sql, fetchSize);
synchronized (session) {
setExecutingStatement(command);
try {
updateCount = command.executeUpdate();
} finally {
setExecutingStatement(null);
}
}
command.close();
return updateCount;
} catch (Exception e) {
throw logAndConvert(e);
}
}
/**
* Returns true if the database is read-only.
*
* @return if the database is read-only
* @throws SQLException if the connection is closed
*/
public boolean isReadOnly() throws SQLException {
try {
debugCodeCall("isReadOnly");
checkClosed();
getReadOnly = prepareCommand("CALL READONLY()", getReadOnly);
ResultInterface result = getReadOnly.executeQuery(0, false);
result.next();
boolean readOnly = result.currentRow()[0].getBoolean().booleanValue();
return readOnly;
} catch (Exception e) {
throw logAndConvert(e);
}
}
/**
* Commits the current transaction. This call has only an effect if auto commit is switched off.
*
* @throws SQLException if the connection is closed
*/
public synchronized void commit() throws SQLException {
try {
debugCodeCall("commit");
checkClosedForWrite();
try {
commit = prepareCommand("COMMIT", commit);
commit.executeUpdate();
} finally {
afterWriting();
}
} catch (Exception e) {
throw logAndConvert(e);
}
}
JdbcParameterMetaData(Trace trace, JdbcPreparedStatement prep, CommandInterface command, int id) {
setTrace(trace, TraceObject.PARAMETER_META_DATA, id);
this.prep = prep;
this.parameters = command.getParameters();
this.paramCount = parameters.size();
}
private void switchOffCluster() {
CommandInterface ci = prepareCommand("SET CLUSTER ''", Integer.MAX_VALUE);
ci.executeUpdate();
}
private void rollbackInternal() {
rollback = prepareCommand("ROLLBACK", rollback);
rollback.executeUpdate();
}
/** INTERNAL */
ResultSet getGeneratedKeys(JdbcStatement stat, int id) {
getGeneratedKeys = prepareCommand("CALL SCOPE_IDENTITY()", getGeneratedKeys);
ResultInterface result = getGeneratedKeys.executeQuery(0, false);
ResultSet rs = new JdbcResultSet(this, stat, result, id, false, true, false);
return rs;
}
private CommandInterface closeAndSetNull(CommandInterface command) {
if (command != null) {
command.close();
}
return null;
}