private void fetchExecutionResult(
@NotNull DBCSession session, @NotNull DBDDataReceiver dataReceiver, @NotNull SQLQuery query)
throws DBCException {
// Fetch fake result set
// DBCStatement statsStatement;
StatResultSet fakeResultSet = new StatResultSet(session, curStatement);
SQLQueryResult resultInfo = new SQLQueryResult(query);
if (statistics.getStatementsCount() > 1) {
// Multiple statements - show script statistics
fakeResultSet.addColumn("Queries", DBPDataKind.NUMERIC);
fakeResultSet.addColumn("Updated Rows", DBPDataKind.NUMERIC);
fakeResultSet.addColumn("Execute time", DBPDataKind.NUMERIC);
fakeResultSet.addColumn("Fetch time", DBPDataKind.NUMERIC);
fakeResultSet.addColumn("Total time", DBPDataKind.NUMERIC);
fakeResultSet.addRow(
statistics.getStatementsCount(),
statistics.getRowsUpdated(),
statistics.getExecuteTime(),
statistics.getFetchTime(),
statistics.getTotalTime());
resultInfo.setResultSetName("Statistics");
} else {
// Single statement
long updateCount = statistics.getRowsUpdated();
if (updateCount >= 0) {
fakeResultSet.addColumn("Query", DBPDataKind.STRING);
fakeResultSet.addColumn("Updated Rows", DBPDataKind.NUMERIC);
fakeResultSet.addRow(query.getQuery(), updateCount);
} else {
fakeResultSet.addColumn("Result", DBPDataKind.NUMERIC);
}
resultInfo.setResultSetName("Result");
}
fetchQueryData(session, fakeResultSet, resultInfo, dataReceiver, false);
}
private void showExecutionResult(DBCSession session) throws DBCException {
if (statistics.getStatementsCount() > 1 || resultSetNumber == 0) {
SQLQuery query = new SQLQuery("", -1, -1);
if (queries.size() == 1) {
query.setQuery(queries.get(0).getQuery());
}
query.setData(STATS_RESULTS); // It will set tab name to "Stats"
DBDDataReceiver dataReceiver = resultsConsumer.getDataReceiver(query, resultSetNumber);
if (dataReceiver != null) {
fetchExecutionResult(session, dataReceiver, query);
}
}
}
private boolean fetchQueryData(
DBCSession session,
DBCResultSet resultSet,
SQLQueryResult result,
DBDDataReceiver dataReceiver,
boolean updateStatistics)
throws DBCException {
if (dataReceiver == null) {
// No data pump - skip fetching stage
return false;
}
if (resultSet == null) {
return false;
}
boolean keepCursor = keepStatementOpen();
if (keepCursor) {
curResultSets.add(resultSet);
}
DBRProgressMonitor monitor = session.getProgressMonitor();
monitor.subTask("Fetch result set");
long rowCount = 0;
dataReceiver.fetchStart(session, resultSet, rsOffset, rsMaxRows);
try {
// Retrieve source entity
if (result != null) {
DBCResultSetMetaData rsMeta = resultSet.getMeta();
String sourceName = null; // resultSet.getResultSetName();
for (DBCAttributeMetaData attr : rsMeta.getAttributes()) {
String entityName = attr.getEntityName();
if (!CommonUtils.isEmpty(entityName)) {
if (sourceName == null) {
sourceName = entityName;
} else if (!sourceName.equals(entityName)) {
// Multiple source entities
sourceName += "(+)";
break;
}
}
}
/*
if (CommonUtils.isEmpty(sourceName)) {
try {
sourceName = resultSet.getResultSetName();
} catch (DBCException e) {
log.debug(e);
}
}
*/
if (CommonUtils.isEmpty(sourceName)) {
sourceName = "Result";
}
result.setResultSetName(sourceName);
}
long fetchStartTime = System.currentTimeMillis();
// Fetch all rows
while ((!hasLimits() || rowCount < rsMaxRows) && resultSet.nextRow()) {
if (monitor.isCanceled()) {
break;
}
rowCount++;
if (rowCount > 0 && rowCount % 100 == 0) {
monitor.subTask(rowCount + " rows fetched");
monitor.worked(100);
}
dataReceiver.fetchRow(session, resultSet);
}
if (updateStatistics) {
statistics.addFetchTime(System.currentTimeMillis() - fetchStartTime);
}
} finally {
if (!keepCursor) {
try {
resultSet.close();
} catch (Throwable e) {
log.error("Error while closing resultset", e);
}
}
try {
dataReceiver.fetchEnd(session, resultSet);
} catch (Throwable e) {
log.error("Error while handling end of result set fetch", e);
}
dataReceiver.close();
}
if (result != null) {
result.setRowCount(rowCount);
}
if (updateStatistics) {
statistics.setRowsFetched(rowCount);
}
monitor.subTask(rowCount + " rows fetched");
return true;
}
private boolean executeSingleQuery(
@NotNull DBCSession session, @NotNull SQLQuery sqlQuery, boolean fireEvents) {
lastError = null;
final String originalQueryText = sqlQuery.getQuery();
DBCExecutionContext executionContext = getExecutionContext();
SQLQueryResult curResult = new SQLQueryResult(sqlQuery);
if (rsOffset > 0) {
curResult.setRowOffset(rsOffset);
}
SQLQuery originalQuery = sqlQuery;
long startTime = System.currentTimeMillis();
if (fireEvents && listener != null) {
// Notify query start
listener.onStartQuery(sqlQuery);
}
try {
// Prepare statement
closeStatement();
// Check and invalidate connection
DBPDataSource dataSource = executionContext.getDataSource();
if (!connectionInvalidated
&& dataSource
.getContainer()
.getPreferenceStore()
.getBoolean(DBeaverPreferences.STATEMENT_INVALIDATE_BEFORE_EXECUTE)) {
executionContext.invalidateContext(session.getProgressMonitor());
connectionInvalidated = true;
}
try {
// Modify query (filters + parameters)
if (dataFilter != null && dataFilter.hasFilters() && dataSource instanceof SQLDataSource) {
String filteredQueryText =
((SQLDataSource) dataSource)
.getSQLDialect()
.addFiltersToQuery(dataSource, originalQueryText, dataFilter);
sqlQuery = new SQLQuery(filteredQueryText, sqlQuery.getOffset(), sqlQuery.getLength());
}
} catch (DBException e) {
throw new DBCException("Can't apply query filter", e);
}
Boolean hasParameters = prepareStatementParameters(sqlQuery);
if (hasParameters == null) {
return false;
}
statistics.setQueryText(originalQueryText);
startTime = System.currentTimeMillis();
DBCExecutionSource source =
new AbstractExecutionSource(
dataContainer, executionContext, partSite.getPart(), sqlQuery);
curStatement =
DBUtils.prepareStatement(
source,
session,
hasParameters ? DBCStatementType.QUERY : DBCStatementType.SCRIPT,
sqlQuery,
rsOffset,
rsMaxRows);
if (hasParameters) {
bindStatementParameters(session, sqlQuery);
}
// Execute statement
try {
boolean hasResultSet = curStatement.executeStatement();
curResult.setHasResultSet(hasResultSet);
statistics.addExecuteTime(System.currentTimeMillis() - startTime);
statistics.addStatementsCount();
long updateCount = -1;
while (hasResultSet || resultSetNumber == 0 || updateCount >= 0) {
// Fetch data only if we have to fetch all results or if it is rs requested
if (fetchResultSetNumber < 0 || fetchResultSetNumber == resultSetNumber) {
if (hasResultSet && fetchResultSets) {
DBDDataReceiver dataReceiver =
resultsConsumer.getDataReceiver(sqlQuery, resultSetNumber);
if (dataReceiver != null) {
hasResultSet =
fetchQueryData(
session, curStatement.openResultSet(), curResult, dataReceiver, true);
}
}
}
if (!hasResultSet) {
try {
updateCount = curStatement.getUpdateRowCount();
if (updateCount >= 0) {
curResult.setUpdateCount(updateCount);
statistics.addRowsUpdated(updateCount);
}
} catch (DBCException e) {
// In some cases we can't read update count
// This is bad but we can live with it
// Just print a warning
log.warn("Can't obtain update count", e);
}
}
if (hasResultSet && fetchResultSets) {
resultSetNumber++;
fetchResultSetNumber = resultSetNumber;
}
if (!hasResultSet && updateCount < 0) {
// Nothing else to fetch
break;
}
if (dataSource.getInfo().supportsMultipleResults()) {
hasResultSet = curStatement.nextResults();
updateCount = hasResultSet ? -1 : 0;
} else {
break;
}
}
try {
curResult.setWarnings(curStatement.getStatementWarnings());
} catch (Throwable e) {
log.warn("Can't read execution warnings", e);
}
} finally {
// monitor.subTask("Close query");
if (!keepStatementOpen()) {
closeStatement();
}
// Release parameters
releaseStatementParameters(sqlQuery);
}
} catch (Throwable ex) {
if (!(ex instanceof DBException)) {
log.error("Unexpected error while processing SQL", ex);
}
curResult.setError(ex);
lastError = ex;
} finally {
curResult.setQueryTime(System.currentTimeMillis() - startTime);
if (fireEvents && listener != null) {
// Notify query end
listener.onEndQuery(curResult);
}
}
if (curResult.getError() != null && errorHandling != SQLScriptErrorHandling.IGNORE) {
return false;
}
// Success
lastGoodQuery = originalQuery;
return true;
}