25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
import * as api from "@/lib/backend/api";
import { connectionObjectTreeNodeSchema, effectiveDatabaseTypeForConnection, metadataSchemaForConnection } from "@/lib/database/jdbcDialect";
import { invalidateTableMetadataCache, loadTableMetadata } from "@/lib/metadata/tableMetadataCache";
import { canApplyDataTabMetadata, canReuseActiveMongoTab, type DataTabReuseMode } from "@/lib/sidebar/dataTabOpenPolicy";
import { isNoSnapshotErrorResult, isQueryExecutionErrorResult } from "@/lib/query/queryResultError";
import { buildTableSelectSql, requiresEagerTableMetadataForDataOpen } from "@/lib/table/tableSelectSql";
import { resolveTableDefaultSort, applyTableDefaultSortResult } from "@/lib/table/tableDefaultSort";
import { tableDataLargeValuePreviewOptions } from "@/lib/dataGrid/dataGridLargeValues";
import { editableRowIdentifierColumns, physicalTablePrimaryKeys, shouldIncludeSyntheticRowId } from "@/lib/table/tableEditing";
import { tableOpenPageLimit } from "@/lib/table/tableOpenPageLimit";
import { uuid } from "@/lib/common/utils";
import { beginDataTabNavigation, endDataTabNavigation, isCurrentDataTabNavigation } from "@/lib/tabs/dataTabNavigationGeneration";
import { useSidebarDataOpenRuntime } from "@/composables/useSidebarDataOpenRuntime";
import { useConnectionStore } from "@/stores/connectionStore";
import { useQueryStore } from "@/stores/queryStore";
import { useSettingsStore } from "@/stores/settingsStore";
import type { ColumnInfo, TableInfoTab } from "@/types/database";
export type NavigationTarget = {
connectionId: string;
database: string;
catalog?: string;
schema?: string;
tableName: string;
tableType?: string;
comment?: string | null;
columnName?: string;
whereInput?: string;
/** Database search: open the structure editor instead of a data preview. */
searchScope?: "data" | "structure";
};
export interface NavigationOpenOptions {
// Called once the selected tab has its target identity, before loading data.
onOpened?: (tabId: string) => void;
// Guards selection only; background loading uses the tab execution generation.
isCurrent?: () => boolean;
}
function openMongoCollectionTarget(target: NavigationTarget, reuseMode: DataTabReuseMode) {
const connectionStore = useConnectionStore();
const queryStore = useQueryStore();
connectionStore.activeConnectionId = target.connectionId;
const tabTitle = `${target.database}.${target.tableName}`;
const sameCollectionTab = reuseMode === "always-new" ? undefined : queryStore.tabs.find((tab) => tab.mode === "mongo" && tab.connectionId === target.connectionId && tab.database === target.database && tab.sql === target.tableName);
const activeTab = queryStore.tabs.find((tab) => tab.id === queryStore.activeTabId);
const reusableActiveTab = reuseMode === "active-tab" && !sameCollectionTab && canReuseActiveMongoTab(activeTab, target) ? activeTab : undefined;
const reusableTab = sameCollectionTab ?? reusableActiveTab;
const tabId = reusableTab?.id ?? queryStore.createTab(target.connectionId, target.database, tabTitle, "mongo", undefined, undefined, undefined, { forceNew: true });
if (reusableTab) {
queryStore.switchTab(tabId);
reusableTab.title = tabTitle;
}
queryStore.updateSql(tabId, target.tableName);
queryStore.setTableMeta(tabId, {
database: target.database,
tableName: target.tableName,
tableType: target.tableType || "TABLE",
columns: [],
primaryKeys: [],
});
return tabId;
}
async function openTableTarget(target: NavigationTarget, options: NavigationOpenOptions & { tableInfoTab?: TableInfoTab } = {}) {
const connectionStore = useConnectionStore();
const queryStore = useQueryStore();
const settingsStore = useSettingsStore();
const pageLimit = tableOpenPageLimit(settingsStore.editorSettings.tableOpenPageSize);
if (options.isCurrent?.() === false) return;
connectionStore.activeConnectionId = target.connectionId;
const config = connectionStore.getConfig(target.connectionId);
if (config?.db_type === "mongodb") {
const tabId = openMongoCollectionTarget(target, settingsStore.editorSettings.dataTabReuseMode);
options.onOpened?.(tabId);
return;
}
const tableSchema = connectionObjectTreeNodeSchema(config, target.database, target.schema);
const tabTitle = target.catalog ? `${target.catalog}.${tableSchema || target.database}.${target.tableName}` : tableSchema ? `${tableSchema}.${target.tableName}` : target.tableName;
if (config?.db_type === "qdrant" || config?.db_type === "milvus" || config?.db_type === "weaviate" || config?.db_type === "chromadb") {
await connectionStore.ensureConnected(target.connectionId);
if (options.isCurrent?.() === false) return;
const tabId = queryStore.createTab(target.connectionId, target.database || "default", tabTitle, "vector");
queryStore.updateSql(tabId, target.tableName);
options.onOpened?.(tabId);
return;
}
const tabId = queryStore.createTab(target.connectionId, target.database, tabTitle, "data", tableSchema, undefined, undefined, { forceNew: true });
const targetTab = queryStore.tabs.find((tab) => tab.id === tabId);
if (targetTab) {
targetTab.tableInfoTab = options.tableInfoTab;
targetTab.tableComment = target.comment;
}
// Stamp the new table identity synchronously so SQL rebuilds (refresh,
// filters, row count) never read a stale tableMeta from a reused tab or
// fall back to parsing the schema-qualified tab title (issue #3613).
queryStore.setTableMeta(tabId, {
schema: tableSchema,
catalog: target.catalog,
database: target.database,
tableName: target.tableName,
tableType: target.tableType ?? "TABLE",
columns: [],
primaryKeys: [],
});
// 占位身份的行标识未知:真实元数据落地(下方 getColumns 成功后的 setTableMeta)
// 前编辑/保存保持禁用,防止数据查询先返回时整行 WHERE 保存路径短暂可用(#3727)
if (targetTab) targetTab.tableMetaPending = true;
// 立即作废旧执行代次:旧导航在途的 executeTabSql 结果按 executionId 比对
// 落地,仅置 isExecuting 不会替换 executionId,旧结果仍可能写入本 tab。
// preparationId 同时参与 isCurrentTarget:用户在准备期点击停止会清掉
// executionId,后续异步返回后不得再启动查询(同 refreshPreparationId 模式)
const preparationId = uuid();
queryStore.setExecutingWithId(tabId, preparationId);
// 侧边栏 openData 可能接管同一 tab:每次异步返回后必须校验(1)本次
// 导航仍是该 tab 的最新代次,(2)tab 未被其他流程改指别的
// 目标,(3)准备期 executionId 未被停止/接管清除。否则旧请求晚返回会用
// A 的元数据覆盖新目标 B 的占位并解除 pending,造成结果属于 B、写入目标
// 却是 A 的错位
const navigationToken = beginDataTabNavigation(tabId);
const isCurrentTarget = () =>
isCurrentDataTabNavigation(tabId, navigationToken) &&
canApplyDataTabMetadata(
queryStore.tabs.find((tab) => tab.id === tabId),
{
connectionId: target.connectionId,
database: target.database,
schema: tableSchema,
catalog: target.catalog,
tableName: target.tableName,
},
);
// 仅首次 executeTabSql 前有效:executeTabSql 会替换 executionId、完成后清空,
// 之后的落地点(元数据/fallback)回到 isCurrentTarget 判定。
// isCancelling 必须同查:停止请求先同步置 isCancelling,等 cancelQuery 返回
// 才清 executionId——这个窗口内准备流程不得启动查询
const isPreparationCurrent = () => {
const currentTab = queryStore.tabs.find((tab) => tab.id === tabId);
return isCurrentTarget() && currentTab?.executionId === preparationId && !currentTab.isCancelling;
};
// 区分外层 catch 的判定:准备期(首次 executeTabSql 前)reject 用
// isPreparationCurrent——停止/接管后的迟到错误不得写入;首次执行之后
// preparationId 正常失效,回到 isCurrentTarget,真实错误仍要展示
let firstExecuteStarted = false;
options.onOpened?.(tabId);
try {
await connectionStore.ensureConnected(target.connectionId);
if (!isPreparationCurrent()) return;
if (!config) throw new Error("Connection config not found");
const metadataGenerationAtStart = connectionStore.metadataGenerationFor(target.connectionId, target.database);
const isCurrentGeneration = () => connectionStore.metadataGenerationFor(target.connectionId, target.database) === metadataGenerationAtStart;
const effectiveDbType = effectiveDatabaseTypeForConnection(config);
const identifierQuote = connectionStore.connectionIdentifierQuote?.(target.connectionId);
const querySchema = metadataSchemaForConnection(config, target.database, tableSchema);
const targetTableType = target.tableType ?? "TABLE";
if (config.db_type === "neo4j") {
const columns = await api.getColumns(target.connectionId, target.database, querySchema, target.tableName);
const primaryKeys = editableRowIdentifierColumns(effectiveDbType, columns, undefined, targetTableType);
const defaultSort = resolveTableDefaultSort(settingsStore.editorSettings, effectiveDbType, physicalTablePrimaryKeys(columns), identifierQuote);
const sql = await buildTableSelectSql({
databaseType: effectiveDbType,
driverProfile: config.driver_profile,
serverVersion: connectionStore.getConfig(target.connectionId)?.database_info?.productVersion,
identifierQuote,
schema: tableSchema,
catalog: target.catalog,
database: target.database,
tableName: target.tableName,
includeDatabaseName: settingsStore.editorSettings.generateSqlIncludeDatabaseName,
injectDefaultTimeSeriesWhere: true,
tableType: targetTableType,
columns: columns.map((column) => column.name),
primaryKeys,
orderBy: defaultSort.orderBy,
whereInput: target.whereInput,
limit: pageLimit,
});
if (!isPreparationCurrent() || !isCurrentGeneration()) return;
queryStore.updateSql(tabId, sql);
queryStore.setTableMeta(tabId, {
catalog: target.catalog,
database: target.database,
schema: tableSchema,
tableName: target.tableName,
tableType: targetTableType,
columns,
primaryKeys,
});
firstExecuteStarted = true;
if (targetTab) targetTab.orderByInput = defaultSort.orderBy;
await queryStore.executeTabSql(tabId, sql, { pagination: { limit: pageLimit, offset: 0 } });
if (isCurrentTarget() && targetTab) applyTableDefaultSortResult(targetTab, defaultSort, queryStore.sortTabResultLocally);
return;
}
let eagerMetadata: Awaited<ReturnType<typeof loadTableMetadata>> | undefined;
if (requiresEagerTableMetadataForDataOpen(effectiveDbType) || (settingsStore.editorSettings.tableOpenSortMode ?? "none") !== "none") {
try {
eagerMetadata = await loadTableMetadata({
connectionId: target.connectionId,
database: target.database,
schema: querySchema,
tableName: target.tableName,
tableType: targetTableType,
databaseType: effectiveDbType ?? config.db_type,
driverProfile: config.driver_profile || config.db_type,
catalog: target.catalog,
});
} catch (error) {
// Metadata is needed for optional default sorting, but it must not
// prevent the data preview from opening. The later metadata refresh
// keeps the tab pending for edits and can retry independently.
console.warn("[DBX] unable to preload table metadata for default sort", error);
}
}
const eagerColumns = eagerMetadata?.metadata.columns ?? [];
const eagerPrimaryKeys = eagerMetadata?.metadata.primaryKeys ?? [];
const defaultSort = resolveTableDefaultSort(settingsStore.editorSettings, effectiveDbType, physicalTablePrimaryKeys(eagerColumns, eagerMetadata?.metadata.indexes, effectiveDbType), identifierQuote);
const sql = await buildTableSelectSql({
databaseType: effectiveDbType,
driverProfile: config.driver_profile,
serverVersion: connectionStore.getConfig(target.connectionId)?.database_info?.productVersion,
identifierQuote,
schema: tableSchema,
catalog: target.catalog,
database: target.database,
tableName: target.tableName,
includeDatabaseName: settingsStore.editorSettings.generateSqlIncludeDatabaseName,
tableType: targetTableType,
columns: eagerColumns.map((column) => column.name),
primaryKeys: eagerPrimaryKeys,
orderBy: defaultSort.orderBy,
...tableDataLargeValuePreviewOptions(effectiveDbType, eagerColumns, eagerPrimaryKeys, pageLimit, config.db_type === "jdbc"),
whereInput: target.whereInput,
limit: pageLimit,
});
if (!isPreparationCurrent() || !isCurrentGeneration()) return;
queryStore.updateSql(tabId, sql);
queryStore.setTableMeta(tabId, {
schema: tableSchema,
catalog: target.catalog,
database: target.database,
tableName: target.tableName,
tableType: targetTableType,
columns: eagerColumns,
primaryKeys: eagerPrimaryKeys,
});
firstExecuteStarted = true;
// 取消计数快照:isCancelling 是瞬态的(取消失败/查询先完成会被清掉),
// 比对计数才能跨越 executeTabSql 生命周期识别"执行期间用户请求过停止"
const cancelCountBeforeExecute = queryStore.tabs.find((tab) => tab.id === tabId)?.cancelRequestCount ?? 0;
if (targetTab) targetTab.orderByInput = defaultSort.orderBy;
await queryStore.executeTabSql(tabId, sql, { pagination: { limit: pageLimit, offset: 0 } });
if (!isCurrentTarget()) return;
// 首次查询被停止/失败(executeTabSql 以 Error 结果表达,不抛出)时,
// 后续不得自动启动第二次查询(synthetic row-id/TDengine 重查)——用户
// 停止了查询,流程不能替他再跑一次;元数据落地不受影响
const tabAfterFirstExecute = queryStore.tabs.find((tab) => tab.id === tabId);
const firstResult = tabAfterFirstExecute?.result;
const cancelRequestedDuringExecute = (tabAfterFirstExecute?.cancelRequestCount ?? 0) > cancelCountBeforeExecute;
const firstQueryFailed = cancelRequestedDuringExecute || tabAfterFirstExecute?.isCancelling === true || (firstResult !== undefined && isQueryExecutionErrorResult(firstResult));
if (!firstQueryFailed && targetTab) applyTableDefaultSortResult(targetTab, defaultSort, queryStore.sortTabResultLocally);
// executeTabSql surfaces query failures as an "Error" result instead of throwing.
// A snapshot-less lake table fails the data preview above but its metadata still
// reads fine — retry with LIMIT 0 so the user sees the table structure (columns +
// empty grid) rather than a cryptic server error. The flag also skips the
// synthetic-row-id re-query below, which is another data read that would fail
// the same way on a snapshot-less table.
const fellBackToLimitZero = isNoSnapshotErrorResult(queryStore.tabs.find((tab) => tab.id === tabId)?.result);
if (fellBackToLimitZero) {
const emptySql = await buildTableSelectSql({
databaseType: effectiveDbType,
driverProfile: config.driver_profile,
serverVersion: connectionStore.getConfig(target.connectionId)?.database_info?.productVersion,
identifierQuote,
schema: tableSchema,
catalog: target.catalog,
database: target.database,
tableName: target.tableName,
includeDatabaseName: settingsStore.editorSettings.generateSqlIncludeDatabaseName,
injectDefaultTimeSeriesWhere: true,
tableType: targetTableType,
whereInput: target.whereInput,
limit: 0,
});
if (!isCurrentTarget()) return;
queryStore.updateSql(tabId, emptySql);
await queryStore.executeTabSql(tabId, emptySql, { pagination: { limit: pageLimit, offset: 0 } });
if (!isCurrentTarget()) return;
}
try {
// 复用共享表元数据缓存(30s TTL + in-flight 去重)
const { metadata } = await loadTableMetadata({
connectionId: target.connectionId,
database: target.database,
schema: querySchema,
tableName: target.tableName,
tableType: targetTableType,
databaseType: effectiveDbType ?? config.db_type,
driverProfile: config.driver_profile || config.db_type,
catalog: target.catalog,
});
const columns = metadata.columns;
const primaryKeys = metadata.primaryKeys;
// 异步窗口内 tab 可能已被复用为其他目标:旧请求的元数据不得落地、
// 不得解除新目标的 pending
if (!isCurrentTarget() || !isCurrentGeneration()) return;
const useRowId = shouldIncludeSyntheticRowId(effectiveDbType, primaryKeys, targetTableType);
queryStore.setTableMeta(tabId, {
schema: tableSchema,
catalog: target.catalog,
database: target.database,
tableName: target.tableName,
tableType: targetTableType,
columns,
primaryKeys,
});
if (!fellBackToLimitZero && !firstQueryFailed && (useRowId || config.db_type === "tdengine")) {
const newSql = await buildTableSelectSql({
databaseType: effectiveDbType,
driverProfile: config.driver_profile,
serverVersion: connectionStore.getConfig(target.connectionId)?.database_info?.productVersion,
identifierQuote,
schema: tableSchema,
catalog: target.catalog,
database: target.database,
tableName: target.tableName,
includeDatabaseName: settingsStore.editorSettings.generateSqlIncludeDatabaseName,
injectDefaultTimeSeriesWhere: true,
tableType: targetTableType,
whereInput: target.whereInput,
primaryKeys,
columns: columns.map((column) => column.name),
...tableDataLargeValuePreviewOptions(effectiveDbType, columns, primaryKeys, pageLimit, config.db_type === "jdbc"),
includeRowId: true,
orderBy: defaultSort.orderBy,
limit: pageLimit,
});
if (!isCurrentTarget()) return;
queryStore.updateSql(tabId, newSql);
await queryStore.executeTabSql(tabId, newSql, { pagination: { limit: pageLimit, offset: 0 } });
if (isCurrentTarget() && targetTab) applyTableDefaultSortResult(targetTab, defaultSort, queryStore.sortTabResultLocally);
}
} catch (reason) {
console.error("[DBX] ERROR fetching table metadata:", reason);
}
} catch (e: any) {
if (firstExecuteStarted ? !isCurrentTarget() : !isPreparationCurrent()) return;
queryStore.setErrorResult(tabId, e);
} finally {
endDataTabNavigation(tabId, navigationToken);
}
}
export function useNavigationTargets(dialogs: { showFieldLineageDialog: { value: boolean }; showDatabaseSearchDialog: { value: boolean }; showDiagramDialog: { value: boolean } }) {
const connectionStore = useConnectionStore();
const queryStore = useQueryStore();
const settingsStore = useSettingsStore();
const { openData } = useSidebarDataOpenRuntime();
async function openObjectBrowserTableTarget(target: NavigationTarget, options: NavigationOpenOptions = {}) {
if (options.isCurrent?.() === false) return;
if (connectionStore.getConfig(target.connectionId)?.db_type === "mongodb") {
const tabId = openMongoCollectionTarget(target, settingsStore.editorSettings.dataTabReuseMode);
options.onOpened?.(tabId);
return;
}
if (settingsStore.editorSettings.dataTabReuseMode === "always-new") {
await openTableTarget(target, options);
return;
}
connectionStore.activeConnectionId = target.connectionId;
const normalizedTableType = target.tableType?.trim().toUpperCase().replaceAll(" ", "_");
const nodeType = normalizedTableType === "VIEW" ? "view" : normalizedTableType === "MATERIALIZED_VIEW" ? "materialized_view" : "table";
await openData(
{
id: uuid(),
label: target.tableName,
type: nodeType,
connectionId: target.connectionId,
database: target.database,
schema: target.schema,
catalog: target.catalog,
tableType: target.tableType,
comment: target.comment,
},
undefined,
"default",
{ reuseMode: settingsStore.editorSettings.dataTabReuseMode, ...options },
);
}
async function openLineageTarget(target: NavigationTarget) {
dialogs.showFieldLineageDialog.value = false;
await openTableTarget(target);
}
async function openDatabaseSearchTarget(target: NavigationTarget) {
dialogs.showDatabaseSearchDialog.value = false;
if (target.searchScope === "structure" && target.tableName) {
const tableType = (target.tableType || "").toUpperCase() === "VIEW" ? "view" : "table";
queryStore.openTableStructure(target.connectionId, target.database, target.schema, target.tableName, "columns", target.columnName ? { kind: "column", name: target.columnName } : undefined, target.catalog, tableType);
return;
}
await openTableTarget(target);
}
async function openDiagramTarget(target: NavigationTarget) {
dialogs.showDiagramDialog.value = false;
await openTableTarget(target);
}
async function onStructureEditorSaved(
reloadData: () => Promise<void>,
toast: (msg: string, duration?: number) => void,
context: { connectionId: string; database: string; schema?: string; catalog?: string; tableName: string; exactIdentity?: boolean },
commentChanged?: boolean,
createdTable = false,
) {
if (!context.tableName) {
try {
await connectionStore.refreshObjectListTreeNode(context.connectionId, context.database, context.schema || undefined);
} catch {}
return;
}
if (commentChanged || createdTable) {
try {
await connectionStore.refreshObjectListTreeNode(context.connectionId, context.database, context.schema || undefined);
} catch {}
}
connectionStore.invalidateCompletionTableCache(context.connectionId, context.database, context.tableName, context.schema, context.catalog);
if (context.exactIdentity) queryStore.invalidateTableStructure(context.connectionId, context.database, context.schema, context.tableName, true, context.catalog);
else queryStore.invalidateTableStructure(context.connectionId, context.database, context.schema, context.tableName);
// 结构已变更:无论是否有打开的 data tab 都必须作废共享元数据缓存,否则
// 其它 loadTableMetadata 消费者最长 30 秒拿到旧列。不带 schema/catalog
// 维度(宁可多废,schema 形态在各消费点可能不同)
invalidateTableMetadataCache({ connectionId: context.connectionId, database: context.database, tableName: context.tableName, ...(context.exactIdentity ? { schema: context.schema } : {}) });
const matchingDataTabs = queryStore.tabs.filter((tab) => tab.mode === "data" && tab.connectionId === context.connectionId && tab.database === context.database && tab.tableMeta?.tableName === context.tableName && (tab.schema || tab.tableMeta.schema || "") === (context.schema || ""));
// 同一 catalog 只强制加载一次,结果分发给全部匹配 tab
const loadedByCatalog = new Map<string, { columns: ColumnInfo[]; primaryKeys: string[] }>();
for (const tab of matchingDataTabs) {
try {
const connection = connectionStore.getConfig(tab.connectionId);
// 捕获不可变目标身份:await 期间 tab 可能被导航复用改指其他表,
// 共享缓存结果落地前仍必须复核,不能解除新目标的 pending
const capturedMeta = tab.tableMeta!;
const capturedSchema = tab.schema || capturedMeta.schema;
const capturedTarget = { connectionId: tab.connectionId, database: tab.database, schema: capturedSchema, catalog: capturedMeta.catalog, tableName: capturedMeta.tableName };
const metadataGenerationAtStart = connectionStore.metadataGenerationFor(tab.connectionId, tab.database);
const metadataSchema = metadataSchemaForConnection(connection, tab.database, capturedSchema);
// 分组含 tableType:主键计算依赖它,不同 tableType 不能共享加载结果
const catalogKey = `${capturedMeta.catalog ?? ""}\u0000${capturedMeta.tableType ?? ""}`;
let metadata = loadedByCatalog.get(catalogKey);
if (!metadata) {
metadata = (
await loadTableMetadata({
connectionId: tab.connectionId,
database: tab.database,
schema: metadataSchema,
tableName: capturedMeta.tableName,
tableType: capturedMeta.tableType,
databaseType: effectiveDatabaseTypeForConnection(connection) ?? connection?.db_type ?? "",
driverProfile: connection?.driver_profile || connection?.db_type,
catalog: capturedMeta.catalog,
force: true,
})
).metadata;
loadedByCatalog.set(catalogKey, metadata);
}
const currentTab = queryStore.tabs.find((item) => item.id === tab.id);
if (connectionStore.metadataGenerationFor(tab.connectionId, tab.database) !== metadataGenerationAtStart) continue;
if (!canApplyDataTabMetadata(currentTab, capturedTarget)) continue;
queryStore.setTableMeta(tab.id, {
...capturedMeta,
schema: capturedSchema,
columns: metadata.columns,
primaryKeys: metadata.primaryKeys,
});
if (tab.id === queryStore.activeTabId) await reloadData();
} catch (e: any) {
toast(e?.message || String(e), 5000);
}
}
}
return { openLineageTarget, openDatabaseSearchTarget, openDiagramTarget, openObjectBrowserTableTarget, onStructureEditorSaved, openTableTarget };
}