/**
* 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);
}
}
}
@Override
public void fetchRow(DBCSession session, DBCResultSet resultSet) throws DBCException {
Object[] row = new Object[columnsCount];
for (int i = 0; i < columnsCount; i++) {
try {
row[i] =
metaColumns[i]
.getValueHandler()
.fetchValueObject(
session,
resultSet,
metaColumns[i].getAttribute(),
metaColumns[i].getOrdinalPosition());
} catch (DBCException e) {
// Do not reports the same error multiple times
// There are a lot of error could occur during result set fetch
// We report certain error only once
List<DBCException> errorList = errors.get(metaColumns[i].getMetaAttribute());
if (errorList == null) {
errorList = new ArrayList<>();
errors.put(metaColumns[i].getMetaAttribute(), errorList);
}
if (!errorList.contains(e)) {
log.warn("Can't read column '" + metaColumns[i].getName() + "' value", e);
errorList.add(e);
}
}
}
rows.add(row);
}
/** Data type resolver */
public class SQLDataTypeResolver extends TemplateVariableResolver {
private static final Log log = Log.getLog(SQLDataTypeResolver.class);
public SQLDataTypeResolver() {
super("type", "Data type");
}
@Override
protected String[] resolveAll(final TemplateContext context) {
final DBCExecutionContext executionContext =
((DBPContextProvider) context).getExecutionContext();
if (executionContext == null) {
return super.resolveAll(context);
}
DBPDataTypeProvider dataTypeProvider =
DBUtils.getAdapter(DBPDataTypeProvider.class, executionContext.getDataSource());
if (dataTypeProvider != null) {
final Collection<? extends DBSDataType> localDataTypes = dataTypeProvider.getLocalDataTypes();
if (!CommonUtils.isEmpty(localDataTypes)) {
String[] result = new String[localDataTypes.size()];
int index = 0;
for (DBSDataType dataType : localDataTypes) {
result[index++] = dataType.getName();
}
return result;
}
}
return super.resolveAll(context);
}
}
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;
}
@Override
public void contributeProperties(
@NotNull DBPPropertyManager propertySource, @NotNull IValueController controller) {
super.contributeProperties(propertySource, controller);
try {
Object value = controller.getValue();
if (value instanceof DBDContent) {
propertySource.addProperty(
PROP_CATEGORY_CONTENT,
"content_type", //$NON-NLS-1$
CoreMessages.model_jdbc_content_type,
((DBDContent) value).getContentType());
final long contentLength = ((DBDContent) value).getContentLength();
if (contentLength >= 0) {
propertySource.addProperty(
PROP_CATEGORY_CONTENT,
"content_length", //$NON-NLS-1$
CoreMessages.model_jdbc_content_length,
contentLength);
}
}
} catch (Exception e) {
log.warn("Can't extract CONTENT value information", e); // $NON-NLS-1$
}
}
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);
}
}
/** Entity resolver */
public class SQLAttributeResolver extends TemplateVariableResolver {
private static final Log log = Log.getLog(SQLAttributeResolver.class);
public SQLAttributeResolver() {
super("column", "Table column");
}
@Override
protected String[] resolveAll(final TemplateContext context) {
final DBCExecutionContext executionContext =
((DBPContextProvider) context).getExecutionContext();
if (executionContext == null) {
return super.resolveAll(context);
}
TemplateVariable tableVariable = ((SQLContext) context).getTemplateVariable("table");
final String tableName = tableVariable == null ? null : tableVariable.getDefaultValue();
if (!CommonUtils.isEmpty(tableName)) {
final List<DBSEntityAttribute> attributes = new ArrayList<>();
DBRRunnableWithProgress runnable =
new DBRRunnableWithProgress() {
@Override
public void run(DBRProgressMonitor monitor)
throws InvocationTargetException, InterruptedException {
try {
List<DBSEntity> entities = new ArrayList<>();
SQLEntityResolver.resolveTables(monitor, executionContext, context, entities);
if (!CommonUtils.isEmpty(entities)) {
DBSEntity table = DBUtils.findObject(entities, tableName);
if (table != null) {
attributes.addAll(CommonUtils.safeCollection(table.getAttributes(monitor)));
}
}
} catch (DBException e) {
throw new InvocationTargetException(e);
}
}
};
RuntimeUtils.runTask(runnable, "Resolve attributes", 1000);
if (!CommonUtils.isEmpty(attributes)) {
String[] result = new String[attributes.size()];
for (int i = 0; i < attributes.size(); i++) {
DBSEntityAttribute entity = attributes.get(i);
result[i] = entity.getName();
}
return result;
}
}
return super.resolveAll(context);
}
@Override
public void resolve(TemplateVariable variable, TemplateContext context) {
super.resolve(variable, context);
if (variable instanceof SQLVariable) {
((SQLVariable) variable).setResolver(this);
}
}
}
/**
* Eclipse hack. Disables/enabled all key bindings in specified site's part. Works only if host
* editor is extender of AbstractTextEditor Uses reflection because setActionActivation is private
* method TODO: find better way to disable key bindings or prioritize event handling to widgets
*
* @param partSite workbench part site
* @param enable enable or disable
*/
@Deprecated
public static void enableHostEditorKeyBindings(IWorkbenchPartSite partSite, boolean enable) {
IWorkbenchPart part = partSite.getPart();
if (part instanceof AbstractTextEditor) {
AbstractTextEditor hostEditor = (AbstractTextEditor) part;
if (hostEditor instanceof BaseTextEditor) {
StyledText textWidget = ((BaseTextEditor) hostEditor).getTextViewer().getTextWidget();
if (textWidget == null || textWidget.isDisposed()) {
return;
}
}
try {
Method activatorMethod =
AbstractTextEditor.class.getDeclaredMethod("setActionActivation", Boolean.TYPE);
activatorMethod.setAccessible(true);
activatorMethod.invoke(hostEditor, enable);
} catch (Throwable e) {
if (e instanceof InvocationTargetException) {
e = ((InvocationTargetException) e).getTargetException();
}
log.warn("Can't disable text editor action activations", e);
}
// hostEditor.getEditorSite().getActionBarContributor().setActiveEditor(hostEditor);
}
}
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 Combo createEncodingCombo(Composite parent, String curCharset) {
if (curCharset == null) {
curCharset = GeneralUtils.getDefaultFileEncoding();
}
Combo encodingCombo = new Combo(parent, SWT.DROP_DOWN);
encodingCombo.setVisibleItemCount(30);
SortedMap<String, Charset> charsetMap = Charset.availableCharsets();
int index = 0;
int defIndex = -1;
for (String csName : charsetMap.keySet()) {
Charset charset = charsetMap.get(csName);
encodingCombo.add(charset.displayName());
if (charset.displayName().equalsIgnoreCase(curCharset)) {
defIndex = index;
}
if (defIndex < 0) {
for (String alias : charset.aliases()) {
if (alias.equalsIgnoreCase(curCharset)) {
defIndex = index;
}
}
}
index++;
}
if (defIndex >= 0) {
encodingCombo.select(defIndex);
} else {
log.warn("Charset '" + curCharset + "' is not recognized"); // $NON-NLS-1$ //$NON-NLS-2$
}
return encodingCombo;
}
@Override
protected ElementInfo createElementInfo(Object element) throws CoreException {
if (element instanceof IEditorInput) {
IEditorInput input = (IEditorInput) element;
IStorage storage = EditorUtils.getStorageFromInput(input);
if (storage instanceof IFile) {
IFile file = (IFile) storage;
try {
refreshFile(file);
} catch (CoreException x) {
log.warn("Can't refresh file", x);
}
IDocument d;
IStatus s = null;
try {
d = createDocument(element);
} catch (CoreException x) {
log.warn("Can't create document", x);
s = x.getStatus();
d = createEmptyDocument();
}
// Set the initial line delimiter
String initialLineDelimiter = GeneralUtils.getDefaultLineSeparator();
if (initialLineDelimiter != null) {
((IDocumentExtension4) d).setInitialLineDelimiter(initialLineDelimiter);
}
IAnnotationModel m = createAnnotationModel(element);
FileSynchronizer f = new FileSynchronizer(input);
f.install();
FileInfo info = new FileInfo(d, m, f);
info.modificationStamp = computeModificationStamp(file);
info.fStatus = s;
return info;
}
}
return super.createElementInfo(element);
}
public static void dispose(Resource resource) {
if (resource != null && !resource.isDisposed()) {
try {
resource.dispose();
} catch (Exception e) {
log.debug("Resource dispose error", e);
}
}
}
public static void dispose(Widget widget) {
if (widget != null && !widget.isDisposed()) {
try {
widget.dispose();
} catch (Exception e) {
log.debug("widget dispose error", e);
}
}
}
public static void addFocusTracker(
IServiceLocator serviceLocator, String controlID, Control control) {
final IFocusService focusService = serviceLocator.getService(IFocusService.class);
if (focusService != null) {
focusService.addFocusTracker(control, controlID);
} else {
log.debug("Focus service not found in " + serviceLocator);
}
}
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;
}
}
@Override
public String getNodeDescription() {
try {
final IProject project = getProject();
return project == null ? null : project.getDescription().getComment();
} catch (CoreException e) {
log.debug(e);
return null;
}
}
public static void removeFocusTracker(IServiceLocator serviceLocator, Control control) {
if (PlatformUI.getWorkbench().isClosing()) {
// TODO: it is a bug in eclipse. During workbench shutdown disposed service returned.
return;
}
final IFocusService focusService = serviceLocator.getService(IFocusService.class);
if (focusService != null) {
focusService.removeFocusTracker(control);
} else {
log.debug("Focus service not found in " + serviceLocator);
}
}
@Nullable
public static Integer getTextInteger(Text text) {
String str = text.getText();
str = str.trim();
if (str.length() == 0) {
return null;
}
try {
return Integer.valueOf(str);
} catch (NumberFormatException e) {
log.debug(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);
}
}
static class LoadingUIJob<RESULT> extends AbstractUIJob {
private static final Log log = Log.getLog(LoadingUIJob.class);
private static final long DELAY = 200;
private ILoadService<RESULT> loadService;
private ILoadVisualizer<RESULT> visualizer;
private DBRProgressMonitor mainMonitor;
LoadingUIJob(LoadingJob<RESULT> loadingJob, DBRProgressMonitor mainMonitor) {
super(loadingJob.getName());
this.loadService = loadingJob.getLoadingService();
this.visualizer = loadingJob.getVisualizer();
this.mainMonitor = mainMonitor;
setSystem(true);
}
@Override
public IStatus runInUIThread(DBRProgressMonitor monitor) {
/*
if (mainMonitor.isCanceled()) {
// Try to cancel current load service
try {
loadService.cancel();
}
catch (InvocationTargetException e) {
log.warn("Error while canceling service", e.getTargetException());
}
return Status.CANCEL_STATUS;
} else {
*/
if (!visualizer.isCompleted()) {
visualizer.visualizeLoading();
schedule(DELAY);
}
// }
return Status.OK_STATUS;
}
@Override
public boolean belongsTo(Object family) {
return family == LOADING_FAMILY;
}
@Override
protected void canceling() {
super.canceling();
}
}
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;
}
}
private Boolean computeUserIsAuthorisedForDBCFG() {
// Must have one of DATAACCESS, DBADM, SQLADM or or SELECT on SYSIBMADM.APPLICATIONS or CONTROL
// on SYSIBMADM.APPLICATIONS
if ((listAuthorities.contains(DATAACCESS))
|| (listAuthorities.contains(DBADM))
|| (listAuthorities.contains(SQLADM))) {
return true;
}
if (listObjectPrivileges.contains(AUTH_DBCFG)) {
return true;
}
LOG.debug("Current User is not authorized to see DB/DBM Configuration Parameters");
return false;
}
private boolean matchesContentType(IResultSetContext context) {
String documentType = context.getDocumentContentType();
if (contentTypes.isEmpty() || CommonUtils.isEmpty(documentType)) {
return false;
}
for (MimeType mimeType : contentTypes) {
try {
if (mimeType.match(documentType)) {
return true;
}
} catch (MimeTypeParseException e) {
log.warn("Bad document content type: " + documentType, e);
}
}
return false;
}
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;
}
@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));
}
public PostgreDataType getDataType(long typeId) {
if (typeId <= 0) {
return null;
}
PostgreDataType dataType = dataTypeCache.get(typeId);
if (dataType != null) {
return dataType;
}
for (PostgreSchema schema : getDatabase().schemaCache.getCachedObjects()) {
dataType = schema.dataTypeCache.getDataType(typeId);
if (dataType != null) {
dataTypeCache.put(typeId, dataType);
return dataType;
}
}
log.debug("Data type '" + typeId + "' not found");
return null;
}
public PostgreDataType getDataType(String typeName) {
if (typeName.endsWith("[]")) {
// In some cases ResultSetMetadata returns it as []
typeName = "_" + typeName.substring(0, typeName.length() - 2);
}
String alias = PostgreConstants.DATA_TYPE_ALIASES.get(typeName);
if (alias != null) {
typeName = alias;
}
{
// First check system catalog
final PostgreSchema schema = getCatalogSchema();
if (schema != null) {
final PostgreDataType dataType = schema.dataTypeCache.getCachedObject(typeName);
if (dataType != null) {
return dataType;
}
}
}
// Check schemas in search path
final List<String> searchPath = dataSource.getSearchPath();
for (String schemaName : searchPath) {
final PostgreSchema schema = schemaCache.getCachedObject(schemaName);
if (schema != null) {
final PostgreDataType dataType = schema.dataTypeCache.getCachedObject(typeName);
if (dataType != null) {
return dataType;
}
}
}
// Check the rest
for (PostgreSchema schema : schemaCache.getCachedObjects()) {
if (searchPath.contains(schema.getName())) {
continue;
}
final PostgreDataType dataType = schema.dataTypeCache.getCachedObject(typeName);
if (dataType != null) {
return dataType;
}
}
log.debug("Data type '" + typeName + "' not found in database '" + getName() + "'");
return null;
}
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);
}
}