// The prepared statement and the activation may already be available
// if the trigger has been fired before in the same statement. (Only
// happens with row triggers that are triggered by a statement that
// touched multiple rows.) The WHEN clause and the trigger action have
// their own prepared statement and activation. Fetch the correct set.
ExecPreparedStatement ps = isWhen ? whenPS : actionPS;
Activation spsActivation = isWhen
? spsWhenActivation : spsActionActivation;
while (true) {
/*
** Only grab the ps the 1st time through. This
** way a row trigger doesn't do any unnecessary
** setup work.
*/
if (ps == null || recompile)
{
// The SPS activation will set its parent activation from
// the statement context. Reset it to the original parent
// activation first so that it doesn't use the activation of
// the previously executed SPS as parent. DERBY-6348.
lcc.getStatementContext().setActivation(activation);
/*
** We need to clone the prepared statement so we don't
** wind up marking that ps that is tied to sps as finished
** during the course of execution.
*/
ps = sps.getPreparedStatement();
ps = ps.getClone();
// it should be valid since we've just prepared for it
ps.setValid();
spsActivation = ps.getActivation(lcc, false);
/*
** Normally, we want getSource() for an sps invocation
** to be EXEC STATEMENT xxx, but in this case, since
** we are executing the SPS in our own fashion, we want
** the text to be the trigger action. So set it accordingly.
*/
ps.setSource(sps.getText());
ps.setSPSAction();
// Cache the prepared statement and activation in case the
// trigger fires multiple times.
if (isWhen) {
whenPS = ps;
spsWhenActivation = spsActivation;
} else {
actionPS = ps;
spsActionActivation = spsActivation;
}
}
// save the active statement context for exception handling purpose
StatementContext active_sc = lcc.getStatementContext();
/*
** Execute the activation. If we have an error, we
** are going to go to some extra work to pop off
** our statement context. This is because we are
** a nested statement (we have 2 activations), but
** we aren't a nested connection, so we have to
** pop off our statementcontext to get error handling
** to work correctly. This is normally a no-no, but
** we are an unusual case.
*/
try
{
// This is a substatement; for now, we do not set any timeout
// for it. We might change this behaviour later, by linking
// timeout to its parent statement's timeout settings.
ResultSet rs = ps.executeSubStatement
(activation, spsActivation, false, 0L);
if (isWhen)
{
// This is a WHEN clause. Expect a single BOOLEAN value