/**
* @see CallableStatement#registerOutParameter
* @exception SQLException NoOutputParameters thrown.
*/
public final void registerOutParameter(int parameterIndex, int sqlType) throws SQLException {
checkStatus();
try {
getParms().registerOutParameter(parameterIndex - 1, sqlType, -1);
} catch (StandardException e) {
throw EmbedResultSet.noStateChangeException(e);
}
}
public void setRowId(int parameterIndex, RowId x) throws SQLException {
checkStatus();
try {
/* JDBC is one-based, DBMS is zero-based */
getParms().getParameterForSet(parameterIndex - 1).setValue(x);
} catch (Throwable t) {
throw EmbedResultSet.noStateChangeException(t);
}
}
/**
* @see CallableStatement#getTimestamp
* @exception SQLException NoOutputParameters thrown.
*/
public Timestamp getTimestamp(int parameterIndex, Calendar cal) throws SQLException {
checkStatus();
try {
Timestamp v = getParms().getParameterForGet(parameterIndex - 1).getTimestamp(cal);
wasNull = (v == null);
return v;
} catch (StandardException e) {
throw EmbedResultSet.noStateChangeException(e);
}
}
/**
* @see CallableStatement#getBytes
* @exception SQLException NoOutputParameters thrown.
*/
public byte[] getBytes(int parameterIndex) throws SQLException {
checkStatus();
try {
byte[] v = getParms().getParameterForGet(parameterIndex - 1).getBytes();
wasNull = (v == null);
return v;
} catch (StandardException e) {
throw EmbedResultSet.noStateChangeException(e);
}
}
/**
* @see CallableStatement#getDouble
* @exception SQLException NoOutputParameters thrown.
*/
public double getDouble(int parameterIndex) throws SQLException {
checkStatus();
try {
DataValueDescriptor param = getParms().getParameterForGet(parameterIndex - 1);
double v = param.getDouble();
wasNull = (v == 0.0) && param.isNull();
return v;
} catch (StandardException e) {
throw EmbedResultSet.noStateChangeException(e);
}
}
/**
* @see CallableStatement#getShort
* @exception SQLException NoOutputParameters thrown.
*/
public short getShort(int parameterIndex) throws SQLException {
checkStatus();
try {
DataValueDescriptor param = getParms().getParameterForGet(parameterIndex - 1);
short s = param.getShort();
wasNull = (s == 0) && param.isNull();
return s;
} catch (StandardException e) {
throw EmbedResultSet.noStateChangeException(e);
}
}
/**
* @see CallableStatement#registerOutParameter
* @exception SQLException NoOutputParameters thrown.
*/
public final void registerOutParameter(int parameterIndex, int sqlType, int scale)
throws SQLException {
checkStatus();
if (scale < 0) throw newSQLException(SQLState.BAD_SCALE_VALUE, new Integer(scale));
try {
getParms().registerOutParameter(parameterIndex - 1, sqlType, scale);
} catch (StandardException e) {
throw EmbedResultSet.noStateChangeException(e);
}
}
/**
* JDBC 2.0
*
* <p>Get the value of a NUMERIC parameter as a java.math.BigDecimal object.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @return the parameter value (full precision); if the value is SQL NULL, the result is null
* @exception SQLException if a database-access error occurs.
*/
public final BigDecimal getBigDecimal(int parameterIndex) throws SQLException {
checkStatus();
try {
DataValueDescriptor dvd = getParms().getParameterForGet(parameterIndex - 1);
if (wasNull = dvd.isNull()) return null;
return org.apache.derby.iapi.types.SQLDecimal.getBigDecimal(dvd);
} catch (StandardException e) {
throw EmbedResultSet.noStateChangeException(e);
}
}
protected final boolean executeStatement(
Activation a, boolean executeQuery, boolean executeUpdate) throws SQLException {
// need this additional check (it's also in the super.executeStatement
// to ensure we have an activation for the getParams
checkExecStatus();
synchronized (getConnectionSynchronization()) {
wasNull = false;
// Don't fetch the getParms into a local varibale
// at this point because it is possible that the activation
// associated with this callable statement may have become
// stale. If the current activation is invalid, a new activation
// will be created for it in executeStatement call below.
// We should be using the ParameterValueSet associated with
// the activation associated to the CallableStatement after
// the executeStatement below. That ParameterValueSet is the
// right object to hold the return value from the CallableStatement.
try {
getParms().validate();
} catch (StandardException e) {
throw EmbedResultSet.noStateChangeException(e);
}
/* KLUDGE - ? = CALL ... returns a ResultSet(). We
* need executeUpdate to be false in that case.
*/
boolean execResult =
super.executeStatement(a, executeQuery, (executeUpdate && (!hasReturnOutputParameter)));
// Fetch the getParms into a local variable now because the
// activation associated with a CallableStatement at this
// point(after the executStatement) is the current activation.
// We can now safely stuff the return value of the
// CallableStatement into the following ParameterValueSet object.
ParameterValueSet pvs = getParms();
/*
** If we have a return parameter, then we
** consume it from the returned ResultSet
** reset the ResultSet set to null.
*/
if (hasReturnOutputParameter) {
if (SanityManager.DEBUG) {
SanityManager.ASSERT(
results != null,
"null results even though we are supposed to have a return parameter");
}
boolean gotRow = results.next();
if (SanityManager.DEBUG) {
SanityManager.ASSERT(gotRow, "the return resultSet didn't have any rows");
}
try {
DataValueDescriptor returnValue = pvs.getReturnValueForSet();
returnValue.setValueFromResultSet(results, 1, true);
} catch (StandardException e) {
throw EmbedResultSet.noStateChangeException(e);
} finally {
results.close();
results = null;
}
// This is a form of ? = CALL which current is not a procedure call.
// Thus there cannot be any user result sets, so return false. execResult
// is set to true since a result set was returned, for the return parameter.
execResult = false;
}
return execResult;
}
}