/**
* Updates the element info to a change of the file content and sends out appropriate
* notifications.
*
* @param fileEditorInput the input of an text editor
*/
protected void handleElementContentChanged(IEditorInput fileEditorInput) {
FileInfo info = (FileInfo) getElementInfo(fileEditorInput);
if (info == null) {
return;
}
IStorage storage = EditorUtils.getStorageFromInput(fileEditorInput);
if (storage instanceof IFile) {
IFile file = (IFile) storage;
IDocument document = createEmptyDocument();
IStatus status = null;
try {
try {
refreshFile(file);
} catch (CoreException x) {
log.error("handleElementContentChanged", x);
}
setDocumentContent(document, file);
} catch (CoreException x) {
status = x.getStatus();
}
String newContent = document.get();
if (!newContent.equals(info.fDocument.get())) {
// set the new content and fire content related events
fireElementContentAboutToBeReplaced(fileEditorInput);
removeUnchangedElementListeners(fileEditorInput, info);
info.fDocument.removeDocumentListener(info);
info.fDocument.set(newContent);
info.fCanBeSaved = false;
info.modificationStamp = computeModificationStamp(file);
info.fStatus = status;
addUnchangedElementListeners(fileEditorInput, info);
fireElementContentReplaced(fileEditorInput);
} else {
removeUnchangedElementListeners(fileEditorInput, info);
// fires only the dirty state related event
info.fCanBeSaved = false;
info.modificationStamp = computeModificationStamp(file);
info.fStatus = status;
addUnchangedElementListeners(fileEditorInput, info);
fireElementDirtyStateChanged(fileEditorInput, false);
}
}
}
private void renderReport(DBRProgressMonitor monitor, CompareReport report) {
try {
File reportFile;
switch (settings.getOutputType()) {
case BROWSER:
reportFile = File.createTempFile("compare-report", ".html");
break;
default:
{
StringBuilder fileName = new StringBuilder("compare"); // "compare-report.html";
for (DBNDatabaseNode node : report.getNodes()) {
fileName.append("-").append(CommonUtils.escapeIdentifier(node.getName()));
}
fileName.append("-report.html");
reportFile = new File(settings.getOutputFolder(), fileName.toString());
break;
}
}
reportFile.deleteOnExit();
OutputStream outputStream = new FileOutputStream(reportFile);
try {
monitor.beginTask("Render report", report.getReportLines().size());
CompareReportRenderer reportRenderer = new CompareReportRenderer();
reportRenderer.renderReport(monitor, report, getSettings(), outputStream);
monitor.done();
} finally {
ContentUtils.close(outputStream);
}
UIUtils.launchProgram(reportFile.getAbsolutePath());
} catch (IOException e) {
showError(e.getMessage());
log.error(e);
}
}
public static List<ERDEntity> generateEntityList(
final EntityDiagram diagram, Collection<DBPNamedObject> objects) {
final List<DBSObject> roots = new ArrayList<>();
for (DBPNamedObject object : objects) {
if (object instanceof DBSObject) {
roots.add((DBSObject) object);
}
}
final List<ERDEntity> entities = new ArrayList<>();
try {
DBeaverUI.runInProgressService(
new DBRRunnableWithProgress() {
@Override
public void run(DBRProgressMonitor monitor)
throws InvocationTargetException, InterruptedException {
DiagramObjectCollector collector = new DiagramObjectCollector(diagram);
try {
collector.generateDiagramObjects(monitor, roots);
} catch (DBException e) {
throw new InvocationTargetException(e);
}
entities.addAll(collector.getDiagramEntities());
}
});
} catch (InvocationTargetException e) {
log.error(e.getTargetException());
} catch (InterruptedException e) {
// interrupted
}
return entities;
}
private void makeProposalsFromChildren(
DBRProgressMonitor monitor,
DBSObject parent,
@Nullable String startPart,
List<SQLCompletionProposal> proposals) {
if (startPart != null) {
startPart = wordDetector.removeQuotes(startPart).toUpperCase();
int divPos = startPart.lastIndexOf(editor.getSyntaxManager().getStructSeparator());
if (divPos != -1) {
startPart = startPart.substring(divPos + 1);
}
}
try {
Collection<? extends DBSObject> children = null;
if (parent instanceof DBSObjectContainer) {
children = ((DBSObjectContainer) parent).getChildren(monitor);
} else if (parent instanceof DBSEntity) {
children = ((DBSEntity) parent).getAttributes(monitor);
}
if (children != null && !children.isEmpty()) {
for (DBSObject child : children) {
if (startPart != null && !child.getName().toUpperCase().startsWith(startPart)) {
continue;
}
proposals.add(makeProposalsFromObject(monitor, child));
}
}
} catch (DBException e) {
log.error(e);
}
}
PostgreTableBase findTable(DBRProgressMonitor monitor, long schemaId, long tableId)
throws DBException {
PostgreSchema schema = getSchema(monitor, schemaId);
if (schema == null) {
log.error("Catalog " + schemaId + " not found");
return null;
}
return schema.getTable(monitor, tableId);
}
@Override
public List<DB2IndexColumn> getAttributeReferences(DBRProgressMonitor monitor) {
try {
return getContainer().getIndexCache().getChildren(monitor, getContainer(), this);
} catch (DBException e) {
// DF: Don't know what to do with this exception except log it
LOG.error("DBException swallowed during getAttributeReferences", e);
return null;
}
}
private void addNodeSettings(DataTransferNodeDescriptor node) {
if (node == null) {
return;
}
Class<? extends IDataTransferNode> nodeClass = node.getNodeClass();
if (nodeSettings.containsKey(nodeClass)) {
return;
}
try {
nodeSettings.put(nodeClass, new NodeSettings(node));
} catch (DBException e) {
log.error("Can't add node '" + node.getId() + "'", e);
}
}
private void closeStatement() {
if (curStatement != null) {
for (DBCResultSet resultSet : curResultSets) {
resultSet.close();
}
curResultSets.clear();
try {
curStatement.close();
} catch (Throwable e) {
log.error("Error closing statement", e);
}
curStatement = null;
}
}
@Override
public boolean performFinish() {
// Save settings
getSettings().saveTo(getDialogSettings());
showError(null);
// Compare
final CompareObjectsExecutor executor = new CompareObjectsExecutor(settings);
try {
DBeaverUI.run(
getContainer(),
true,
true,
new DBRRunnableWithProgress() {
@Override
public void run(DBRProgressMonitor monitor)
throws InvocationTargetException, InterruptedException {
try {
CompareReport report = generateReport(monitor, executor);
renderReport(monitor, report);
} catch (DBException e) {
throw new InvocationTargetException(e);
}
}
});
UIUtils.showMessageBox(
getShell(), "Objects compare", "Objects compare finished", SWT.ICON_INFORMATION);
} catch (InvocationTargetException e) {
if (executor.getInitializeError() != null) {
showError(executor.getInitializeError().getMessage());
} else {
log.error(e.getTargetException());
showError(e.getTargetException().getMessage());
}
return false;
} catch (InterruptedException e) {
showError("Compare interrupted");
return false;
} finally {
executor.dispose();
}
// Done
return true;
}
public static void showErrorDialog(
@Nullable Shell shell,
@NotNull String title,
@Nullable String message,
@Nullable Throwable error) {
if (error != null) {
log.error(error);
}
showErrorDialog(
shell,
title,
error == null ? null : message,
error == null
? new Status(IStatus.ERROR, DBeaverCore.PLUGIN_ID, message)
: GeneralUtils.makeExceptionStatus(error));
}
protected static List<DBNNode> loadTreeState(DBPPreferenceStore store, String propName) {
final List<DBNNode> result = new ArrayList<>();
final String sources = store.getString(propName);
if (!CommonUtils.isEmpty(sources)) {
try {
DBeaverUI.runInProgressService(
new DBRRunnableWithProgress() {
@Override
public void run(DBRProgressMonitor monitor) {
// Keep broken datasources to make connect attempt only once
Set<DBNDataSource> brokenDataSources = new HashSet<>();
// Find all nodes
StringTokenizer st = new StringTokenizer(sources, "|"); // $NON-NLS-1$
while (st.hasMoreTokens()) {
String nodePath = st.nextToken();
try {
DBNDataSource dsNode =
DBeaverCore.getInstance().getNavigatorModel().getDataSourceByPath(nodePath);
if (brokenDataSources.contains(dsNode)) {
continue;
}
DBNNode node =
DBeaverCore.getInstance()
.getNavigatorModel()
.getNodeByPath(monitor, nodePath);
if (node != null) {
result.add(node);
} else {
brokenDataSources.add(dsNode);
}
} catch (DBException e) {
log.error(e);
}
}
}
});
} catch (InvocationTargetException e) {
log.error(e.getTargetException());
} catch (InterruptedException e) {
// ignore
}
}
return result;
}
private void dispose() {
// this.trayItem.dispose();
this.sharedTextColors.dispose();
if (trayItem != null) {
trayItem.hide();
}
List<IDisposable> dispList = new ArrayList<>(globalDisposables);
Collections.reverse(dispList);
for (IDisposable disp : dispList) {
try {
disp.dispose();
} catch (Exception e) {
log.error(e);
}
globalDisposables.remove(disp);
}
}
private void loadImage() {
if (imageViewer == null || imageViewer.isDisposed()) {
return;
}
if (getEditorInput() instanceof IPathEditorInput) {
try {
final IPath absolutePath = ((IPathEditorInput) getEditorInput()).getPath();
File localFile = absolutePath.toFile();
if (localFile.exists()) {
try (InputStream inputStream = new FileInputStream(localFile)) {
contentValid = imageViewer.loadImage(inputStream);
imageViewer.update();
}
}
} catch (Exception e) {
log.error("Can't load image contents", e);
}
}
}
public DBNResource findResource(IResource resource) {
List<IResource> path = new ArrayList<>();
for (IResource parent = resource; !(parent instanceof IProject); parent = parent.getParent()) {
path.add(0, parent);
}
DBNResource resNode = this;
for (IResource res : path) {
try {
resNode.getChildren(VoidProgressMonitor.INSTANCE);
} catch (DBException e) {
log.error(e);
}
resNode = resNode.getChild(res);
if (resNode == null) {
return null;
}
}
return resNode;
}
private void makeProposalsFromAssistant(
DBRProgressMonitor monitor,
DBSStructureAssistant assistant,
@Nullable DBSObjectContainer rootSC,
String objectName,
List<SQLCompletionProposal> proposals) {
try {
Collection<DBSObjectReference> references =
assistant.findObjectsByMask(
monitor,
rootSC,
assistant.getAutoCompleteObjectTypes(),
wordDetector.removeQuotes(objectName) + "%",
wordDetector.isQuoted(objectName),
100);
for (DBSObjectReference reference : references) {
proposals.add(makeProposalsFromObject(reference, reference.getObjectType().getImage()));
}
} catch (DBException e) {
log.error(e);
}
}
void selectConsumer(
DataTransferNodeDescriptor consumer, DataTransferProcessorDescriptor processor) {
this.consumer = consumer;
this.processor = processor;
if (consumer != null && processor != null) {
if (!processorPropsHistory.containsKey(processor)) {
processorPropsHistory.put(processor, new HashMap<>());
}
}
// Configure pipes
for (DataTransferPipe pipe : dataPipes) {
if (consumer != null) {
try {
pipe.setConsumer((IDataTransferConsumer) consumer.createNode());
} catch (DBException e) {
log.error(e);
pipe.setConsumer(null);
}
} else {
pipe.setConsumer(null);
}
}
}
public static boolean logObjectErrors(
JDBCSession session,
DBCCompileLog compileLog,
OracleSourceObject unit,
OracleObjectType objectType) {
try {
try (JDBCPreparedStatement dbStat =
session.prepareStatement(
"SELECT * FROM SYS.ALL_ERRORS WHERE OWNER=? AND NAME=? AND TYPE=? ORDER BY SEQUENCE")) {
dbStat.setString(1, unit.getSchema().getName());
dbStat.setString(2, unit.getName());
dbStat.setString(3, objectType.getTypeName());
try (ResultSet dbResult = dbStat.executeQuery()) {
boolean hasErrors = false;
while (dbResult.next()) {
DBCCompileError error =
new DBCCompileError(
"ERROR".equals(dbResult.getString("ATTRIBUTE")),
dbResult.getString("TEXT"),
dbResult.getInt("LINE"),
dbResult.getInt("POSITION"));
hasErrors = true;
if (error.isError()) {
compileLog.error(error);
} else {
compileLog.warn(error);
}
}
return !hasErrors;
}
}
} catch (Exception e) {
log.error("Can't read user errors", e);
return false;
}
}
@Override
protected IStatus run(DBRProgressMonitor monitor) {
RuntimeUtils.setThreadName("SQL script execution");
statistics = new DBCStatistics();
try {
DBCExecutionContext context = getExecutionContext();
DBCTransactionManager txnManager = DBUtils.getTransactionManager(context);
DBCExecutionPurpose purpose =
queries.size() > 1 ? DBCExecutionPurpose.USER_SCRIPT : DBCExecutionPurpose.USER;
try (DBCSession session = context.openSession(monitor, purpose, "SQL Query")) {
// Set transaction settings (only if autocommit is off)
QMUtils.getDefaultHandler().handleScriptBegin(session);
boolean oldAutoCommit = txnManager == null || txnManager.isAutoCommit();
boolean newAutoCommit = (commitType == SQLScriptCommitType.AUTOCOMMIT);
if (txnManager != null && !oldAutoCommit && newAutoCommit) {
txnManager.setAutoCommit(monitor, true);
}
monitor.beginTask(this.getName(), queries.size());
// Notify job start
if (listener != null) {
listener.onStartScript();
}
resultSetNumber = 0;
for (int queryNum = 0; queryNum < queries.size(); ) {
// Execute query
SQLQuery query = queries.get(queryNum);
fetchResultSetNumber = resultSetNumber;
boolean runNext = executeSingleQuery(session, query, true);
if (!runNext) {
// Ask to continue
if (lastError != null) {
log.error(lastError);
}
boolean isQueue = queryNum < queries.size() - 1;
ExecutionQueueErrorResponse response =
ExecutionQueueErrorJob.showError(
isQueue ? "SQL script execution" : "SQL query execution", lastError, isQueue);
boolean stopScript = false;
switch (response) {
case STOP:
// just stop execution
stopScript = true;
break;
case RETRY:
// just make it again
continue;
case IGNORE:
// Just do nothing
break;
case IGNORE_ALL:
errorHandling = SQLScriptErrorHandling.IGNORE;
break;
}
if (stopScript) {
break;
}
}
// Check monitor
if (monitor.isCanceled()) {
break;
}
monitor.worked(1);
queryNum++;
}
showExecutionResult(session);
monitor.done();
// Commit data
if (txnManager != null && !oldAutoCommit && commitType != SQLScriptCommitType.AUTOCOMMIT) {
if (lastError == null || errorHandling == SQLScriptErrorHandling.STOP_COMMIT) {
if (commitType != SQLScriptCommitType.NO_COMMIT) {
monitor.beginTask("Commit data", 1);
txnManager.commit(session);
monitor.done();
}
} else {
monitor.beginTask("Rollback data", 1);
txnManager.rollback(session, null);
monitor.done();
}
}
// Restore transactions settings
if (txnManager != null && !oldAutoCommit && newAutoCommit) {
txnManager.setAutoCommit(monitor, false);
}
QMUtils.getDefaultHandler().handleScriptEnd(session);
// Return success
return new Status(Status.OK, DBeaverCore.getCorePluginID(), "SQL job completed");
}
} catch (Throwable ex) {
return new Status(
Status.ERROR,
DBeaverCore.getCorePluginID(),
"Error during SQL job execution: " + ex.getMessage());
} finally {
// Notify job end
if (listener != null) {
listener.onEndScript(statistics, lastError != null);
}
}
}
@Nullable
private DBSObject getTableFromAlias(
DBRProgressMonitor monitor, DBSObjectContainer sc, @Nullable String token) {
final DBPDataSource dataSource = editor.getDataSource();
if (!(dataSource instanceof SQLDataSource)) {
return null;
}
if (activeQuery == null) {
activeQuery = editor.extractQueryAtPos(documentOffset).getQuery() + " ";
}
final List<String> nameList = new ArrayList<>();
if (token == null) {
token = "";
}
{
Matcher matcher;
Pattern aliasPattern;
SQLDialect sqlDialect = ((SQLDataSource) dataSource).getSQLDialect();
String quoteString = sqlDialect.getIdentifierQuoteString();
String quote =
quoteString == null
? SQLConstants.STR_QUOTE_DOUBLE
: SQLConstants.STR_QUOTE_DOUBLE.equals(quoteString)
? quoteString
: Pattern.quote(quoteString);
String catalogSeparator = sqlDialect.getCatalogSeparator();
while (token.endsWith(catalogSeparator)) token = token.substring(0, token.length() - 1);
String tableNamePattern =
"((?:"
+ quote
+ "(?:[.[^"
+ quote
+ "]]+)"
+ quote
+ ")|(?:[\\w"
+ Pattern.quote(catalogSeparator)
+ "]+))";
String structNamePattern;
if (CommonUtils.isEmpty(token)) {
structNamePattern = "(?:from|update|join|into)\\s*" + tableNamePattern;
} else {
structNamePattern =
tableNamePattern
+ "(?:\\s*\\.\\s*"
+ tableNamePattern
+ ")?"
+ "\\s+(?:(?:AS)\\s)?"
+ token
+ "[\\s,]+";
}
try {
aliasPattern = Pattern.compile(structNamePattern, Pattern.CASE_INSENSITIVE);
} catch (PatternSyntaxException e) {
// Bad pattern - seems to be a bad token
return null;
}
matcher = aliasPattern.matcher(activeQuery);
if (!matcher.find()) {
return null;
}
int groupCount = matcher.groupCount();
for (int i = 1; i <= groupCount; i++) {
String group = matcher.group(i);
if (!CommonUtils.isEmpty(group)) {
String[] allNames = group.split(Pattern.quote(catalogSeparator));
for (String name : allNames) {
if (quoteString != null && name.startsWith(quoteString) && name.endsWith(quoteString)) {
name = name.substring(1, name.length() - 1);
}
nameList.add(name);
}
}
}
}
if (nameList.isEmpty()) {
return null;
}
for (int i = 0; i < nameList.size(); i++) {
nameList.set(
i, DBObjectNameCaseTransformer.transformName(sc.getDataSource(), nameList.get(i)));
}
try {
DBSObject childObject = null;
while (childObject == null) {
childObject = DBUtils.findNestedObject(monitor, sc, nameList);
if (childObject == null) {
DBSObjectContainer parentSc = DBUtils.getParentAdapter(DBSObjectContainer.class, sc);
if (parentSc == null) {
break;
}
sc = parentSc;
}
}
if (childObject == null && nameList.size() <= 1) {
// No such object found - may be it's start of table name
DBSStructureAssistant structureAssistant =
DBUtils.getAdapter(DBSStructureAssistant.class, sc);
if (structureAssistant != null) {
String objectNameMask = nameList.get(0);
Collection<DBSObjectReference> tables =
structureAssistant.findObjectsByMask(
monitor,
sc,
structureAssistant.getAutoCompleteObjectTypes(),
wordDetector.removeQuotes(objectNameMask),
wordDetector.isQuoted(objectNameMask),
2);
if (!tables.isEmpty()) {
return tables.iterator().next().resolveObject(monitor);
}
}
return null;
} else {
return childObject;
}
} catch (DBException e) {
log.error(e);
return null;
}
}
private void makeStructureProposals(
DBRProgressMonitor monitor, DBPDataSource dataSource, List<SQLCompletionProposal> proposals) {
final DBSObjectContainer rootContainer =
DBUtils.getAdapter(DBSObjectContainer.class, dataSource);
if (rootContainer == null) {
return;
}
DBSObjectContainer selectedContainer = null;
{
DBSObject selectedObject = getSelectedObject(dataSource);
if (selectedObject != null) {
selectedContainer = DBUtils.getAdapter(DBSObjectContainer.class, selectedObject);
}
}
DBSObjectContainer sc = rootContainer;
DBSObject childObject = sc;
List<String> tokens = wordDetector.splitWordPart();
String lastToken = null;
for (int i = 0; i < tokens.size(); i++) {
String token = tokens.get(i);
if (i == tokens.size() - 1 && !wordDetector.getWordPart().endsWith(".")) {
lastToken = token;
break;
}
if (sc == null) {
break;
}
// Get next structure container
try {
String objectName = DBObjectNameCaseTransformer.transformName(dataSource, token);
childObject = sc.getChild(monitor, objectName);
if (childObject == null && i == 0 && selectedContainer != null) {
// Probably it is from selected object, let's try it
childObject = selectedContainer.getChild(monitor, objectName);
if (childObject != null) {
sc = selectedContainer;
}
}
if (childObject == null) {
if (i == 0) {
// Assume it's a table alias ?
childObject = this.getTableFromAlias(monitor, sc, token);
if (childObject == null) {
DBSStructureAssistant structureAssistant =
DBUtils.getAdapter(DBSStructureAssistant.class, sc);
if (structureAssistant != null) {
Collection<DBSObjectReference> references =
structureAssistant.findObjectsByMask(
monitor,
null,
structureAssistant.getAutoCompleteObjectTypes(),
wordDetector.removeQuotes(token),
wordDetector.isQuoted(token),
2);
if (!references.isEmpty()) {
childObject = references.iterator().next().resolveObject(monitor);
}
}
}
} else {
// Path element not found. Damn - can't do anything.
return;
}
}
if (childObject instanceof DBSObjectContainer) {
sc = (DBSObjectContainer) childObject;
} else {
sc = null;
}
} catch (DBException e) {
log.error(e);
return;
}
}
if (childObject == null) {
return;
}
if (lastToken == null) {
// Get all children objects as proposals
makeProposalsFromChildren(monitor, childObject, null, proposals);
} else {
// Get matched children
makeProposalsFromChildren(monitor, childObject, lastToken, proposals);
if (proposals.isEmpty() || tokens.size() == 1) {
// At last - try to find child tables by pattern
DBSStructureAssistant structureAssistant = null;
for (DBSObject object = childObject; object != null; object = object.getParentObject()) {
structureAssistant = DBUtils.getAdapter(DBSStructureAssistant.class, object);
if (structureAssistant != null) {
break;
}
}
if (structureAssistant != null) {
makeProposalsFromAssistant(monitor, structureAssistant, sc, lastToken, proposals);
}
}
}
}
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;
}
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;
}