diff --git a/apps/desktop/src/components/layout/EditorToolbar.vue b/apps/desktop/src/components/layout/EditorToolbar.vue index ff57996553..70b3bf4c42 100644 --- a/apps/desktop/src/components/layout/EditorToolbar.vue +++ b/apps/desktop/src/components/layout/EditorToolbar.vue @@ -15,7 +15,7 @@ import { connectionIconType } from "@/lib/connection/connectionPresentation"; import { formatDatabaseLabel, isDefaultDatabase } from "@/lib/database/defaultDatabase"; import { connectionDisplayName } from "@/lib/tabs/tabPresentation"; import { buildConnectionGroupPathMap } from "@/lib/sidebar/sidebarLayout"; -import { isSingleDatabase, supportsSqlInListPaste, supportsTransaction as supportsTransactionFeature } from "@/lib/database/databaseCapabilities"; +import { isSingleDatabase, supportsClearableQuerySchema, supportsSqlInListPaste, supportsTransaction as supportsTransactionFeature } from "@/lib/database/databaseCapabilities"; import { hexToRgba } from "@/lib/common/color"; import { productionContextForDatabase } from "@/lib/database/productionSafety"; import type { QueryTab, ConnectionConfig } from "@/types/database"; @@ -411,6 +411,7 @@ function databaseOptionIsProduction(database: string): boolean { :empty-text="t('grid.noSearchResults')" :loading-text="t('common.loading')" :loading="!!activeConnection && isLoadingSchemas(activeConnection.id, schemaDatabaseKey)" + :clear-selected-option="supportsClearableQuerySchema(activeConnection?.db_type)" trigger-class="gap-1.5" @update:model-value="(schema) => emit('changeSchema', schema || undefined)" @update:open=" diff --git a/apps/desktop/src/components/ui/searchable-select/SearchableSelect.vue b/apps/desktop/src/components/ui/searchable-select/SearchableSelect.vue index f982b9af20..b8de44f543 100644 --- a/apps/desktop/src/components/ui/searchable-select/SearchableSelect.vue +++ b/apps/desktop/src/components/ui/searchable-select/SearchableSelect.vue @@ -33,12 +33,14 @@ const props = withDefaults( optionTooltip?: (option: string) => string | undefined; normalizeCustom?: (value: string) => string; clearable?: boolean; + clearSelectedOption?: boolean; }>(), { loading: false, disabled: false, allowCustom: false, clearable: false, + clearSelectedOption: false, loadingText: "Loading...", triggerVariant: "ghost", triggerIconClass: "h-3 w-3", @@ -183,6 +185,10 @@ function selectOption(option: string) { open.value = false; } +function selectOrClearOption(option: string) { + selectOption(props.clearSelectedOption && option === props.modelValue ? "" : option); +} + function selectCustomOption() { if (!canSelectCustom.value) return; selectOption(customOptionValue.value); @@ -214,7 +220,7 @@ function handleKeydown(event: KeyboardEvent) { if (highlightIndex.value < 0 || highlightIndex.value >= optionCount()) return; event.preventDefault(); if (highlightIndex.value < filteredOptions.value.length) { - selectOption(filteredOptions.value[highlightIndex.value]); + selectOrClearOption(filteredOptions.value[highlightIndex.value]); } else { selectCustomOption(); } @@ -255,15 +261,18 @@ function handleKeydown(event: KeyboardEvent) { :title="optionTooltip(option) ? undefined : optionTitle(option)" :class=" cn( - 'flex h-8 w-full min-w-0 items-center gap-2 rounded-sm px-2 text-left text-sm hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground focus-visible:outline-none', + 'group flex h-8 w-full min-w-0 items-center gap-2 rounded-sm px-2 text-left text-sm hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground focus-visible:outline-none', props.itemClass, index === highlightIndex && 'bg-accent text-accent-foreground', ) " @pointerenter="activateHelpForOption(option)" - @click="selectOption(option)" + @click="selectOrClearOption(option)" > - + + + + {{ displayName?.(option) }} diff --git a/apps/desktop/src/lib/database/databaseCapabilitySets.ts b/apps/desktop/src/lib/database/databaseCapabilitySets.ts index 3d4511fbe3..8eb4441b50 100644 --- a/apps/desktop/src/lib/database/databaseCapabilitySets.ts +++ b/apps/desktop/src/lib/database/databaseCapabilitySets.ts @@ -39,6 +39,8 @@ export const SCHEMA_AWARE_TYPES = new Set([ export const SINGLE_DATABASE_TYPES = new Set(["oracle", "dameng", "firebird", "oceanbase-oracle", "access", "questdb"]); +export const CLEARABLE_QUERY_SCHEMA_TYPES = new Set(["oracle", "dameng", "oceanbase-oracle"]); + export const FETCH_FIRST_TYPES = new Set(["oracle", "dameng"]); export const TREE_SCHEMA_TYPES = new Set([ diff --git a/apps/desktop/src/lib/database/databaseFeatureSupport.ts b/apps/desktop/src/lib/database/databaseFeatureSupport.ts index 06b503400d..758952b1bf 100644 --- a/apps/desktop/src/lib/database/databaseFeatureSupport.ts +++ b/apps/desktop/src/lib/database/databaseFeatureSupport.ts @@ -1,7 +1,7 @@ import type { ConnectionConfig, DatabaseType, TreeNodeType } from "@/types/database"; import { supportsDatabaseFeature } from "@/lib/database/databaseDriverManifest"; import { canEditTableStructure } from "@/lib/table/tableStructureCapabilities"; -import { DATABASE_OBJECT_TREE_TYPES, FETCH_FIRST_TYPES, PG_LIKE_STRUCTURE_TYPES, SCHEMA_AWARE_TYPES, SINGLE_DATABASE_TYPES, TREE_SCHEMA_TYPES } from "@/lib/database/databaseCapabilitySets"; +import { CLEARABLE_QUERY_SCHEMA_TYPES, DATABASE_OBJECT_TREE_TYPES, FETCH_FIRST_TYPES, PG_LIKE_STRUCTURE_TYPES, SCHEMA_AWARE_TYPES, SINGLE_DATABASE_TYPES, TREE_SCHEMA_TYPES } from "@/lib/database/databaseCapabilitySets"; export function isSchemaAware(dbType?: DatabaseType): boolean { return !!dbType && SCHEMA_AWARE_TYPES.has(dbType); @@ -59,6 +59,10 @@ export function isSingleDatabase(dbType?: DatabaseType): boolean { return !!dbType && SINGLE_DATABASE_TYPES.has(dbType); } +export function supportsClearableQuerySchema(dbType?: DatabaseType): boolean { + return !!dbType && CLEARABLE_QUERY_SCHEMA_TYPES.has(dbType); +} + export function usesFetchFirst(dbType?: DatabaseType): boolean { return !!dbType && FETCH_FIRST_TYPES.has(dbType); } diff --git a/apps/desktop/src/stores/queryStore.ts b/apps/desktop/src/stores/queryStore.ts index 7f240603d4..fb0d0d5c56 100644 --- a/apps/desktop/src/stores/queryStore.ts +++ b/apps/desktop/src/stores/queryStore.ts @@ -28,6 +28,7 @@ import { redisCommandResultToQueryResult } from "@/lib/redis/redisQueryResult"; import { nextRedisCommandDb } from "@/lib/redis/redisCommandSession"; import { isRedisMutatingCommand } from "@/lib/redis/redisCommandTable"; import { usesAgentCursorForQuery } from "@/lib/database/databaseDriverManifest"; +import { supportsClearableQuerySchema } from "@/lib/database/databaseFeatureSupport"; import { canUseKeylessRowPredicate, DBX_ROWID_COLUMN, editablePrimaryKeys, usesSyntheticRowIdKey } from "@/lib/table/tableEditing"; import { TABLE_DATA_EXPORT_PAGE_SIZE } from "@/lib/table/tableDataExport"; import { tableMetaForDataTab } from "@/lib/table/tableDataTabMeta"; @@ -357,6 +358,7 @@ export const useQueryStore = defineStore("query", () => { const closeConfirmContext = ref("tab"); const tableStructureRefreshVersions = ref>({}); const savedSqlEditorPositionTimers = new Map>(); + const pendingTabSessionResets = new Map>(); let resultCacheTrimScheduled = false; let resultCacheTrimRunning = false; let resultCacheTrimRequested = false; @@ -379,7 +381,7 @@ export const useQueryStore = defineStore("query", () => { } const MAX_CACHED_RESULTS = 5; - async function closeResultSession(tab: QueryTab | undefined, preserveSessionId?: string) { + async function closeResultSession(tab: QueryTab | undefined, preserveSessionId?: string, throwOnError = false) { const sessionId = tab?.resultSessionId ?? tab?.result?.session_id; if (!tab || !sessionId || sessionId === preserveSessionId) return; try { @@ -389,28 +391,54 @@ export const useQueryStore = defineStore("query", () => { await api.closeQuerySession(tab.connectionId, executionDatabase, sessionId, tab.id); } catch (error) { console.warn("[DBX][query-session:close:error]", { tabId: tab.id, sessionId, error }); + if (throwOnError) throw error; } finally { if (tab.resultSessionId === sessionId) tab.resultSessionId = undefined; if (tab.result?.session_id === sessionId) tab.result.session_id = undefined; } } - async function closeClientSessionId(connectionId: string, database: string, clientSessionId: string, logContext: Record = {}) { + async function closeClientSessionId(connectionId: string, database: string, clientSessionId: string, logContext: Record = {}, throwOnError = false) { try { await api.closeClientConnectionSession(connectionId, database, clientSessionId); } catch (error) { console.warn("[DBX][client-session:close:error]", { ...logContext, clientSessionId, error }); + if (throwOnError) throw error; } } - async function closeClientConnectionSession(tab: QueryTab | undefined) { + async function closeClientConnectionSession(tab: QueryTab | undefined, throwOnError = false) { if (!tab?.connectionId) return; const catalog = tab.mode === "data" ? tab.tableMeta?.catalog : undefined; const connection = catalog ? useConnectionStore().getConfig(tab.connectionId) : undefined; const executionDatabase = dataTabExecutionDatabase(connection, tab.database, catalog); const clientSessionIds = [...new Set([tabClientSessionId(tab), ...BACKGROUND_CLIENT_SESSION_SUFFIXES.map((suffix) => tabClientSessionId(tab, suffix)), tab.explainClientSessionId].filter((sessionId): sessionId is string => !!sessionId))]; for (const clientSessionId of clientSessionIds) { - await closeClientSessionId(tab.connectionId, executionDatabase, clientSessionId, { tabId: tab.id }); + await closeClientSessionId(tab.connectionId, executionDatabase, clientSessionId, { tabId: tab.id }, throwOnError); + } + } + + function queueTabSessionReset(tab: QueryTab) { + const previousReset = pendingTabSessionResets.get(tab.id); + const reset = (async () => { + if (previousReset) await previousReset; + // A schema reset must fail closed: reusing the old session would retain Oracle CURRENT_SCHEMA. + await closeResultSession(tab, undefined, true); + await closeClientConnectionSession(tab, true); + })(); + pendingTabSessionResets.set(tab.id, reset); + const clearPendingReset = () => { + if (pendingTabSessionResets.get(tab.id) === reset) pendingTabSessionResets.delete(tab.id); + }; + void reset.then(clearPendingReset, clearPendingReset); + } + + async function waitForTabSessionReset(tabId: string) { + while (true) { + const pendingReset = pendingTabSessionResets.get(tabId); + if (!pendingReset) return; + await pendingReset; + if (pendingTabSessionResets.get(tabId) === pendingReset) pendingTabSessionResets.delete(tabId); } } @@ -1985,6 +2013,15 @@ export const useQueryStore = defineStore("query", () => { const tab = tabs.value.find((t) => t.id === id); if (!tab || tab.schema === schema) return; rollbackTabTransaction(tab); + const clearsQuerySchema = tab.mode === "query" && tab.schema && !schema && supportsClearableQuerySchema(useConnectionStore().getConfig(tab.connectionId)?.db_type); + if (clearsQuerySchema) { + queueTabSessionReset(tab); + clearResultPayload(tab); + tab.lastExecutedSql = undefined; + tab.resultBaseSql = undefined; + tab.resultSortedSql = undefined; + clearExplain(tab); + } tab.schema = schema; if (tab.mode === "objects") tab.objectBrowser = { ...tab.objectBrowser, schema, viewport: undefined }; } @@ -2605,6 +2642,7 @@ export const useQueryStore = defineStore("query", () => { let countSql: string | undefined; let useAgentResultSession = false; try { + await waitForTabSessionReset(id); const connStore = useConnectionStore(); let conn = connStore.getConfig(tab.connectionId); const parsedMongoCommands = conn?.db_type === "mongodb" ? splitMongoCommandRanges(sql) : undefined; @@ -3209,6 +3247,16 @@ export const useQueryStore = defineStore("query", () => { tab.explainTableSql = undefined; tab.lastExplainedSql = sql; + try { + await waitForTabSessionReset(id); + } catch (e: any) { + // Do not start an explain with a session whose schema reset did not complete. + tab.isExplaining = false; + tab.explainExecutionId = undefined; + tab.explainError = String(e?.message || e); + return { ok: false as const, reason: tab.explainError }; + } + // DM and Oracle agents expose native text plans. DM also supports autotrace. if (databaseType === "dameng" || databaseType === "oracle") { let explainSql = sql; diff --git a/packages/app-tests/databaseCapabilities.test.ts b/packages/app-tests/databaseCapabilities.test.ts index 93cc8cb2e7..44b7c67d67 100644 --- a/packages/app-tests/databaseCapabilities.test.ts +++ b/packages/app-tests/databaseCapabilities.test.ts @@ -1,6 +1,6 @@ import assert from "node:assert/strict"; import { test } from "vitest"; -import { isSchemaAware, supportsDatabaseCreation, usesTreeSchemaMode } from "../../apps/desktop/src/lib/database/databaseCapabilities.ts"; +import { isSchemaAware, supportsClearableQuerySchema, supportsDatabaseCreation, usesTreeSchemaMode } from "../../apps/desktop/src/lib/database/databaseCapabilities.ts"; test("TDengine uses database/catalog tree nodes without a schema layer", () => { assert.equal(isSchemaAware("tdengine"), false); @@ -16,3 +16,13 @@ test("GoldenDB and Vastbase expose database creation", () => { assert.equal(supportsDatabaseCreation("goldendb"), true); assert.equal(supportsDatabaseCreation("vastbase"), true); }); + +test("only Oracle-compatible single-database schemas can be cleared from query tabs", () => { + assert.equal(supportsClearableQuerySchema("oracle"), true); + assert.equal(supportsClearableQuerySchema("dameng"), true); + assert.equal(supportsClearableQuerySchema("oceanbase-oracle"), true); + assert.equal(supportsClearableQuerySchema("mysql"), false); + assert.equal(supportsClearableQuerySchema("postgres"), false); + assert.equal(supportsClearableQuerySchema("sqlserver"), false); + assert.equal(supportsClearableQuerySchema("jdbc"), false); +}); diff --git a/packages/app-tests/queryStore.test.ts b/packages/app-tests/queryStore.test.ts index 5ea18633c6..f934a8b1b9 100644 --- a/packages/app-tests/queryStore.test.ts +++ b/packages/app-tests/queryStore.test.ts @@ -48,6 +48,13 @@ function oracleConn(id: string): ConnectionConfig { }; } +function oracleCompatibleConn(id: string, dbType: "oracle" | "dameng" | "oceanbase-oracle"): ConnectionConfig { + return { + ...oracleConn(id), + db_type: dbType, + }; +} + function sqlServerConn(id: string): ConnectionConfig { return { ...conn(id), @@ -760,7 +767,10 @@ test("sortTabResultLocally sorts current rows and restores original order", () = [2, "Grace"], [3, "Linus"], ]); - assert.deepEqual(tab.result?.mongo_documents?.map((document) => (document as { id: number }).id), [1, 2, 3]); + assert.deepEqual( + tab.result?.mongo_documents?.map((document) => (document as { id: number }).id), + [1, 2, 3], + ); assert.equal(tab.resultSortColumn, "name"); assert.equal(tab.resultSortColumnIndex, 1); assert.equal(tab.resultSortDirection, "asc"); @@ -774,7 +784,10 @@ test("sortTabResultLocally sorts current rows and restores original order", () = [2, "Grace"], [1, "Ada"], ]); - assert.deepEqual(tab.result?.mongo_documents?.map((document) => (document as { id: number }).id), [3, 2, 1]); + assert.deepEqual( + tab.result?.mongo_documents?.map((document) => (document as { id: number }).id), + [3, 2, 1], + ); store.sortTabResultLocally(tabId, "name", 1, null); @@ -783,7 +796,10 @@ test("sortTabResultLocally sorts current rows and restores original order", () = [1, "Ada"], [3, "Linus"], ]); - assert.deepEqual(tab.result?.mongo_documents?.map((document) => (document as { id: number }).id), [2, 1, 3]); + assert.deepEqual( + tab.result?.mongo_documents?.map((document) => (document as { id: number }).id), + [2, 1, 3], + ); assert.equal(tab.resultSortColumn, undefined); assert.equal(tab.resultSortMode, undefined); }); @@ -920,7 +936,10 @@ test("removing the active result run clears output when remaining caches are una assert.equal(tab.activeResultRunId, undefined); assert.equal(tab.result, undefined); assert.equal(tab.results, undefined); - assert.deepEqual(tab.resultRuns?.map((run) => run.id), ["run-2"]); + assert.deepEqual( + tab.resultRuns?.map((run) => run.id), + ["run-2"], + ); }); test("removed result runs are excluded from result archives", async () => { @@ -4134,6 +4153,187 @@ test("closing a data tab releases its tab-scoped client session", async () => { } }); +for (const dbType of ["oracle", "dameng", "oceanbase-oracle"] as const) { + test(`clearing a ${dbType} query schema releases its tab-scoped client session`, async () => { + const restoreStorage = installMemoryStorage(); + setActivePinia(createPinia()); + const connectionStore = useConnectionStore(); + const store = useQueryStore(); + const originalFetch = globalThis.fetch; + const connectionId = `${dbType}-1`; + + connectionStore.addEphemeralConnection(oracleCompatibleConn(connectionId, dbType)); + const tabId = store.createTab(connectionId, "SERVICE", "Query", "query", "REPORTING"); + const closedSessions: any[] = []; + + globalThis.fetch = async (input, init) => { + const url = String(input); + if (url === "/api/query/close-client-session") { + closedSessions.push(JSON.parse(String(init?.body ?? "{}"))); + return new Response(JSON.stringify(true), { + status: 200, + headers: { "Content-Type": "application/json" }, + }); + } + return new Response("unexpected request", { status: 500 }); + }; + + try { + store.updateSchema(tabId, undefined); + + await waitFor(() => closedSessions.some((body) => body.clientSessionId === tabId)); + assert.equal(store.tabs.find((tab) => tab.id === tabId)?.schema, undefined); + assert.ok( + closedSessions.some((body) => body.connectionId === connectionId && body.database === "SERVICE" && body.clientSessionId === tabId), + `expected close-client-session for cleared query schema, got ${JSON.stringify(closedSessions)}`, + ); + } finally { + globalThis.fetch = originalFetch; + restoreStorage(); + } + }); +} + +test("query execution waits for a cleared schema client session to close", async () => { + const restoreStorage = installMemoryStorage(); + setActivePinia(createPinia()); + const connectionStore = useConnectionStore(); + const store = useQueryStore(); + const originalFetch = globalThis.fetch; + + connectionStore.addEphemeralConnection(oracleConn("oracle-1")); + const tabId = store.createTab("oracle-1", "ORCL", "Query", "query", "REPORTING"); + let resolveClientSessionClose: ((response: Response) => void) | undefined; + let executeRequests = 0; + + globalThis.fetch = async (input) => { + const url = String(input); + if (url === "/api/query/close-client-session") { + if (!resolveClientSessionClose) { + return new Promise((resolve) => { + resolveClientSessionClose = resolve; + }); + } + return new Response(JSON.stringify(true), { status: 200, headers: { "Content-Type": "application/json" } }); + } + if (url === "/api/query/prepare-pagination-plan") { + return new Response( + JSON.stringify({ + sqlToExecute: "select 1", + pageLimit: 100, + pageOffset: 0, + useAgentResultSession: false, + }), + { status: 200, headers: { "Content-Type": "application/json" } }, + ); + } + if (url === "/api/query/execute-multi") { + executeRequests += 1; + return new Response(JSON.stringify([{ columns: [], rows: [], affected_rows: 0, execution_time_ms: 1 }]), { + status: 200, + headers: { "Content-Type": "application/json" }, + }); + } + return new Response("unexpected request", { status: 500 }); + }; + + try { + store.updateSchema(tabId, undefined); + const execution = store.executeTabSql(tabId, "select 1", { skipEnsureConnected: true }); + + await waitFor(() => !!resolveClientSessionClose); + await Promise.resolve(); + assert.equal(executeRequests, 0); + + resolveClientSessionClose!(new Response(JSON.stringify(true), { status: 200, headers: { "Content-Type": "application/json" } })); + await execution; + assert.equal(executeRequests, 1); + } finally { + globalThis.fetch = originalFetch; + restoreStorage(); + } +}); + +test("failed schema session reset blocks query and Oracle explain execution", async () => { + const restoreStorage = installMemoryStorage(); + setActivePinia(createPinia()); + const connectionStore = useConnectionStore(); + const store = useQueryStore(); + const originalFetch = globalThis.fetch; + let executeRequests = 0; + let explainRequests = 0; + + connectionStore.addEphemeralConnection(oracleConn("oracle-1")); + const queryTabId = store.createTab("oracle-1", "ORCL", "Query", "query", "REPORTING"); + const explainTabId = store.createTab("oracle-1", "ORCL", "Explain", "query", "REPORTING"); + + globalThis.fetch = async (input) => { + const url = String(input); + if (url === "/api/query/close-client-session") return new Response("reset failed", { status: 500 }); + if (url === "/api/query/execute-multi") { + executeRequests += 1; + return new Response(JSON.stringify([]), { status: 200, headers: { "Content-Type": "application/json" } }); + } + if (url === "/api/query/get-explain-info") { + explainRequests += 1; + return new Response("unexpected explain request", { status: 500 }); + } + return new Response("unexpected request", { status: 500 }); + }; + + try { + store.updateSchema(queryTabId, undefined); + const queryExecution = store.executeTabSql(queryTabId, "select 1", { skipEnsureConnected: true }); + await queryExecution; + const queryTab = store.tabs.find((tab) => tab.id === queryTabId)!; + assert.equal(executeRequests, 0); + assert.equal(queryTab.result?.execution_error, true); + assert.match(String(queryTab.result?.rows[0]?.[0]), /reset failed/i); + + store.updateSchema(explainTabId, undefined); + const explainResult = await store.explainTabSql(explainTabId, "select 1", "oracle"); + const explainTab = store.tabs.find((tab) => tab.id === explainTabId)!; + assert.equal(explainResult.ok, false); + assert.equal(explainRequests, 0); + assert.equal(explainTab.isExplaining, false); + assert.match(explainTab.explainError ?? "", /reset failed/i); + } finally { + globalThis.fetch = originalFetch; + restoreStorage(); + } +}); + +test("clearing a non-clearable query schema does not reset its client session", async () => { + const restoreStorage = installMemoryStorage(); + setActivePinia(createPinia()); + const connectionStore = useConnectionStore(); + const store = useQueryStore(); + const originalFetch = globalThis.fetch; + let closeRequests = 0; + + connectionStore.addEphemeralConnection(conn("pg-1")); + const tabId = store.createTab("pg-1", "app", "Query", "query", "public"); + + globalThis.fetch = async (input) => { + if (String(input) === "/api/query/close-client-session") closeRequests += 1; + return new Response(JSON.stringify(true), { + status: 200, + headers: { "Content-Type": "application/json" }, + }); + }; + + try { + store.updateSchema(tabId, undefined); + await Promise.resolve(); + + assert.equal(store.tabs.find((tab) => tab.id === tabId)?.schema, undefined); + assert.equal(closeRequests, 0); + } finally { + globalThis.fetch = originalFetch; + restoreStorage(); + } +}); + test("query execution keeps automatically counting total rows in the background", async () => { const restoreStorage = installMemoryStorage(); setActivePinia(createPinia());