/**
* @see org.apache.derby.iapi.sql.ResultSet#cleanUp
* @exception StandardException Thrown on error
*/
public void cleanUp() throws StandardException {
if (rowHolder != null) {
rowHolder.close();
}
if (rs != null) {
try {
rs.close();
} catch (Throwable t) {
throw StandardException.unexpectedUserException(t);
}
rs = null;
}
// Close the ps if it needs to be instantiated on each execution
if (!vtiRS.isReuseablePs() && ps != null) {
try {
ps.close();
ps = null;
} catch (Throwable t) {
throw StandardException.unexpectedUserException(t);
}
}
super.cleanUp();
} // end of cleanUp
public void finish() throws StandardException {
if ((ps != null) && !vtiRS.isReuseablePs()) {
try {
ps.close();
ps = null;
} catch (Throwable t) {
throw StandardException.unexpectedUserException(t);
}
}
super.finish();
} // end of finish
/** @exception StandardException Standard Derby error policy */
protected void openCore() throws StandardException {
/* We must instantiate the VTI on each execution if any of the
* parameters contain a ?.
*/
if (ps == null) {
ps = (PreparedStatement) vtiRS.getVTIConstructor().invoke(activation);
}
if (ps instanceof DeferModification) {
try {
((DeferModification) ps)
.modificationNotify(DeferModification.INSERT_STATEMENT, constants.deferred);
} catch (Throwable t) {
throw StandardException.unexpectedUserException(t);
}
}
ExecRow row = getNextRowCore(sourceResultSet);
try {
rs = ps.executeQuery();
} catch (Throwable t) {
throw StandardException.unexpectedUserException(t);
}
/* Get or re-use the row changer.
* NOTE: We need to set ourself as the top result set
* if this is not the 1st execution. (Done in constructor
* for 1st execution.)
*/
if (!firstExecute) {
lcc.getStatementContext().setTopResultSet(this, subqueryTrackingArray);
}
/* The source does not know whether or not we are doing a
* deferred mode insert. If we are, then we must clear the
* index scan info from the activation so that the row changer
* does not re-use that information (which won't be valid for
* a deferred mode insert).
*/
if (constants.deferred) {
activation.clearIndexScanInfo();
}
if (firstExecute && constants.deferred) {
Properties properties = new Properties();
/*
** If deferred we save a copy of the entire row.
*/
rowHolder = new TemporaryRowHolderImpl(activation, properties);
}
while (row != null) {
/*
** If we're doing a deferred insert, insert into the temporary
** conglomerate. Otherwise, insert directly into the permanent
** conglomerates using the rowChanger.
*/
if (constants.deferred) {
rowHolder.insert(row);
} else {
insertIntoVTI(rs, row);
}
rowCount++;
// No need to do a next on a single row source
if (constants.singleRowSource) {
row = null;
} else {
row = getNextRowCore(sourceResultSet);
}
}
/*
** If it's a deferred insert, scan the temporary conglomerate and
** insert the rows into the permanent conglomerates using rowChanger.
*/
if (constants.deferred) {
CursorResultSet tempRS = rowHolder.getResultSet();
try {
tempRS.open();
while ((row = tempRS.getNextRow()) != null) {
insertIntoVTI(rs, row);
}
} finally {
sourceResultSet.clearCurrentRow();
tempRS.close();
}
}
if (rowHolder != null) {
rowHolder.close();
// rowHolder kept across opens
}
} // end of normalInsertCore
